lib/libc/rpc/clnt_generic.c

   1 /*
   2  * The contents of this file are subject to the Sun Standards
   3  * License Version 1.0 the (the "License";) You may not use
   4  * this file except in compliance with the License.  You may
   5  * obtain a copy of the License at lib/libc/rpc/LICENSE
   6  *
   7  * Software distributed under the License is distributed on
   8  * an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either
   9  * express or implied.  See the License for the specific
  10  * language governing rights and limitations under the License.
  11  *
  12  * The Original Code is Copyright 1998 by Sun Microsystems, Inc
  13  *
  14  * The Initial Developer of the Original Code is:  Sun
  15  * Microsystems, Inc.
  16  *
  17  * All Rights Reserved.
  18  *
  19  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  20  * unrestricted use provided that this legend is included on all tape
  21  * media and as a part of the software program in whole or part.  Users
  22  * may copy or modify Sun RPC without charge, but are not authorized
  23  * to license or distribute it to anyone else except as part of a product or
  24  * program developed by the user.
  25  *
  26  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  27  * WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  29  *
  30  * Sun RPC is provided with no support and without any obligation on the
  31  * part of Sun Microsystems, Inc. to assist in its use, correction,
  32  * modification or enhancement.
  33  *
  34  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  35  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  36  * OR ANY PART THEREOF.
  37  *
  38  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  39  * or profits or other special, indirect and consequential damages, even if
  40  * Sun has been advised of the possibility of such damages.
  41  *
  42  * Sun Microsystems, Inc.
  43  * 2550 Garcia Avenue
  44  * Mountain View, California  94043
  45  *
  46  * @(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI
  47  * @(#)clnt_generic.c   2.2 88/08/01 4.0 RPCSRC
  48  * @(#)clnt_generic.c   1.40    99/04/21 SMI
  49  * $NetBSD: clnt_generic.c,v 1.18 2000/07/06 03:10:34 christos Exp $
  50  * $FreeBSD: src/lib/libc/rpc/clnt_generic.c,v 1.15 2004/10/16 06:11:34 obrien Exp $
  51  */
  52
  53 /*
  54  * Copyright (c) 1986-1996,1998 by Sun Microsystems, Inc.
  55  * All rights reserved.
  56  */
  57 #include "namespace.h"
  58 #include "reentrant.h"
  59 #include <sys/types.h>
  60 #include <sys/fcntl.h>
  61 #include <sys/socket.h>
  62 #include <netinet/in.h>
  63 #include <netinet/tcp.h>
  64 #include <stdio.h>
  65 #include <errno.h>
  66 #include <netdb.h>
  67 #include <syslog.h>
  68 #include <rpc/rpc.h>
  69 #include <rpc/nettype.h>
  70 #include <string.h>
  71 #include <stdlib.h>
  72 #include <unistd.h>
  73 #include "un-namespace.h"
  74 #include "rpc_com.h"
  75
  76 extern bool_t   __rpc_is_local_host(const char *);
  77 int             __rpc_raise_fd(int);
  78
  79 #ifndef NETIDLEN
  80 #define NETIDLEN 32
  81 #endif
  82
  83
  84 /*
  85  * Generic client creation with version checking the value of
  86  * vers_out is set to the highest server supported value
  87  * vers_low <= vers_out <= vers_high  AND an error results
  88  * if this can not be done.
  89  *
  90  * It calls clnt_create_vers_timed() with a NULL value for the timeout
  91  * pointer, which indicates that the default timeout should be used.
  92  */
  93 CLIENT *
  94 clnt_create_vers(const char *hostname, rpcprog_t prog, rpcvers_t *vers_out,
  95                  rpcvers_t vers_low, rpcvers_t vers_high, const char *nettype)
  96 {
  97
  98         return (clnt_create_vers_timed(hostname, prog, vers_out, vers_low,
  99                                 vers_high, nettype, NULL));
 100 }
 101
 102 /*
 103  * This the routine has the same definition as clnt_create_vers(),
 104  * except it takes an additional timeout parameter - a pointer to
 105  * a timeval structure.  A NULL value for the pointer indicates
 106  * that the default timeout value should be used.
 107  */
 108 CLIENT *
 109 clnt_create_vers_timed(const char *hostname, rpcprog_t prog,
 110     rpcvers_t *vers_out, rpcvers_t vers_low, rpcvers_t vers_high,
 111     const char *nettype, const struct timeval *tp)
 112 {
 113         CLIENT *clnt;
 114         struct timeval to;
 115         enum clnt_stat rpc_stat;
 116         struct rpc_err rpcerr;
 117
 118         clnt = clnt_create_timed(hostname, prog, vers_high, nettype, tp);
 119         if (clnt == NULL) {
 120                 return (NULL);
 121         }
 122         to.tv_sec = 10;
 123         to.tv_usec = 0;
 124         rpc_stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void,
 125                         NULL, (xdrproc_t)xdr_void, NULL, to);
 126         if (rpc_stat == RPC_SUCCESS) {
 127                 *vers_out = vers_high;
 128                 return (clnt);
 129         }
 130         while (rpc_stat == RPC_PROGVERSMISMATCH && vers_high > vers_low) {
 131                 unsigned int minvers, maxvers;
 132
 133                 clnt_geterr(clnt, &rpcerr);
 134                 minvers = rpcerr.re_vers.low;
 135                 maxvers = rpcerr.re_vers.high;
 136                 if (maxvers < vers_high)
 137                         vers_high = maxvers;
 138                 else
 139                         vers_high--;
 140                 if (minvers > vers_low)
 141                         vers_low = minvers;
 142                 if (vers_low > vers_high) {
 143                         goto error;
 144                 }
 145                 CLNT_CONTROL(clnt, CLSET_VERS, (char *)&vers_high);
 146                 rpc_stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void,
 147                                 NULL, (xdrproc_t)xdr_void,
 148                                 NULL, to);
 149                 if (rpc_stat == RPC_SUCCESS) {
 150                         *vers_out = vers_high;
 151                         return (clnt);
 152                 }
 153         }
 154         clnt_geterr(clnt, &rpcerr);
 155
 156 error:
 157         rpc_createerr.cf_stat = rpc_stat;
 158         rpc_createerr.cf_error = rpcerr;
 159         clnt_destroy(clnt);
 160         return (NULL);
 161 }
 162
 163 /*
 164  * Top level client creation routine.
 165  * Generic client creation: takes (servers name, program-number, nettype) and
 166  * returns client handle. Default options are set, which the user can
 167  * change using the rpc equivalent of _ioctl()'s.
 168  *
 169  * It tries for all the netids in that particular class of netid until
 170  * it succeeds.
 171  * XXX The error message in the case of failure will be the one
 172  * pertaining to the last create error.
 173  *
 174  * It calls clnt_create_timed() with the default timeout.
 175  */
 176 CLIENT *
 177 clnt_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,
 178     const char *nettype)
 179 {
 180
 181         return (clnt_create_timed(hostname, prog, vers, nettype, NULL));
 182 }
 183
 184 /*
 185  * This the routine has the same definition as clnt_create(),
 186  * except it takes an additional timeout parameter - a pointer to
 187  * a timeval structure.  A NULL value for the pointer indicates
 188  * that the default timeout value should be used.
 189  *
 190  * This function calls clnt_tp_create_timed().
 191  */
 192 CLIENT *
 193 clnt_create_timed(const char *hostname, rpcprog_t prog, rpcvers_t vers,
 194     const char *netclass, const struct timeval *tp)
 195 {
 196         struct netconfig *nconf;
 197         CLIENT *clnt = NULL;
 198         void *handle;
 199         enum clnt_stat  save_cf_stat = RPC_SUCCESS;
 200         struct rpc_err  save_cf_error;
 201         char nettype_array[NETIDLEN];
 202         char *nettype = &nettype_array[0];
 203
 204         if (netclass == NULL)
 205                 nettype = NULL;
 206         else {
 207                 size_t len = strlen(netclass);
 208                 if (len >= sizeof (nettype_array)) {
 209                         rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 210                         return (NULL);
 211                 }
 212                 strcpy(nettype, netclass);
 213         }
 214
 215         if ((handle = __rpc_setconf((char *)nettype)) == NULL) {
 216                 rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 217                 return (NULL);
 218         }
 219         rpc_createerr.cf_stat = RPC_SUCCESS;
 220         while (clnt == NULL) {
 221                 if ((nconf = __rpc_getconf(handle)) == NULL) {
 222                         if (rpc_createerr.cf_stat == RPC_SUCCESS)
 223                                 rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 224                         break;
 225                 }
 226 #ifdef CLNT_DEBUG
 227                 printf("trying netid %s\n", nconf->nc_netid);
 228 #endif
 229                 clnt = clnt_tp_create_timed(hostname, prog, vers, nconf, tp);
 230                 if (clnt)
 231                         break;
 232                 else
 233                         /*
 234                          *      Since we didn't get a name-to-address
 235                          *      translation failure here, we remember
 236                          *      this particular error.  The object of
 237                          *      this is to enable us to return to the
 238                          *      caller a more-specific error than the
 239                          *      unhelpful ``Name to address translation
 240                          *      failed'' which might well occur if we
 241                          *      merely returned the last error (because
 242                          *      the local loopbacks are typically the
 243                          *      last ones in /etc/netconfig and the most
 244                          *      likely to be unable to translate a host
 245                          *      name).  We also check for a more
 246                          *      meaningful error than ``unknown host
 247                          *      name'' for the same reasons.
 248                          */
 249                         if (rpc_createerr.cf_stat != RPC_N2AXLATEFAILURE &&
 250                             rpc_createerr.cf_stat != RPC_UNKNOWNHOST) {
 251                                 save_cf_stat = rpc_createerr.cf_stat;
 252                                 save_cf_error = rpc_createerr.cf_error;
 253                         }
 254         }
 255
 256         /*
 257          *      Attempt to return an error more specific than ``Name to address
 258          *      translation failed'' or ``unknown host name''
 259          */
 260         if ((rpc_createerr.cf_stat == RPC_N2AXLATEFAILURE ||
 261                                 rpc_createerr.cf_stat == RPC_UNKNOWNHOST) &&
 262                                         (save_cf_stat != RPC_SUCCESS)) {
 263                 rpc_createerr.cf_stat = save_cf_stat;
 264                 rpc_createerr.cf_error = save_cf_error;
 265         }
 266         __rpc_endconf(handle);
 267         return (clnt);
 268 }
 269
 270 /*
 271  * Generic client creation: takes (servers name, program-number, netconf) and
 272  * returns client handle. Default options are set, which the user can
 273  * change using the rpc equivalent of _ioctl()'s : clnt_control()
 274  * It finds out the server address from rpcbind and calls clnt_tli_create().
 275  *
 276  * It calls clnt_tp_create_timed() with the default timeout.
 277  */
 278 CLIENT *
 279 clnt_tp_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,
 280     const struct netconfig *nconf)
 281 {
 282
 283         return (clnt_tp_create_timed(hostname, prog, vers, nconf, NULL));
 284 }
 285
 286 /*
 287  * This has the same definition as clnt_tp_create(), except it
 288  * takes an additional parameter - a pointer to a timeval structure.
 289  * A NULL value for the timeout pointer indicates that the default
 290  * value for the timeout should be used.
 291  */
 292 CLIENT *
 293 clnt_tp_create_timed(const char *hostname, rpcprog_t prog, rpcvers_t vers,
 294     const struct netconfig *nconf, const struct timeval *tp)
 295 {
 296         struct netbuf *svcaddr;                 /* servers address */
 297         CLIENT *cl = NULL;                      /* client handle */
 298
 299         if (nconf == NULL) {
 300                 rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 301                 return (NULL);
 302         }
 303
 304         /*
 305          * Get the address of the server
 306          */
 307         if ((svcaddr = __rpcb_findaddr_timed(prog, vers,
 308                         (struct netconfig *)nconf, (char *)hostname,
 309                         &cl, (struct timeval *)tp)) == NULL) {
 310                 /* appropriate error number is set by rpcbind libraries */
 311                 return (NULL);
 312         }
 313         if (cl == NULL) {
 314                 cl = clnt_tli_create(RPC_ANYFD, nconf, svcaddr,
 315                                         prog, vers, 0, 0);
 316         } else {
 317                 /* Reuse the CLIENT handle and change the appropriate fields */
 318                 if (CLNT_CONTROL(cl, CLSET_SVC_ADDR, (void *)svcaddr) == TRUE) {
 319                         if (cl->cl_netid == NULL)
 320                                 cl->cl_netid = strdup(nconf->nc_netid);
 321                         if (cl->cl_tp == NULL)
 322                                 cl->cl_tp = strdup(nconf->nc_device);
 323                         CLNT_CONTROL(cl, CLSET_PROG, (void *)&prog);
 324                         CLNT_CONTROL(cl, CLSET_VERS, (void *)&vers);
 325                 } else {
 326                         CLNT_DESTROY(cl);
 327                         cl = clnt_tli_create(RPC_ANYFD, nconf, svcaddr,
 328                                         prog, vers, 0, 0);
 329                 }
 330         }
 331         free(svcaddr->buf);
 332         free(svcaddr);
 333         return (cl);
 334 }
 335
 336 /*
 337  * Generic client creation:  returns client handle.
 338  * Default options are set, which the user can
 339  * change using the rpc equivalent of _ioctl()'s : clnt_control().
 340  * If fd is RPC_ANYFD, it will be opened using nconf.
 341  * It will be bound if not so.
 342  * If sizes are 0; appropriate defaults will be chosen.
 343  */
 344 CLIENT *
 345 clnt_tli_create(int fd, const struct netconfig *nconf,
 346         struct netbuf *svcaddr, rpcprog_t prog, rpcvers_t vers,
 347         uint sendsz, uint recvsz)
 348 {
 349         CLIENT *cl;                     /* client handle */
 350         bool_t madefd = FALSE;          /* whether fd opened here */
 351         long servtype;
 352         int one = 1;
 353         struct __rpc_sockinfo si;
 354         extern int __rpc_minfd;
 355
 356         if (fd == RPC_ANYFD) {
 357                 if (nconf == NULL) {
 358                         rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 359                         return (NULL);
 360                 }
 361
 362                 fd = __rpc_nconf2fd(nconf);
 363
 364                 if (fd == -1)
 365                         goto err;
 366                 if (fd < __rpc_minfd)
 367                         fd = __rpc_raise_fd(fd);
 368                 madefd = TRUE;
 369                 servtype = nconf->nc_semantics;
 370                 if (!__rpc_fd2sockinfo(fd, &si))
 371                         goto err;
 372                 bindresvport(fd, NULL);
 373         } else {
 374                 if (!__rpc_fd2sockinfo(fd, &si))
 375                         goto err;
 376                 servtype = __rpc_socktype2seman(si.si_socktype);
 377                 if (servtype == -1) {
 378                         rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 379                         return (NULL);
 380                 }
 381         }
 382
 383         if (si.si_af != ((struct sockaddr *)svcaddr->buf)->sa_family) {
 384                 rpc_createerr.cf_stat = RPC_UNKNOWNHOST;        /* XXX */
 385                 goto err1;
 386         }
 387
 388         switch (servtype) {
 389         case NC_TPI_COTS:
 390                 cl = clnt_vc_create(fd, svcaddr, prog, vers, sendsz, recvsz);
 391                 break;
 392         case NC_TPI_COTS_ORD:
 393                 if (nconf && ((strcmp(nconf->nc_protofmly, "inet") == 0))) {
 394                         _setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one,
 395                             sizeof (one));
 396                 }
 397                 cl = clnt_vc_create(fd, svcaddr, prog, vers, sendsz, recvsz);
 398                 break;
 399         case NC_TPI_CLTS:
 400                 cl = clnt_dg_create(fd, svcaddr, prog, vers, sendsz, recvsz);
 401                 break;
 402         default:
 403                 goto err;
 404         }
 405
 406         if (cl == NULL)
 407                 goto err1; /* borrow errors from clnt_dg/vc creates */
 408         if (nconf) {
 409                 cl->cl_netid = strdup(nconf->nc_netid);
 410                 cl->cl_tp = strdup(nconf->nc_device);
 411         } else {
 412                 cl->cl_netid = "";
 413                 cl->cl_tp = "";
 414         }
 415         if (madefd) {
 416                 CLNT_CONTROL(cl, CLSET_FD_CLOSE, NULL);
 417 /*              CLNT_CONTROL(cl, CLSET_POP_TIMOD, NULL);  */
 418         }
 419
 420         return (cl);
 421
 422 err:
 423         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 424         rpc_createerr.cf_error.re_errno = errno;
 425 err1:   if (madefd)
 426                 _close(fd);
 427         return (NULL);
 428 }
 429
 430 /*
 431  *  To avoid conflicts with the "magic" file descriptors (0, 1, and 2),
 432  *  we try to not use them.  The __rpc_raise_fd() routine will dup
 433  *  a descriptor to a higher value.  If we fail to do it, we continue
 434  *  to use the old one (and hope for the best).
 435  */
 436 int __rpc_minfd = 3;
 437
 438 int
 439 __rpc_raise_fd(int fd)
 440 {
 441         int nfd;
 442
 443         if (fd >= __rpc_minfd)
 444                 return (fd);
 445
 446         if ((nfd = _fcntl(fd, F_DUPFD, __rpc_minfd)) == -1)
 447                 return (fd);
 448
 449         if (_fsync(nfd) == -1) {
 450                 _close(nfd);
 451                 return (fd);
 452         }
 453
 454         if (_close(fd) == -1) {
 455                 /* this is okay, we will syslog an error, then use the new fd */
 456                 syslog(LOG_ERR, "could not close() fd %d; mem & fd leak", fd);
 457         }
 458
 459         return (nfd);
 460 }