sunrpc/svc_udp.c

   1 /*
   2  * svc_udp.c,
   3  * Server side for UDP/IP based RPC.  (Does some caching in the hopes of
   4  * achieving execute-at-most-once semantics.)
   5  *
   6  * Copyright (C) 2012-2016 Free Software Foundation, Inc.
   7  * This file is part of the GNU C Library.
   8  *
   9  * The GNU C Library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * The GNU C Library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with the GNU C Library; if not, see
  21  * <http://www.gnu.org/licenses/>.
  22  *
  23  * Copyright (c) 2010, Oracle America, Inc.
  24  *
  25  * Redistribution and use in source and binary forms, with or without
  26  * modification, are permitted provided that the following conditions are
  27  * met:
  28  *
  29  *     * Redistributions of source code must retain the above copyright
  30  *       notice, this list of conditions and the following disclaimer.
  31  *     * Redistributions in binary form must reproduce the above
  32  *       copyright notice, this list of conditions and the following
  33  *       disclaimer in the documentation and/or other materials
  34  *       provided with the distribution.
  35  *     * Neither the name of the "Oracle America, Inc." nor the names of its
  36  *       contributors may be used to endorse or promote products derived
  37  *       from this software without specific prior written permission.
  38  *
  39  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  40  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  41  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  42  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  43  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  44  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  46  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  47  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  48  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  49  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  50  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  51  */
  52
  53 #include <stdio.h>
  54 #include <unistd.h>
  55 #include <string.h>
  56 #include <rpc/rpc.h>
  57 #include <sys/socket.h>
  58 #include <errno.h>
  59 #include <libintl.h>
  60
  61 #ifdef IP_PKTINFO
  62 #include <sys/uio.h>
  63 #endif
  64
  65 #include <wchar.h>
  66 #include <libio/iolibio.h>
  67
  68 #define rpc_buffer(xprt) ((xprt)->xp_p1)
  69 #ifndef MAX
  70 #define MAX(a, b)     ((a > b) ? a : b)
  71 #endif
  72
  73 static bool_t svcudp_recv (SVCXPRT *, struct rpc_msg *);
  74 static bool_t svcudp_reply (SVCXPRT *, struct rpc_msg *);
  75 static enum xprt_stat svcudp_stat (SVCXPRT *);
  76 static bool_t svcudp_getargs (SVCXPRT *, xdrproc_t, caddr_t);
  77 static bool_t svcudp_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
  78 static void svcudp_destroy (SVCXPRT *);
  79
  80 static const struct xp_ops svcudp_op =
  81 {
  82   svcudp_recv,
  83   svcudp_stat,
  84   svcudp_getargs,
  85   svcudp_reply,
  86   svcudp_freeargs,
  87   svcudp_destroy
  88 };
  89
  90 static int cache_get (SVCXPRT *, struct rpc_msg *, char **replyp,
  91                       u_long *replylenp);
  92 static void cache_set (SVCXPRT *xprt, u_long replylen);
  93
  94 /*
  95  * kept in xprt->xp_p2
  96  */
  97 struct svcudp_data
  98   {
  99     u_int su_iosz;              /* byte size of send.recv buffer */
 100     u_long su_xid;              /* transaction id */
 101     XDR su_xdrs;                /* XDR handle */
 102     char su_verfbody[MAX_AUTH_BYTES];   /* verifier body */
 103     char *su_cache;             /* cached data, NULL if no cache */
 104   };
 105 #define su_data(xprt)   ((struct svcudp_data *)(xprt->xp_p2))
 106
 107 /*
 108  * Usage:
 109  *      xprt = svcudp_create(sock);
 110  *
 111  * If sock<0 then a socket is created, else sock is used.
 112  * If the socket, sock is not bound to a port then svcudp_create
 113  * binds it to an arbitrary port.  In any (successful) case,
 114  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
 115  * associated port number.
 116  * Once *xprt is initialized, it is registered as a transporter;
 117  * see (svc.h, xprt_register).
 118  * The routines returns NULL if a problem occurred.
 119  */
 120 SVCXPRT *
 121 svcudp_bufcreate (int sock, u_int sendsz, u_int recvsz)
 122 {
 123   bool_t madesock = FALSE;
 124   SVCXPRT *xprt;
 125   struct svcudp_data *su;
 126   struct sockaddr_in addr;
 127   socklen_t len = sizeof (struct sockaddr_in);
 128   int pad;
 129   void *buf;
 130
 131   if (sock == RPC_ANYSOCK)
 132     {
 133       if ((sock = __socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
 134         {
 135           perror (_("svcudp_create: socket creation problem"));
 136           return (SVCXPRT *) NULL;
 137         }
 138       madesock = TRUE;
 139     }
 140   __bzero ((char *) &addr, sizeof (addr));
 141   addr.sin_family = AF_INET;
 142   if (bindresvport (sock, &addr))
 143     {
 144       addr.sin_port = 0;
 145       (void) __bind (sock, (struct sockaddr *) &addr, len);
 146     }
 147   if (__getsockname (sock, (struct sockaddr *) &addr, &len) != 0)
 148     {
 149       perror (_("svcudp_create - cannot getsockname"));
 150       if (madesock)
 151         (void) __close (sock);
 152       return (SVCXPRT *) NULL;
 153     }
 154   xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
 155   su = (struct svcudp_data *) mem_alloc (sizeof (*su));
 156   buf = mem_alloc (((MAX (sendsz, recvsz) + 3) / 4) * 4);
 157   if (xprt == NULL || su == NULL || buf == NULL)
 158     {
 159       (void) __fxprintf (NULL, "%s: %s",
 160                          "svcudp_create",  _("out of memory\n"));
 161       mem_free (xprt, sizeof (SVCXPRT));
 162       mem_free (su, sizeof (*su));
 163       mem_free (buf, ((MAX (sendsz, recvsz) + 3) / 4) * 4);
 164       return NULL;
 165     }
 166   su->su_iosz = ((MAX (sendsz, recvsz) + 3) / 4) * 4;
 167   rpc_buffer (xprt) = buf;
 168   xdrmem_create (&(su->su_xdrs), rpc_buffer (xprt), su->su_iosz, XDR_DECODE);
 169   su->su_cache = NULL;
 170   xprt->xp_p2 = (caddr_t) su;
 171   xprt->xp_verf.oa_base = su->su_verfbody;
 172   xprt->xp_ops = &svcudp_op;
 173   xprt->xp_port = ntohs (addr.sin_port);
 174   xprt->xp_sock = sock;
 175
 176 #ifdef IP_PKTINFO
 177   if ((sizeof (struct iovec) + sizeof (struct msghdr)
 178        + sizeof(struct cmsghdr) + sizeof (struct in_pktinfo))
 179       > sizeof (xprt->xp_pad))
 180     {
 181       (void) __fxprintf (NULL,"%s", _("\
 182 svcudp_create: xp_pad is too small for IP_PKTINFO\n"));
 183       return NULL;
 184     }
 185   pad = 1;
 186   if (__setsockopt (sock, SOL_IP, IP_PKTINFO, (void *) &pad,
 187                     sizeof (pad)) == 0)
 188     /* Set the padding to all 1s. */
 189     pad = 0xff;
 190   else
 191 #endif
 192     /* Clear the padding. */
 193     pad = 0;
 194   memset (&xprt->xp_pad [0], pad, sizeof (xprt->xp_pad));
 195
 196   xprt_register (xprt);
 197   return xprt;
 198 }
 199 #ifdef EXPORT_RPC_SYMBOLS
 200 libc_hidden_def (svcudp_bufcreate)
 201 #else
 202 libc_hidden_nolink_sunrpc (svcudp_bufcreate, GLIBC_2_0)
 203 #endif
 204
 205 SVCXPRT *
 206 svcudp_create (int sock)
 207 {
 208   return svcudp_bufcreate (sock, UDPMSGSIZE, UDPMSGSIZE);
 209 }
 210 #ifdef EXPORT_RPC_SYMBOLS
 211 libc_hidden_def (svcudp_create)
 212 #else
 213 libc_hidden_nolink_sunrpc (svcudp_create, GLIBC_2_0)
 214 #endif
 215
 216 static enum xprt_stat
 217 svcudp_stat (SVCXPRT *xprt)
 218 {
 219
 220   return XPRT_IDLE;
 221 }
 222
 223 static bool_t
 224 svcudp_recv (SVCXPRT *xprt, struct rpc_msg *msg)
 225 {
 226   struct svcudp_data *su = su_data (xprt);
 227   XDR *xdrs = &(su->su_xdrs);
 228   int rlen;
 229   char *reply;
 230   u_long replylen;
 231   socklen_t len;
 232
 233   /* It is very tricky when you have IP aliases. We want to make sure
 234      that we are sending the packet from the IP address where the
 235      incoming packet is addressed to. H.J. */
 236 #ifdef IP_PKTINFO
 237   struct iovec *iovp;
 238   struct msghdr *mesgp;
 239 #endif
 240
 241 again:
 242   /* FIXME -- should xp_addrlen be a size_t?  */
 243   len = (socklen_t) sizeof(struct sockaddr_in);
 244 #ifdef IP_PKTINFO
 245   iovp = (struct iovec *) &xprt->xp_pad [0];
 246   mesgp = (struct msghdr *) &xprt->xp_pad [sizeof (struct iovec)];
 247   if (mesgp->msg_iovlen)
 248     {
 249       iovp->iov_base = rpc_buffer (xprt);
 250       iovp->iov_len = su->su_iosz;
 251       mesgp->msg_iov = iovp;
 252       mesgp->msg_iovlen = 1;
 253       mesgp->msg_name = &(xprt->xp_raddr);
 254       mesgp->msg_namelen = len;
 255       mesgp->msg_control = &xprt->xp_pad [sizeof (struct iovec)
 256                                           + sizeof (struct msghdr)];
 257       mesgp->msg_controllen = sizeof(xprt->xp_pad)
 258                               - sizeof (struct iovec) - sizeof (struct msghdr);
 259       rlen = __recvmsg (xprt->xp_sock, mesgp, 0);
 260       if (rlen >= 0)
 261         {
 262           struct cmsghdr *cmsg;
 263           len = mesgp->msg_namelen;
 264           cmsg = CMSG_FIRSTHDR (mesgp);
 265           if (cmsg == NULL
 266               || CMSG_NXTHDR (mesgp, cmsg) != NULL
 267               || cmsg->cmsg_level != SOL_IP
 268               || cmsg->cmsg_type != IP_PKTINFO
 269               || cmsg->cmsg_len < (sizeof (struct cmsghdr)
 270                                    + sizeof (struct in_pktinfo)))
 271             {
 272               /* Not a simple IP_PKTINFO, ignore it.  */
 273               mesgp->msg_control = NULL;
 274               mesgp->msg_controllen = 0;
 275             }
 276           else
 277             {
 278               /* It was a simple IP_PKTIFO as we expected, discard the
 279                  interface field.  */
 280               struct in_pktinfo *pkti = (struct in_pktinfo *) CMSG_DATA (cmsg);
 281               pkti->ipi_ifindex = 0;
 282             }
 283         }
 284     }
 285   else
 286 #endif
 287     rlen = __recvfrom (xprt->xp_sock, rpc_buffer (xprt),
 288                        (int) su->su_iosz, 0,
 289                        (struct sockaddr *) &(xprt->xp_raddr), &len);
 290   xprt->xp_addrlen = len;
 291   if (rlen == -1)
 292     {
 293       if (errno == EINTR)
 294         goto again;
 295       __svc_accept_failed ();
 296     }
 297   if (rlen < 16)                /* < 4 32-bit ints? */
 298     return FALSE;
 299   xdrs->x_op = XDR_DECODE;
 300   XDR_SETPOS (xdrs, 0);
 301   if (!xdr_callmsg (xdrs, msg))
 302     return FALSE;
 303   su->su_xid = msg->rm_xid;
 304   if (su->su_cache != NULL)
 305     {
 306       if (cache_get (xprt, msg, &reply, &replylen))
 307         {
 308 #ifdef IP_PKTINFO
 309           if (mesgp->msg_iovlen)
 310             {
 311               iovp->iov_base = reply;
 312               iovp->iov_len = replylen;
 313               (void) __sendmsg (xprt->xp_sock, mesgp, 0);
 314             }
 315           else
 316 #endif
 317             (void) __sendto (xprt->xp_sock, reply, (int) replylen, 0,
 318                              (struct sockaddr *) &xprt->xp_raddr, len);
 319           return TRUE;
 320         }
 321     }
 322   return TRUE;
 323 }
 324
 325 static bool_t
 326 svcudp_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 327 {
 328   struct svcudp_data *su = su_data (xprt);
 329   XDR *xdrs = &(su->su_xdrs);
 330   int slen, sent;
 331   bool_t stat = FALSE;
 332 #ifdef IP_PKTINFO
 333   struct iovec *iovp;
 334   struct msghdr *mesgp;
 335 #endif
 336
 337   xdrs->x_op = XDR_ENCODE;
 338   XDR_SETPOS (xdrs, 0);
 339   msg->rm_xid = su->su_xid;
 340   if (xdr_replymsg (xdrs, msg))
 341     {
 342       slen = (int) XDR_GETPOS (xdrs);
 343 #ifdef IP_PKTINFO
 344       mesgp = (struct msghdr *) &xprt->xp_pad [sizeof (struct iovec)];
 345       if (mesgp->msg_iovlen)
 346         {
 347           iovp = (struct iovec *) &xprt->xp_pad [0];
 348           iovp->iov_base = rpc_buffer (xprt);
 349           iovp->iov_len = slen;
 350           sent = __sendmsg (xprt->xp_sock, mesgp, 0);
 351         }
 352       else
 353 #endif
 354         sent = __sendto (xprt->xp_sock, rpc_buffer (xprt), slen, 0,
 355                          (struct sockaddr *) &(xprt->xp_raddr),
 356                          xprt->xp_addrlen);
 357       if (sent == slen)
 358         {
 359           stat = TRUE;
 360           if (su->su_cache && slen >= 0)
 361             {
 362               cache_set (xprt, (u_long) slen);
 363             }
 364         }
 365     }
 366   return stat;
 367 }
 368
 369 static bool_t
 370 svcudp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 371 {
 372
 373   return (*xdr_args) (&(su_data (xprt)->su_xdrs), args_ptr);
 374 }
 375
 376 static bool_t
 377 svcudp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 378 {
 379   XDR *xdrs = &(su_data (xprt)->su_xdrs);
 380
 381   xdrs->x_op = XDR_FREE;
 382   return (*xdr_args) (xdrs, args_ptr);
 383 }
 384
 385 static void
 386 svcudp_destroy (SVCXPRT *xprt)
 387 {
 388   struct svcudp_data *su = su_data (xprt);
 389
 390   xprt_unregister (xprt);
 391   (void) __close (xprt->xp_sock);
 392   XDR_DESTROY (&(su->su_xdrs));
 393   mem_free (rpc_buffer (xprt), su->su_iosz);
 394   mem_free ((caddr_t) su, sizeof (struct svcudp_data));
 395   mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
 396 }
 397
 398
 399 /***********this could be a separate file*********************/
 400
 401 /*
 402  * Fifo cache for udp server
 403  * Copies pointers to reply buffers into fifo cache
 404  * Buffers are sent again if retransmissions are detected.
 405  */
 406
 407 #define SPARSENESS 4            /* 75% sparse */
 408
 409 #define CACHE_PERROR(msg)       \
 410         (void) __fxprintf(NULL, "%s\n", msg)
 411
 412 #define ALLOC(type, size)       \
 413         (type *) mem_alloc((unsigned) (sizeof(type) * (size)))
 414
 415 #define CALLOC(type, size)      \
 416   (type *) calloc (sizeof (type), size)
 417
 418 /*
 419  * An entry in the cache
 420  */
 421 typedef struct cache_node *cache_ptr;
 422 struct cache_node
 423   {
 424     /*
 425      * Index into cache is xid, proc, vers, prog and address
 426      */
 427     u_long cache_xid;
 428     u_long cache_proc;
 429     u_long cache_vers;
 430     u_long cache_prog;
 431     struct sockaddr_in cache_addr;
 432     /*
 433      * The cached reply and length
 434      */
 435     char *cache_reply;
 436     u_long cache_replylen;
 437     /*
 438      * Next node on the list, if there is a collision
 439      */
 440     cache_ptr cache_next;
 441   };
 442
 443
 444
 445 /*
 446  * The entire cache
 447  */
 448 struct udp_cache
 449   {
 450     u_long uc_size;             /* size of cache */
 451     cache_ptr *uc_entries;      /* hash table of entries in cache */
 452     cache_ptr *uc_fifo;         /* fifo list of entries in cache */
 453     u_long uc_nextvictim;       /* points to next victim in fifo list */
 454     u_long uc_prog;             /* saved program number */
 455     u_long uc_vers;             /* saved version number */
 456     u_long uc_proc;             /* saved procedure number */
 457     struct sockaddr_in uc_addr; /* saved caller's address */
 458   };
 459
 460
 461 /*
 462  * the hashing function
 463  */
 464 #define CACHE_LOC(transp, xid)  \
 465  (xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size))
 466
 467
 468 /*
 469  * Enable use of the cache.
 470  * Note: there is no disable.
 471  */
 472 int
 473 svcudp_enablecache (SVCXPRT *transp, u_long size)
 474 {
 475   struct svcudp_data *su = su_data (transp);
 476   struct udp_cache *uc;
 477
 478   if (su->su_cache != NULL)
 479     {
 480       CACHE_PERROR (_("enablecache: cache already enabled"));
 481       return 0;
 482     }
 483   uc = ALLOC (struct udp_cache, 1);
 484   if (uc == NULL)
 485     {
 486       CACHE_PERROR (_("enablecache: could not allocate cache"));
 487       return 0;
 488     }
 489   uc->uc_size = size;
 490   uc->uc_nextvictim = 0;
 491   uc->uc_entries = CALLOC (cache_ptr, size * SPARSENESS);
 492   if (uc->uc_entries == NULL)
 493     {
 494       mem_free (uc, sizeof (struct udp_cache));
 495       CACHE_PERROR (_("enablecache: could not allocate cache data"));
 496       return 0;
 497     }
 498   uc->uc_fifo = CALLOC (cache_ptr, size);
 499   if (uc->uc_fifo == NULL)
 500     {
 501       mem_free (uc->uc_entries, size * SPARSENESS);
 502       mem_free (uc, sizeof (struct udp_cache));
 503       CACHE_PERROR (_("enablecache: could not allocate cache fifo"));
 504       return 0;
 505     }
 506   su->su_cache = (char *) uc;
 507   return 1;
 508 }
 509 libc_hidden_nolink_sunrpc (svcudp_enablecache, GLIBC_2_0)
 510
 511
 512 /*
 513  * Set an entry in the cache
 514  */
 515 static void
 516 cache_set (SVCXPRT *xprt, u_long replylen)
 517 {
 518   cache_ptr victim;
 519   cache_ptr *vicp;
 520   struct svcudp_data *su = su_data (xprt);
 521   struct udp_cache *uc = (struct udp_cache *) su->su_cache;
 522   u_int loc;
 523   char *newbuf;
 524
 525   /*
 526    * Find space for the new entry, either by
 527    * reusing an old entry, or by mallocing a new one
 528    */
 529   victim = uc->uc_fifo[uc->uc_nextvictim];
 530   if (victim != NULL)
 531     {
 532       loc = CACHE_LOC (xprt, victim->cache_xid);
 533       for (vicp = &uc->uc_entries[loc];
 534            *vicp != NULL && *vicp != victim;
 535            vicp = &(*vicp)->cache_next)
 536         ;
 537       if (*vicp == NULL)
 538         {
 539           CACHE_PERROR (_("cache_set: victim not found"));
 540           return;
 541         }
 542       *vicp = victim->cache_next;       /* remote from cache */
 543       newbuf = victim->cache_reply;
 544     }
 545   else
 546     {
 547       victim = ALLOC (struct cache_node, 1);
 548       if (victim == NULL)
 549         {
 550           CACHE_PERROR (_("cache_set: victim alloc failed"));
 551           return;
 552         }
 553       newbuf = mem_alloc (su->su_iosz);
 554       if (newbuf == NULL)
 555         {
 556           mem_free (victim, sizeof (struct cache_node));
 557           CACHE_PERROR (_("cache_set: could not allocate new rpc_buffer"));
 558           return;
 559         }
 560     }
 561
 562   /*
 563    * Store it away
 564    */
 565   victim->cache_replylen = replylen;
 566   victim->cache_reply = rpc_buffer (xprt);
 567   rpc_buffer (xprt) = newbuf;
 568   xdrmem_create (&(su->su_xdrs), rpc_buffer (xprt), su->su_iosz, XDR_ENCODE);
 569   victim->cache_xid = su->su_xid;
 570   victim->cache_proc = uc->uc_proc;
 571   victim->cache_vers = uc->uc_vers;
 572   victim->cache_prog = uc->uc_prog;
 573   victim->cache_addr = uc->uc_addr;
 574   loc = CACHE_LOC (xprt, victim->cache_xid);
 575   victim->cache_next = uc->uc_entries[loc];
 576   uc->uc_entries[loc] = victim;
 577   uc->uc_fifo[uc->uc_nextvictim++] = victim;
 578   uc->uc_nextvictim %= uc->uc_size;
 579 }
 580
 581 /*
 582  * Try to get an entry from the cache
 583  * return 1 if found, 0 if not found
 584  */
 585 static int
 586 cache_get (SVCXPRT *xprt, struct rpc_msg *msg, char **replyp,
 587            u_long *replylenp)
 588 {
 589   u_int loc;
 590   cache_ptr ent;
 591   struct svcudp_data *su = su_data (xprt);
 592   struct udp_cache *uc = (struct udp_cache *) su->su_cache;
 593
 594 #define EQADDR(a1, a2)  (memcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
 595
 596   loc = CACHE_LOC (xprt, su->su_xid);
 597   for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next)
 598     {
 599       if (ent->cache_xid == su->su_xid &&
 600           ent->cache_proc == uc->uc_proc &&
 601           ent->cache_vers == uc->uc_vers &&
 602           ent->cache_prog == uc->uc_prog &&
 603           EQADDR (ent->cache_addr, uc->uc_addr))
 604         {
 605           *replyp = ent->cache_reply;
 606           *replylenp = ent->cache_replylen;
 607           return 1;
 608         }
 609     }
 610   /*
 611    * Failed to find entry
 612    * Remember a few things so we can do a set later
 613    */
 614   uc->uc_proc = msg->rm_call.cb_proc;
 615   uc->uc_vers = msg->rm_call.cb_vers;
 616   uc->uc_prog = msg->rm_call.cb_prog;
 617   memcpy (&uc->uc_addr, &xprt->xp_raddr, sizeof (uc->uc_addr));
 618   return 0;
 619 }