1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 
  23 /*
  24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27 /*
  28  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  29  */
  30 
  31 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  32 /* All Rights Reserved */
  33 /*
  34  * Portions of this source code were derived from Berkeley
  35  * 4.3 BSD under license from the Regents of the University of
  36  * California.
  37  */
  38 /*
  39  * Copyright 2014 Shruti V Sampat <shrutisampat@gmail.com>
  40  */
  41 
  42 /*
  43  * Implements a connectionless client side RPC.
  44  */
  45 
  46 #include "mt.h"
  47 #include "rpc_mt.h"
  48 #include <assert.h>
  49 #include <rpc/rpc.h>
  50 #include <errno.h>
  51 #include <sys/poll.h>
  52 #include <syslog.h>
  53 #include <sys/types.h>
  54 #include <sys/kstat.h>
  55 #include <sys/time.h>
  56 #include <stdlib.h>
  57 #include <unistd.h>
  58 #include <sys/types.h>
  59 #include <sys/stat.h>
  60 #include <strings.h>
  61 #include <note.h>
  62 
  63 extern int __rpc_timeval_to_msec(struct timeval *);
  64 extern bool_t xdr_opaque_auth(XDR *, struct opaque_auth *);
  65 extern bool_t __rpc_gss_wrap(AUTH *, char *, uint_t, XDR *, bool_t (*)(),
  66                                                                 caddr_t);
  67 extern bool_t __rpc_gss_unwrap(AUTH *, XDR *, bool_t (*)(), caddr_t);
  68 
  69 
  70 static struct clnt_ops *clnt_dg_ops(void);
  71 static bool_t time_not_ok(struct timeval *);
  72 
  73 /*
  74  *      This machinery implements per-fd locks for MT-safety.  It is not
  75  *      sufficient to do per-CLIENT handle locks for MT-safety because a
  76  *      user may create more than one CLIENT handle with the same fd behind
  77  *      it.
  78  *
  79  *      The current implementation holds locks across the entire RPC and reply,
  80  *      including retransmissions.  Yes, this is silly, and as soon as this
  81  *      code is proven to work, this should be the first thing fixed.  One step
  82  *      at a time.
  83  */
  84 
  85 /*
  86  * FD Lock handle used by various MT sync. routines
  87  */
  88 static mutex_t dgtbl_lock = DEFAULTMUTEX;
  89 static  void    *dgtbl = NULL;
  90 
  91 static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
  92 
  93 
  94 #define MCALL_MSG_SIZE 24
  95 
  96 /*
  97  * Private data kept per client handle
  98  */
  99 struct cu_data {
 100         int                     cu_fd;          /* connections fd */
 101         bool_t                  cu_closeit;     /* opened by library */
 102         struct netbuf           cu_raddr;       /* remote address */
 103         struct timeval          cu_wait;        /* retransmit interval */
 104         struct timeval          cu_total;       /* total time for the call */
 105         struct rpc_err          cu_error;
 106         struct t_unitdata       *cu_tr_data;
 107         XDR                     cu_outxdrs;
 108         char                    *cu_outbuf_start;
 109         char                    cu_outbuf[MCALL_MSG_SIZE];
 110         uint_t                  cu_xdrpos;
 111         uint_t                  cu_sendsz;      /* send size */
 112         uint_t                  cu_recvsz;      /* recv size */
 113         struct pollfd           pfdp;
 114         char                    cu_inbuf[1];
 115 };
 116 
 117 static int _rcv_unitdata_err(struct cu_data *cu);
 118 
 119 /*
 120  * Connection less client creation returns with client handle parameters.
 121  * Default options are set, which the user can change using clnt_control().
 122  * fd should be open and bound.
 123  * NB: The rpch->cl_auth is initialized to null authentication.
 124  *      Caller may wish to set this something more useful.
 125  *
 126  * sendsz and recvsz are the maximum allowable packet sizes that can be
 127  * sent and received. Normally they are the same, but they can be
 128  * changed to improve the program efficiency and buffer allocation.
 129  * If they are 0, use the transport default.
 130  *
 131  * If svcaddr is NULL, returns NULL.
 132  */
 133 CLIENT *
 134 clnt_dg_create(const int fd, struct netbuf *svcaddr, const rpcprog_t program,
 135         const rpcvers_t version, const uint_t sendsz, const uint_t recvsz)
 136 {
 137         CLIENT *cl = NULL;              /* client handle */
 138         struct cu_data *cu = NULL;      /* private data */
 139         struct t_unitdata *tr_data;
 140         struct t_info tinfo;
 141         struct timeval now;
 142         struct rpc_msg call_msg;
 143         uint_t ssz;
 144         uint_t rsz;
 145 
 146         sig_mutex_lock(&dgtbl_lock);
 147         if ((dgtbl == NULL) && ((dgtbl = rpc_fd_init()) == NULL)) {
 148                 sig_mutex_unlock(&dgtbl_lock);
 149                 goto err1;
 150         }
 151         sig_mutex_unlock(&dgtbl_lock);
 152 
 153         if (svcaddr == NULL) {
 154                 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
 155                 return (NULL);
 156         }
 157         if (t_getinfo(fd, &tinfo) == -1) {
 158                 rpc_createerr.cf_stat = RPC_TLIERROR;
 159                 rpc_createerr.cf_error.re_errno = 0;
 160                 rpc_createerr.cf_error.re_terrno = t_errno;
 161                 return (NULL);
 162         }
 163         /*
 164          * Setup to rcv datagram error, we ignore any errors returned from
 165          * __rpc_tli_set_options() as SO_DGRAM_ERRIND is only relevant to
 166          * udp/udp6 transports and this point in the code we only know that
 167          * we are using a connection less transport.
 168          */
 169         if (tinfo.servtype == T_CLTS)
 170                 (void) __rpc_tli_set_options(fd, SOL_SOCKET, SO_DGRAM_ERRIND,
 171                     1);
 172         /*
 173          * Find the receive and the send size
 174          */
 175         ssz = __rpc_get_t_size((int)sendsz, tinfo.tsdu);
 176         rsz = __rpc_get_t_size((int)recvsz, tinfo.tsdu);
 177         if ((ssz == 0) || (rsz == 0)) {
 178                 rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
 179                 rpc_createerr.cf_error.re_errno = 0;
 180                 rpc_createerr.cf_error.re_terrno = 0;
 181                 return (NULL);
 182         }
 183 
 184         if ((cl = malloc(sizeof (CLIENT))) == NULL)
 185                 goto err1;
 186         /*
 187          * Should be multiple of 4 for XDR.
 188          */
 189         ssz = ((ssz + 3) / 4) * 4;
 190         rsz = ((rsz + 3) / 4) * 4;
 191         cu = malloc(sizeof (*cu) + ssz + rsz);
 192         if (cu == NULL)
 193                 goto err1;
 194         if ((cu->cu_raddr.buf = malloc(svcaddr->len)) == NULL)
 195                 goto err1;
 196         (void) memcpy(cu->cu_raddr.buf, svcaddr->buf, (size_t)svcaddr->len);
 197         cu->cu_raddr.len = cu->cu_raddr.maxlen = svcaddr->len;
 198         cu->cu_outbuf_start = &cu->cu_inbuf[rsz];
 199         /* Other values can also be set through clnt_control() */
 200         cu->cu_wait.tv_sec = 15;     /* heuristically chosen */
 201         cu->cu_wait.tv_usec = 0;
 202         cu->cu_total.tv_sec = -1;
 203         cu->cu_total.tv_usec = -1;
 204         cu->cu_sendsz = ssz;
 205         cu->cu_recvsz = rsz;
 206         (void) gettimeofday(&now, NULL);
 207         call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
 208         call_msg.rm_call.cb_prog = program;
 209         call_msg.rm_call.cb_vers = version;
 210         xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, ssz, XDR_ENCODE);
 211         if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
 212                 rpc_createerr.cf_stat = RPC_CANTENCODEARGS;  /* XXX */
 213                 rpc_createerr.cf_error.re_errno = 0;
 214                 rpc_createerr.cf_error.re_terrno = 0;
 215                 goto err2;
 216         }
 217         cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
 218         XDR_DESTROY(&(cu->cu_outxdrs));
 219         xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf_start, ssz, XDR_ENCODE);
 220 /* LINTED pointer alignment */
 221         tr_data = (struct t_unitdata *)t_alloc(fd, T_UNITDATA, T_ADDR | T_OPT);
 222         if (tr_data == NULL) {
 223                 goto err1;
 224         }
 225         tr_data->udata.maxlen = cu->cu_recvsz;
 226         tr_data->udata.buf = cu->cu_inbuf;
 227         cu->cu_tr_data = tr_data;
 228 
 229         /*
 230          * By default, closeit is always FALSE. It is users responsibility
 231          * to do a t_close on it, else the user may use clnt_control
 232          * to let clnt_destroy do it for him/her.
 233          */
 234         cu->cu_closeit = FALSE;
 235         cu->cu_fd = fd;
 236         cl->cl_ops = clnt_dg_ops();
 237         cl->cl_private = (caddr_t)cu;
 238         cl->cl_auth = authnone_create();
 239         cl->cl_tp = NULL;
 240         cl->cl_netid = NULL;
 241         cu->pfdp.fd = cu->cu_fd;
 242         cu->pfdp.events = MASKVAL;
 243         return (cl);
 244 err1:
 245         (void) syslog(LOG_ERR, mem_err_clnt_dg);
 246         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 247         rpc_createerr.cf_error.re_errno = errno;
 248         rpc_createerr.cf_error.re_terrno = 0;
 249 err2:
 250         if (cl) {
 251                 free(cl);
 252                 if (cu) {
 253                         free(cu->cu_raddr.buf);
 254                         free(cu);
 255                 }
 256         }
 257         return (NULL);
 258 }
 259 
 260 static enum clnt_stat
 261 clnt_dg_call(CLIENT *cl, rpcproc_t proc, xdrproc_t xargs, caddr_t argsp,
 262         xdrproc_t xresults, caddr_t resultsp, struct timeval utimeout)
 263 {
 264 /* LINTED pointer alignment */
 265         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 266         XDR *xdrs;
 267         int outlen;
 268         struct rpc_msg reply_msg;
 269         XDR reply_xdrs;
 270         struct timeval time_waited;
 271         bool_t ok;
 272         int nrefreshes = 2;             /* number of times to refresh cred */
 273         struct timeval timeout;
 274         struct timeval retransmit_time;
 275         struct timeval poll_time;
 276         struct timeval startime, curtime;
 277         struct t_unitdata tu_data;
 278         int res;                        /* result of operations */
 279         uint32_t x_id;
 280 
 281         if (rpc_fd_lock(dgtbl, cu->cu_fd)) {
 282                 rpc_callerr.re_status = RPC_FAILED;
 283                 rpc_callerr.re_errno = errno;
 284                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 285                 return (RPC_FAILED);
 286         }
 287 
 288         if (cu->cu_total.tv_usec == -1) {
 289                 timeout = utimeout;     /* use supplied timeout */
 290         } else {
 291                 timeout = cu->cu_total;      /* use default timeout */
 292         }
 293 
 294         time_waited.tv_sec = 0;
 295         time_waited.tv_usec = 0;
 296         retransmit_time = cu->cu_wait;
 297 
 298         tu_data.addr = cu->cu_raddr;
 299 
 300 call_again:
 301         xdrs = &(cu->cu_outxdrs);
 302         xdrs->x_op = XDR_ENCODE;
 303         XDR_SETPOS(xdrs, 0);
 304         /*
 305          * Due to little endian byte order, it is necessary to convert to host
 306          * format before incrementing xid.
 307          */
 308         /* LINTED pointer cast */
 309         x_id = ntohl(*(uint32_t *)(cu->cu_outbuf)) + 1;              /* set XID */
 310         /* LINTED pointer cast */
 311         *(uint32_t *)cu->cu_outbuf = htonl(x_id);
 312 
 313         if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) {
 314                 if ((!XDR_PUTBYTES(xdrs, cu->cu_outbuf, cu->cu_xdrpos)) ||
 315                     (!XDR_PUTINT32(xdrs, (int32_t *)&proc)) ||
 316                     (!AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
 317                     (!xargs(xdrs, argsp))) {
 318                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 319                         return (rpc_callerr.re_status = RPC_CANTENCODEARGS);
 320                 }
 321         } else {
 322 /* LINTED pointer alignment */
 323                 uint32_t *u = (uint32_t *)&cu->cu_outbuf[cu->cu_xdrpos];
 324                 IXDR_PUT_U_INT32(u, proc);
 325                 if (!__rpc_gss_wrap(cl->cl_auth, cu->cu_outbuf,
 326                     ((char *)u) - cu->cu_outbuf, xdrs, xargs, argsp)) {
 327                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 328                         return (rpc_callerr.re_status = RPC_CANTENCODEARGS);
 329                 }
 330         }
 331         outlen = (int)XDR_GETPOS(xdrs);
 332 
 333 send_again:
 334         tu_data.udata.buf = cu->cu_outbuf_start;
 335         tu_data.udata.len = outlen;
 336         tu_data.opt.len = 0;
 337         if (t_sndudata(cu->cu_fd, &tu_data) == -1) {
 338                 rpc_callerr.re_terrno = t_errno;
 339                 rpc_callerr.re_errno = errno;
 340                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 341                 return (rpc_callerr.re_status = RPC_CANTSEND);
 342         }
 343 
 344         /*
 345          * Hack to provide rpc-based message passing
 346          */
 347         if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
 348                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 349                 return (rpc_callerr.re_status = RPC_TIMEDOUT);
 350         }
 351         /*
 352          * sub-optimal code appears here because we have
 353          * some clock time to spare while the packets are in flight.
 354          * (We assume that this is actually only executed once.)
 355          */
 356         reply_msg.acpted_rply.ar_verf = _null_auth;
 357         reply_msg.acpted_rply.ar_results.where = NULL;
 358         reply_msg.acpted_rply.ar_results.proc = xdr_void;
 359 
 360         /*
 361          * Set polling time so that we don't wait for
 362          * longer than specified by the total time to wait,
 363          * or the retransmit time.
 364          */
 365         poll_time.tv_sec = timeout.tv_sec - time_waited.tv_sec;
 366         poll_time.tv_usec = timeout.tv_usec - time_waited.tv_usec;
 367         while (poll_time.tv_usec < 0) {
 368                 poll_time.tv_usec += 1000000;
 369                 poll_time.tv_sec--;
 370         }
 371 
 372         if (poll_time.tv_sec < 0 || (poll_time.tv_sec == 0 &&
 373             poll_time.tv_usec == 0)) {
 374                 /*
 375                  * this could happen if time_waited >= timeout
 376                  */
 377                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 378                 return (rpc_callerr.re_status = RPC_TIMEDOUT);
 379         }
 380 
 381         if (poll_time.tv_sec > retransmit_time.tv_sec ||
 382             (poll_time.tv_sec == retransmit_time.tv_sec &&
 383             poll_time.tv_usec > retransmit_time.tv_usec))
 384                 poll_time = retransmit_time;
 385 
 386 
 387         for (;;) {
 388 
 389                 (void) gettimeofday(&startime, NULL);
 390 
 391                 switch (poll(&cu->pfdp, 1,
 392                     __rpc_timeval_to_msec(&poll_time))) {
 393                 case -1:
 394                         if (errno != EINTR && errno != EAGAIN) {
 395                                 rpc_callerr.re_errno = errno;
 396                                 rpc_callerr.re_terrno = 0;
 397                                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 398                                 return (rpc_callerr.re_status = RPC_CANTRECV);
 399                         }
 400                         /*FALLTHROUGH*/
 401 
 402                 case 0:
 403                         /*
 404                          * update time waited
 405                          */
 406 timeout:                        (void) gettimeofday(&curtime, NULL);
 407                         time_waited.tv_sec += curtime.tv_sec - startime.tv_sec;
 408                         time_waited.tv_usec += curtime.tv_usec -
 409                             startime.tv_usec;
 410                         while (time_waited.tv_usec >= 1000000) {
 411                                 time_waited.tv_usec -= 1000000;
 412                                 time_waited.tv_sec++;
 413                         }
 414                         while (time_waited.tv_usec < 0) {
 415                                 time_waited.tv_usec += 1000000;
 416                                 time_waited.tv_sec--;
 417                         }
 418 
 419                         /*
 420                          * decrement time left to poll by same amount
 421                          */
 422                         poll_time.tv_sec -= curtime.tv_sec - startime.tv_sec;
 423                         poll_time.tv_usec -= curtime.tv_usec - startime.tv_usec;
 424                         while (poll_time.tv_usec >= 1000000) {
 425                                 poll_time.tv_usec -= 1000000;
 426                                 poll_time.tv_sec++;
 427                         }
 428                         while (poll_time.tv_usec < 0) {
 429                                 poll_time.tv_usec += 1000000;
 430                                 poll_time.tv_sec--;
 431                         }
 432 
 433                         /*
 434                          * if there's time left to poll, poll again
 435                          */
 436                         if (poll_time.tv_sec > 0 ||
 437                             (poll_time.tv_sec == 0 && poll_time.tv_usec > 0))
 438                                 continue;
 439 
 440                         /*
 441                          * if there's more time left, retransmit;
 442                          * otherwise, return timeout error
 443                          */
 444                         if (time_waited.tv_sec < timeout.tv_sec ||
 445                             (time_waited.tv_sec == timeout.tv_sec &&
 446                             time_waited.tv_usec < timeout.tv_usec)) {
 447                                 /*
 448                                  * update retransmit_time
 449                                  */
 450                                 retransmit_time.tv_usec *= 2;
 451                                 retransmit_time.tv_sec *= 2;
 452                                 while (retransmit_time.tv_usec >= 1000000) {
 453                                         retransmit_time.tv_usec -= 1000000;
 454                                         retransmit_time.tv_sec++;
 455                                 }
 456                                 if (retransmit_time.tv_sec >= RPC_MAX_BACKOFF) {
 457                                         retransmit_time.tv_sec =
 458                                             RPC_MAX_BACKOFF;
 459                                         retransmit_time.tv_usec = 0;
 460                                 }
 461                                 /*
 462                                  * redo AUTH_MARSHAL if AUTH_DES or RPCSEC_GSS.
 463                                  */
 464                                 if (cl->cl_auth->ah_cred.oa_flavor ==
 465                                     AUTH_DES ||
 466                                     cl->cl_auth->ah_cred.oa_flavor ==
 467                                     RPCSEC_GSS)
 468                                         goto call_again;
 469                                 else
 470                                         goto send_again;
 471                         }
 472                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 473                         return (rpc_callerr.re_status = RPC_TIMEDOUT);
 474 
 475                 default:
 476                         break;
 477                 }
 478 
 479                 if (cu->pfdp.revents & POLLNVAL || (cu->pfdp.revents == 0)) {
 480                         rpc_callerr.re_status = RPC_CANTRECV;
 481                         /*
 482                          *      Note:  we're faking errno here because we
 483                          *      previously would have expected select() to
 484                          *      return -1 with errno EBADF.  Poll(BA_OS)
 485                          *      returns 0 and sets the POLLNVAL revents flag
 486                          *      instead.
 487                          */
 488                         rpc_callerr.re_errno = errno = EBADF;
 489                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 490                         return (-1);
 491                 }
 492 
 493                 /* We have some data now */
 494                 do {
 495                         int moreflag;           /* flag indicating more data */
 496 
 497                         moreflag = 0;
 498 
 499                         res = t_rcvudata(cu->cu_fd, cu->cu_tr_data, &moreflag);
 500 
 501                         if (moreflag & T_MORE) {
 502                                 /*
 503                                  * Drop this packet. I aint got any
 504                                  * more space.
 505                                  */
 506                                 res = -1;
 507                                 /* I should not really be doing this */
 508                                 errno = 0;
 509                                 /*
 510                                  * XXX: Not really Buffer overflow in the
 511                                  * sense of TLI.
 512                                  */
 513                                 t_errno = TBUFOVFLW;
 514                         }
 515                 } while (res < 0 && (t_errno == TSYSERR && errno == EINTR));
 516                 if (res < 0) {
 517                         int err, errnoflag = FALSE;
 518 #ifdef sun
 519                         if (t_errno == TSYSERR && errno == EWOULDBLOCK)
 520 #else
 521                         if (t_errno == TSYSERR && errno == EAGAIN)
 522 #endif
 523                                 continue;
 524                         if (t_errno == TLOOK) {
 525                                 if ((err = _rcv_unitdata_err(cu)) == 0)
 526                                         continue;
 527                                 else if (err == 1)
 528                                         errnoflag = TRUE;
 529                         } else {
 530                                 rpc_callerr.re_terrno = t_errno;
 531                         }
 532                         if (errnoflag == FALSE)
 533                                 rpc_callerr.re_errno = errno;
 534                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 535                         return (rpc_callerr.re_status = RPC_CANTRECV);
 536                 }
 537                 if (cu->cu_tr_data->udata.len < (uint_t)sizeof (uint32_t))
 538                         continue;
 539                 /* see if reply transaction id matches sent id */
 540                 /* LINTED pointer alignment */
 541                 if (*((uint32_t *)(cu->cu_inbuf)) !=
 542                     /* LINTED pointer alignment */
 543                     *((uint32_t *)(cu->cu_outbuf)))
 544                         goto timeout;
 545                 /* we now assume we have the proper reply */
 546                 break;
 547         }
 548 
 549         /*
 550          * now decode and validate the response
 551          */
 552 
 553         xdrmem_create(&reply_xdrs, cu->cu_inbuf,
 554             (uint_t)cu->cu_tr_data->udata.len, XDR_DECODE);
 555         ok = xdr_replymsg(&reply_xdrs, &reply_msg);
 556         /* XDR_DESTROY(&reply_xdrs);        save a few cycles on noop destroy */
 557         if (ok) {
 558                 if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
 559                     (reply_msg.acpted_rply.ar_stat == SUCCESS))
 560                         rpc_callerr.re_status = RPC_SUCCESS;
 561                 else
 562                         __seterr_reply(&reply_msg, &(rpc_callerr));
 563 
 564                 if (rpc_callerr.re_status == RPC_SUCCESS) {
 565                         if (!AUTH_VALIDATE(cl->cl_auth,
 566                             &reply_msg.acpted_rply.ar_verf)) {
 567                                 rpc_callerr.re_status = RPC_AUTHERROR;
 568                                 rpc_callerr.re_why = AUTH_INVALIDRESP;
 569                         } else if (cl->cl_auth->ah_cred.oa_flavor !=
 570                             RPCSEC_GSS) {
 571                                 if (!(*xresults)(&reply_xdrs, resultsp)) {
 572                                         if (rpc_callerr.re_status ==
 573                                             RPC_SUCCESS)
 574                                                 rpc_callerr.re_status =
 575                                                     RPC_CANTDECODERES;
 576                                 }
 577                         } else if (!__rpc_gss_unwrap(cl->cl_auth, &reply_xdrs,
 578                             xresults, resultsp)) {
 579                                 if (rpc_callerr.re_status == RPC_SUCCESS)
 580                                         rpc_callerr.re_status =
 581                                             RPC_CANTDECODERES;
 582                         }
 583                 }               /* end successful completion */
 584                 /*
 585                  * If unsuccesful AND error is an authentication error
 586                  * then refresh credentials and try again, else break
 587                  */
 588                 else if (rpc_callerr.re_status == RPC_AUTHERROR)
 589                         /* maybe our credentials need to be refreshed ... */
 590                         if (nrefreshes-- &&
 591                             AUTH_REFRESH(cl->cl_auth, &reply_msg))
 592                                 goto call_again;
 593                         else
 594                                 /*
 595                                  * We are setting rpc_callerr here given that
 596                                  * libnsl is not reentrant thereby
 597                                  * reinitializing the TSD.  If not set here then
 598                                  * success could be returned even though refresh
 599                                  * failed.
 600                                  */
 601                                 rpc_callerr.re_status = RPC_AUTHERROR;
 602 
 603                 /* end of unsuccessful completion */
 604                 /* free verifier */
 605                 if (reply_msg.rm_reply.rp_stat == MSG_ACCEPTED &&
 606                     reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
 607                         xdrs->x_op = XDR_FREE;
 608                         (void) xdr_opaque_auth(xdrs,
 609                             &(reply_msg.acpted_rply.ar_verf));
 610                 }
 611         }       /* end of valid reply message */
 612         else {
 613                 rpc_callerr.re_status = RPC_CANTDECODERES;
 614 
 615         }
 616         rpc_fd_unlock(dgtbl, cu->cu_fd);
 617         return (rpc_callerr.re_status);
 618 }
 619 
 620 static enum clnt_stat
 621 clnt_dg_send(CLIENT *cl, rpcproc_t proc, xdrproc_t xargs, caddr_t argsp)
 622 {
 623 /* LINTED pointer alignment */
 624         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 625         XDR *xdrs;
 626         int outlen;
 627         struct t_unitdata tu_data;
 628         uint32_t x_id;
 629 
 630         if (rpc_fd_lock(dgtbl, cu->cu_fd)) {
 631                 rpc_callerr.re_status = RPC_FAILED;
 632                 rpc_callerr.re_errno = errno;
 633                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 634                 return (RPC_FAILED);
 635         }
 636 
 637         tu_data.addr = cu->cu_raddr;
 638 
 639         xdrs = &(cu->cu_outxdrs);
 640         xdrs->x_op = XDR_ENCODE;
 641         XDR_SETPOS(xdrs, 0);
 642         /*
 643          * Due to little endian byte order, it is necessary to convert to host
 644          * format before incrementing xid.
 645          */
 646 /* LINTED pointer alignment */
 647         x_id = ntohl(*(uint32_t *)(cu->cu_outbuf)) + 1;              /* set XID */
 648         /* LINTED pointer cast */
 649         *(uint32_t *)cu->cu_outbuf = htonl(x_id);
 650 
 651         if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) {
 652                 if ((!XDR_PUTBYTES(xdrs, cu->cu_outbuf, cu->cu_xdrpos)) ||
 653                     (!XDR_PUTINT32(xdrs, (int32_t *)&proc)) ||
 654                     (!AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
 655                     (!xargs(xdrs, argsp))) {
 656                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 657                         return (rpc_callerr.re_status = RPC_CANTENCODEARGS);
 658                 }
 659         } else {
 660 /* LINTED pointer alignment */
 661                 uint32_t *u = (uint32_t *)&cu->cu_outbuf[cu->cu_xdrpos];
 662                 IXDR_PUT_U_INT32(u, proc);
 663                 if (!__rpc_gss_wrap(cl->cl_auth, cu->cu_outbuf,
 664                     ((char *)u) - cu->cu_outbuf, xdrs, xargs, argsp)) {
 665                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 666                         return (rpc_callerr.re_status = RPC_CANTENCODEARGS);
 667                 }
 668         }
 669         outlen = (int)XDR_GETPOS(xdrs);
 670 
 671         tu_data.udata.buf = cu->cu_outbuf_start;
 672         tu_data.udata.len = outlen;
 673         tu_data.opt.len = 0;
 674         if (t_sndudata(cu->cu_fd, &tu_data) == -1) {
 675                 rpc_callerr.re_terrno = t_errno;
 676                 rpc_callerr.re_errno = errno;
 677                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 678                 return (rpc_callerr.re_status = RPC_CANTSEND);
 679         }
 680 
 681         rpc_fd_unlock(dgtbl, cu->cu_fd);
 682         return (rpc_callerr.re_status = RPC_SUCCESS);
 683 }
 684 
 685 static void
 686 clnt_dg_geterr(CLIENT *cl, struct rpc_err *errp)
 687 {
 688         NOTE(ARGUNUSED(cl))
 689         *errp = rpc_callerr;
 690 }
 691 
 692 static bool_t
 693 clnt_dg_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
 694 {
 695 /* LINTED pointer alignment */
 696         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 697         XDR *xdrs = &(cu->cu_outxdrs);
 698         bool_t stat;
 699 
 700         (void) rpc_fd_lock(dgtbl, cu->cu_fd);
 701         xdrs->x_op = XDR_FREE;
 702         stat = (*xdr_res)(xdrs, res_ptr);
 703         rpc_fd_unlock(dgtbl, cu->cu_fd);
 704         return (stat);
 705 }
 706 
 707 /* ARGSUSED */
 708 static void
 709 clnt_dg_abort(CLIENT *h)
 710 {
 711 }
 712 
 713 static bool_t
 714 clnt_dg_control(CLIENT *cl, int request, char *info)
 715 {
 716 /* LINTED pointer alignment */
 717         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 718         struct netbuf *addr;
 719         if (rpc_fd_lock(dgtbl, cu->cu_fd)) {
 720                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 721                 return (FALSE);
 722         }
 723 
 724         switch (request) {
 725         case CLSET_FD_CLOSE:
 726                 cu->cu_closeit = TRUE;
 727                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 728                 return (TRUE);
 729         case CLSET_FD_NCLOSE:
 730                 cu->cu_closeit = FALSE;
 731                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 732                 return (TRUE);
 733         }
 734 
 735         /* for other requests which use info */
 736         if (info == NULL) {
 737                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 738                 return (FALSE);
 739         }
 740         switch (request) {
 741         case CLSET_TIMEOUT:
 742 /* LINTED pointer alignment */
 743                 if (time_not_ok((struct timeval *)info)) {
 744                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 745                         return (FALSE);
 746                 }
 747 /* LINTED pointer alignment */
 748                 cu->cu_total = *(struct timeval *)info;
 749                 break;
 750         case CLGET_TIMEOUT:
 751 /* LINTED pointer alignment */
 752                 *(struct timeval *)info = cu->cu_total;
 753                 break;
 754         case CLGET_SERVER_ADDR:         /* Give him the fd address */
 755                 /* Now obsolete. Only for backword compatibility */
 756                 (void) memcpy(info, cu->cu_raddr.buf, (size_t)cu->cu_raddr.len);
 757                 break;
 758         case CLSET_RETRY_TIMEOUT:
 759 /* LINTED pointer alignment */
 760                 if (time_not_ok((struct timeval *)info)) {
 761                         rpc_fd_unlock(dgtbl, cu->cu_fd);
 762                         return (FALSE);
 763                 }
 764 /* LINTED pointer alignment */
 765                 cu->cu_wait = *(struct timeval *)info;
 766                 break;
 767         case CLGET_RETRY_TIMEOUT:
 768 /* LINTED pointer alignment */
 769                 *(struct timeval *)info = cu->cu_wait;
 770                 break;
 771         case CLGET_FD:
 772 /* LINTED pointer alignment */
 773                 *(int *)info = cu->cu_fd;
 774                 break;
 775         case CLGET_SVC_ADDR:
 776 /* LINTED pointer alignment */
 777                 *(struct netbuf *)info = cu->cu_raddr;
 778                 break;
 779         case CLSET_SVC_ADDR:            /* set to new address */
 780 /* LINTED pointer alignment */
 781                 addr = (struct netbuf *)info;
 782                 if (cu->cu_raddr.maxlen < addr->len) {
 783                         free(cu->cu_raddr.buf);
 784                         if ((cu->cu_raddr.buf = malloc(addr->len)) == NULL) {
 785                                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 786                                 return (FALSE);
 787                         }
 788                         cu->cu_raddr.maxlen = addr->len;
 789                 }
 790                 cu->cu_raddr.len = addr->len;
 791                 (void) memcpy(cu->cu_raddr.buf, addr->buf, addr->len);
 792                 break;
 793         case CLGET_XID:
 794                 /*
 795                  * use the knowledge that xid is the
 796                  * first element in the call structure *.
 797                  * This will get the xid of the PREVIOUS call
 798                  */
 799 /* LINTED pointer alignment */
 800                 *(uint32_t *)info = ntohl(*(uint32_t *)cu->cu_outbuf);
 801                 break;
 802 
 803         case CLSET_XID:
 804                 /* This will set the xid of the NEXT call */
 805 /* LINTED pointer alignment */
 806                 *(uint32_t *)cu->cu_outbuf =  htonl(*(uint32_t *)info - 1);
 807                 /* decrement by 1 as clnt_dg_call() increments once */
 808                 break;
 809 
 810         case CLGET_VERS:
 811                 /*
 812                  * This RELIES on the information that, in the call body,
 813                  * the version number field is the fifth field from the
 814                  * begining of the RPC header. MUST be changed if the
 815                  * call_struct is changed
 816                  */
 817 /* LINTED pointer alignment */
 818                 *(uint32_t *)info = ntohl(*(uint32_t *)(cu->cu_outbuf +
 819                     4 * BYTES_PER_XDR_UNIT));
 820                 break;
 821 
 822         case CLSET_VERS:
 823 /* LINTED pointer alignment */
 824                 *(uint32_t *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT) =
 825 /* LINTED pointer alignment */
 826                     htonl(*(uint32_t *)info);
 827                 break;
 828 
 829         case CLGET_PROG:
 830                 /*
 831                  * This RELIES on the information that, in the call body,
 832                  * the program number field is the fourth field from the
 833                  * begining of the RPC header. MUST be changed if the
 834                  * call_struct is changed
 835                  */
 836 /* LINTED pointer alignment */
 837                 *(uint32_t *)info = ntohl(*(uint32_t *)(cu->cu_outbuf +
 838                     3 * BYTES_PER_XDR_UNIT));
 839                 break;
 840 
 841         case CLSET_PROG:
 842 /* LINTED pointer alignment */
 843                 *(uint32_t *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT) =
 844 /* LINTED pointer alignment */
 845                     htonl(*(uint32_t *)info);
 846                 break;
 847 
 848         default:
 849                 rpc_fd_unlock(dgtbl, cu->cu_fd);
 850                 return (FALSE);
 851         }
 852         rpc_fd_unlock(dgtbl, cu->cu_fd);
 853         return (TRUE);
 854 }
 855 
 856 static void
 857 clnt_dg_destroy(CLIENT *cl)
 858 {
 859 /* LINTED pointer alignment */
 860         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 861         int cu_fd = cu->cu_fd;
 862 
 863         (void) rpc_fd_lock(dgtbl, cu_fd);
 864         if (cu->cu_closeit)
 865                 (void) t_close(cu_fd);
 866         XDR_DESTROY(&(cu->cu_outxdrs));
 867         cu->cu_tr_data->udata.buf = NULL;
 868         (void) t_free((char *)cu->cu_tr_data, T_UNITDATA);
 869         free(cu->cu_raddr.buf);
 870         free(cu);
 871         if (cl->cl_netid && cl->cl_netid[0])
 872                 free(cl->cl_netid);
 873         if (cl->cl_tp && cl->cl_tp[0])
 874                 free(cl->cl_tp);
 875         free(cl);
 876         rpc_fd_unlock(dgtbl, cu_fd);
 877 }
 878 
 879 static struct clnt_ops *
 880 clnt_dg_ops(void)
 881 {
 882         static struct clnt_ops ops;
 883         extern mutex_t  ops_lock;
 884 
 885 /* VARIABLES PROTECTED BY ops_lock: ops */
 886 
 887         sig_mutex_lock(&ops_lock);
 888         if (ops.cl_call == NULL) {
 889                 ops.cl_call = clnt_dg_call;
 890                 ops.cl_send = clnt_dg_send;
 891                 ops.cl_abort = clnt_dg_abort;
 892                 ops.cl_geterr = clnt_dg_geterr;
 893                 ops.cl_freeres = clnt_dg_freeres;
 894                 ops.cl_destroy = clnt_dg_destroy;
 895                 ops.cl_control = clnt_dg_control;
 896         }
 897         sig_mutex_unlock(&ops_lock);
 898         return (&ops);
 899 }
 900 
 901 /*
 902  * Make sure that the time is not garbage.  -1 value is allowed.
 903  */
 904 static bool_t
 905 time_not_ok(struct timeval *t)
 906 {
 907         return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
 908             t->tv_usec < -1 || t->tv_usec > 1000000);
 909 }
 910 
 911 /*
 912  * Receive a unit data error indication.
 913  * Below even when t_alloc() fails we pass uderr=NULL to t_rcvuderr()
 914  * so as to just clear the error indication.
 915  */
 916 
 917 static int
 918 _rcv_unitdata_err(struct cu_data *cu)
 919 {
 920         int old;
 921         struct t_uderr *uderr;
 922 
 923         old = t_errno;
 924         /* LINTED pointer cast */
 925         uderr = (struct t_uderr *)t_alloc(cu->cu_fd, T_UDERROR, T_ADDR);
 926 
 927         if (t_rcvuderr(cu->cu_fd, uderr) == 0) {
 928                 if (uderr == NULL)
 929                         return (0);
 930 
 931                 if (uderr->addr.len != cu->cu_raddr.len ||
 932                     (memcmp(uderr->addr.buf, cu->cu_raddr.buf,
 933                     cu->cu_raddr.len))) {
 934                         (void) t_free((char *)uderr, T_UDERROR);
 935                         return (0);
 936                 }
 937                 rpc_callerr.re_errno = uderr->error;
 938                 rpc_callerr.re_terrno = TSYSERR;
 939                 (void) t_free((char *)uderr, T_UDERROR);
 940                 return (1);
 941         }
 942         rpc_callerr.re_terrno = old;
 943         if (uderr)
 944                 (void) t_free((char *)uderr, T_UDERROR);
 945         return (-1);
 946 }