lib/libc/rpc/svc.c

   1 /*      $NetBSD: svc.c,v 1.21 2000/07/06 03:10:35 christos Exp $        */
   2
   3 /*
   4  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   5  * unrestricted use provided that this legend is included on all tape
   6  * media and as a part of the software program in whole or part.  Users
   7  * may copy or modify Sun RPC without charge, but are not authorized
   8  * to license or distribute it to anyone else except as part of a product or
   9  * program developed by the user.
  10  *
  11  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  12  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  13  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  14  *
  15  * Sun RPC is provided with no support and without any obligation on the
  16  * part of Sun Microsystems, Inc. to assist in its use, correction,
  17  * modification or enhancement.
  18  *
  19  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  20  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  21  * OR ANY PART THEREOF.
  22  *
  23  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  24  * or profits or other special, indirect and consequential damages, even if
  25  * Sun has been advised of the possibility of such damages.
  26  *
  27  * Sun Microsystems, Inc.
  28  * 2550 Garcia Avenue
  29  * Mountain View, California  94043
  30  */
  31
  32 #if defined(LIBC_SCCS) && !defined(lint)
  33 static char *sccsid2 = "@(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro";
  34 static char *sccsid = "@(#)svc.c        2.4 88/08/11 4.0 RPCSRC";
  35 #endif
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 /*
  40  * svc.c, Server-side remote procedure call interface.
  41  *
  42  * There are two sets of procedures here.  The xprt routines are
  43  * for handling transport handles.  The svc routines handle the
  44  * list of service routines.
  45  *
  46  * Copyright (C) 1984, Sun Microsystems, Inc.
  47  */
  48
  49 #include "namespace.h"
  50 #include "reentrant.h"
  51 #include <sys/types.h>
  52 #include <sys/poll.h>
  53 #include <assert.h>
  54 #include <errno.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57
  58 #include <rpc/rpc.h>
  59 #ifdef PORTMAP
  60 #include <rpc/pmap_clnt.h>
  61 #endif                          /* PORTMAP */
  62 #include "un-namespace.h"
  63
  64 #include "rpc_com.h"
  65 #include "mt_misc.h"
  66
  67 #define RQCRED_SIZE     400             /* this size is excessive */
  68
  69 #define SVC_VERSQUIET 0x0001            /* keep quiet about vers mismatch */
  70 #define version_keepquiet(xp) (SVC_EXT(xp)->xp_flags & SVC_VERSQUIET)
  71
  72 #define max(a, b) (a > b ? a : b)
  73
  74 /*
  75  * The services list
  76  * Each entry represents a set of procedures (an rpc program).
  77  * The dispatch routine takes request structs and runs the
  78  * apropriate procedure.
  79  */
  80 static struct svc_callout {
  81         struct svc_callout *sc_next;
  82         rpcprog_t           sc_prog;
  83         rpcvers_t           sc_vers;
  84         char               *sc_netid;
  85         void                (*sc_dispatch)(struct svc_req *, SVCXPRT *);
  86 } *svc_head;
  87
  88 static struct svc_callout *svc_find(rpcprog_t, rpcvers_t,
  89     struct svc_callout **, char *);
  90 static void __xprt_do_unregister (SVCXPRT *xprt, bool_t dolock);
  91
  92 /* ***************  SVCXPRT related stuff **************** */
  93
  94 /*
  95  * Activate a transport handle.
  96  */
  97 void
  98 xprt_register(xprt)
  99         SVCXPRT *xprt;
 100 {
 101         int sock;
 102
 103         assert(xprt != NULL);
 104
 105         sock = xprt->xp_fd;
 106
 107         rwlock_wrlock(&svc_fd_lock);
 108         if (__svc_xports == NULL) {
 109                 __svc_xports = (SVCXPRT **)
 110                         mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
 111                 if (__svc_xports == NULL)
 112                         return;
 113                 memset(__svc_xports, '\0', FD_SETSIZE * sizeof(SVCXPRT *));
 114         }
 115         if (sock < FD_SETSIZE) {
 116                 __svc_xports[sock] = xprt;
 117                 FD_SET(sock, &svc_fdset);
 118                 svc_maxfd = max(svc_maxfd, sock);
 119         }
 120         rwlock_unlock(&svc_fd_lock);
 121 }
 122
 123 void
 124 xprt_unregister(SVCXPRT *xprt)
 125 {
 126         __xprt_do_unregister(xprt, TRUE);
 127 }
 128
 129 void
 130 __xprt_unregister_unlocked(SVCXPRT *xprt)
 131 {
 132         __xprt_do_unregister(xprt, FALSE);
 133 }
 134
 135 /*
 136  * De-activate a transport handle.
 137  */
 138 static void
 139 __xprt_do_unregister(xprt, dolock)
 140         SVCXPRT *xprt;
 141         bool_t dolock;
 142 {
 143         int sock;
 144
 145         assert(xprt != NULL);
 146
 147         sock = xprt->xp_fd;
 148
 149         if (dolock)
 150                 rwlock_wrlock(&svc_fd_lock);
 151         if ((sock < FD_SETSIZE) && (__svc_xports[sock] == xprt)) {
 152                 __svc_xports[sock] = NULL;
 153                 FD_CLR(sock, &svc_fdset);
 154                 if (sock >= svc_maxfd) {
 155                         for (svc_maxfd--; svc_maxfd>=0; svc_maxfd--)
 156                                 if (__svc_xports[svc_maxfd])
 157                                         break;
 158                 }
 159         }
 160         if (dolock)
 161                 rwlock_unlock(&svc_fd_lock);
 162 }
 163
 164 /*
 165  * Add a service program to the callout list.
 166  * The dispatch routine will be called when a rpc request for this
 167  * program number comes in.
 168  */
 169 bool_t
 170 svc_reg(xprt, prog, vers, dispatch, nconf)
 171         SVCXPRT *xprt;
 172         const rpcprog_t prog;
 173         const rpcvers_t vers;
 174         void (*dispatch)(struct svc_req *, SVCXPRT *);
 175         const struct netconfig *nconf;
 176 {
 177         bool_t dummy;
 178         struct svc_callout *prev;
 179         struct svc_callout *s;
 180         struct netconfig *tnconf;
 181         char *netid = NULL;
 182         int flag = 0;
 183
 184 /* VARIABLES PROTECTED BY svc_lock: s, prev, svc_head */
 185
 186         if (xprt->xp_netid) {
 187                 netid = strdup(xprt->xp_netid);
 188                 flag = 1;
 189         } else if (nconf && nconf->nc_netid) {
 190                 netid = strdup(nconf->nc_netid);
 191                 flag = 1;
 192         } else if ((tnconf = __rpcgettp(xprt->xp_fd)) != NULL) {
 193                 netid = strdup(tnconf->nc_netid);
 194                 flag = 1;
 195                 freenetconfigent(tnconf);
 196         } /* must have been created with svc_raw_create */
 197         if ((netid == NULL) && (flag == 1)) {
 198                 return (FALSE);
 199         }
 200
 201         rwlock_wrlock(&svc_lock);
 202         if ((s = svc_find(prog, vers, &prev, netid)) != NULL) {
 203                 if (netid)
 204                         free(netid);
 205                 if (s->sc_dispatch == dispatch)
 206                         goto rpcb_it; /* he is registering another xptr */
 207                 rwlock_unlock(&svc_lock);
 208                 return (FALSE);
 209         }
 210         s = mem_alloc(sizeof (struct svc_callout));
 211         if (s == NULL) {
 212                 if (netid)
 213                         free(netid);
 214                 rwlock_unlock(&svc_lock);
 215                 return (FALSE);
 216         }
 217
 218         s->sc_prog = prog;
 219         s->sc_vers = vers;
 220         s->sc_dispatch = dispatch;
 221         s->sc_netid = netid;
 222         s->sc_next = svc_head;
 223         svc_head = s;
 224
 225         if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
 226                 ((SVCXPRT *) xprt)->xp_netid = strdup(netid);
 227
 228 rpcb_it:
 229         rwlock_unlock(&svc_lock);
 230         /* now register the information with the local binder service */
 231         if (nconf) {
 232                 /*LINTED const castaway*/
 233                 dummy = rpcb_set(prog, vers, (struct netconfig *) nconf,
 234                 &((SVCXPRT *) xprt)->xp_ltaddr);
 235                 return (dummy);
 236         }
 237         return (TRUE);
 238 }
 239
 240 /*
 241  * Remove a service program from the callout list.
 242  */
 243 void
 244 svc_unreg(prog, vers)
 245         const rpcprog_t prog;
 246         const rpcvers_t vers;
 247 {
 248         struct svc_callout *prev;
 249         struct svc_callout *s;
 250
 251         /* unregister the information anyway */
 252         (void) rpcb_unset(prog, vers, NULL);
 253         rwlock_wrlock(&svc_lock);
 254         while ((s = svc_find(prog, vers, &prev, NULL)) != NULL) {
 255                 if (prev == NULL) {
 256                         svc_head = s->sc_next;
 257                 } else {
 258                         prev->sc_next = s->sc_next;
 259                 }
 260                 s->sc_next = NULL;
 261                 if (s->sc_netid)
 262                         mem_free(s->sc_netid, sizeof (s->sc_netid) + 1);
 263                 mem_free(s, sizeof (struct svc_callout));
 264         }
 265         rwlock_unlock(&svc_lock);
 266 }
 267
 268 /* ********************** CALLOUT list related stuff ************* */
 269
 270 #ifdef PORTMAP
 271 /*
 272  * Add a service program to the callout list.
 273  * The dispatch routine will be called when a rpc request for this
 274  * program number comes in.
 275  */
 276 bool_t
 277 svc_register(xprt, prog, vers, dispatch, protocol)
 278         SVCXPRT *xprt;
 279         u_long prog;
 280         u_long vers;
 281         void (*dispatch)(struct svc_req *, SVCXPRT *);
 282         int protocol;
 283 {
 284         struct svc_callout *prev;
 285         struct svc_callout *s;
 286
 287         assert(xprt != NULL);
 288         assert(dispatch != NULL);
 289
 290         if ((s = svc_find((rpcprog_t)prog, (rpcvers_t)vers, &prev, NULL)) !=
 291             NULL) {
 292                 if (s->sc_dispatch == dispatch)
 293                         goto pmap_it;  /* he is registering another xptr */
 294                 return (FALSE);
 295         }
 296         s = mem_alloc(sizeof(struct svc_callout));
 297         if (s == NULL) {
 298                 return (FALSE);
 299         }
 300         s->sc_prog = (rpcprog_t)prog;
 301         s->sc_vers = (rpcvers_t)vers;
 302         s->sc_dispatch = dispatch;
 303         s->sc_next = svc_head;
 304         svc_head = s;
 305 pmap_it:
 306         /* now register the information with the local binder service */
 307         if (protocol) {
 308                 return (pmap_set(prog, vers, protocol, xprt->xp_port));
 309         }
 310         return (TRUE);
 311 }
 312
 313 /*
 314  * Remove a service program from the callout list.
 315  */
 316 void
 317 svc_unregister(prog, vers)
 318         u_long prog;
 319         u_long vers;
 320 {
 321         struct svc_callout *prev;
 322         struct svc_callout *s;
 323
 324         if ((s = svc_find((rpcprog_t)prog, (rpcvers_t)vers, &prev, NULL)) ==
 325             NULL)
 326                 return;
 327         if (prev == NULL) {
 328                 svc_head = s->sc_next;
 329         } else {
 330                 prev->sc_next = s->sc_next;
 331         }
 332         s->sc_next = NULL;
 333         mem_free(s, sizeof(struct svc_callout));
 334         /* now unregister the information with the local binder service */
 335         (void)pmap_unset(prog, vers);
 336 }
 337 #endif                          /* PORTMAP */
 338
 339 /*
 340  * Search the callout list for a program number, return the callout
 341  * struct.
 342  */
 343 static struct svc_callout *
 344 svc_find(prog, vers, prev, netid)
 345         rpcprog_t prog;
 346         rpcvers_t vers;
 347         struct svc_callout **prev;
 348         char *netid;
 349 {
 350         struct svc_callout *s, *p;
 351
 352         assert(prev != NULL);
 353
 354         p = NULL;
 355         for (s = svc_head; s != NULL; s = s->sc_next) {
 356                 if (((s->sc_prog == prog) && (s->sc_vers == vers)) &&
 357                     ((netid == NULL) || (s->sc_netid == NULL) ||
 358                     (strcmp(netid, s->sc_netid) == 0)))
 359                         break;
 360                 p = s;
 361         }
 362         *prev = p;
 363         return (s);
 364 }
 365
 366 /* ******************* REPLY GENERATION ROUTINES  ************ */
 367
 368 /*
 369  * Send a reply to an rpc request
 370  */
 371 bool_t
 372 svc_sendreply(xprt, xdr_results, xdr_location)
 373         SVCXPRT *xprt;
 374         xdrproc_t xdr_results;
 375         void * xdr_location;
 376 {
 377         struct rpc_msg rply;
 378
 379         assert(xprt != NULL);
 380
 381         rply.rm_direction = REPLY;
 382         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 383         rply.acpted_rply.ar_verf = xprt->xp_verf;
 384         rply.acpted_rply.ar_stat = SUCCESS;
 385         rply.acpted_rply.ar_results.where = xdr_location;
 386         rply.acpted_rply.ar_results.proc = xdr_results;
 387         return (SVC_REPLY(xprt, &rply));
 388 }
 389
 390 /*
 391  * No procedure error reply
 392  */
 393 void
 394 svcerr_noproc(xprt)
 395         SVCXPRT *xprt;
 396 {
 397         struct rpc_msg rply;
 398
 399         assert(xprt != NULL);
 400
 401         rply.rm_direction = REPLY;
 402         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 403         rply.acpted_rply.ar_verf = xprt->xp_verf;
 404         rply.acpted_rply.ar_stat = PROC_UNAVAIL;
 405         SVC_REPLY(xprt, &rply);
 406 }
 407
 408 /*
 409  * Can't decode args error reply
 410  */
 411 void
 412 svcerr_decode(xprt)
 413         SVCXPRT *xprt;
 414 {
 415         struct rpc_msg rply;
 416
 417         assert(xprt != NULL);
 418
 419         rply.rm_direction = REPLY;
 420         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 421         rply.acpted_rply.ar_verf = xprt->xp_verf;
 422         rply.acpted_rply.ar_stat = GARBAGE_ARGS;
 423         SVC_REPLY(xprt, &rply);
 424 }
 425
 426 /*
 427  * Some system error
 428  */
 429 void
 430 svcerr_systemerr(xprt)
 431         SVCXPRT *xprt;
 432 {
 433         struct rpc_msg rply;
 434
 435         assert(xprt != NULL);
 436
 437         rply.rm_direction = REPLY;
 438         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 439         rply.acpted_rply.ar_verf = xprt->xp_verf;
 440         rply.acpted_rply.ar_stat = SYSTEM_ERR;
 441         SVC_REPLY(xprt, &rply);
 442 }
 443
 444 #if 0
 445 /*
 446  * Tell RPC package to not complain about version errors to the client.  This
 447  * is useful when revving broadcast protocols that sit on a fixed address.
 448  * There is really one (or should be only one) example of this kind of
 449  * protocol: the portmapper (or rpc binder).
 450  */
 451 void
 452 __svc_versquiet_on(xprt)
 453         SVCXPRT *xprt;
 454 {
 455
 456         SVC_EXT(xprt)->xp_flags |= SVC_VERSQUIET;
 457 }
 458
 459 void
 460 __svc_versquiet_off(xprt)
 461         SVCXPRT *xprt;
 462 {
 463
 464         SVC_EXT(xprt)->xp_flags &= ~SVC_VERSQUIET;
 465 }
 466
 467 void
 468 svc_versquiet(xprt)
 469         SVCXPRT *xprt;
 470 {
 471         __svc_versquiet_on(xprt);
 472 }
 473
 474 int
 475 __svc_versquiet_get(xprt)
 476         SVCXPRT *xprt;
 477 {
 478
 479         return (SVC_EXT(xprt)->xp_flags & SVC_VERSQUIET);
 480 }
 481 #endif
 482
 483 /*
 484  * Authentication error reply
 485  */
 486 void
 487 svcerr_auth(xprt, why)
 488         SVCXPRT *xprt;
 489         enum auth_stat why;
 490 {
 491         struct rpc_msg rply;
 492
 493         assert(xprt != NULL);
 494
 495         rply.rm_direction = REPLY;
 496         rply.rm_reply.rp_stat = MSG_DENIED;
 497         rply.rjcted_rply.rj_stat = AUTH_ERROR;
 498         rply.rjcted_rply.rj_why = why;
 499         SVC_REPLY(xprt, &rply);
 500 }
 501
 502 /*
 503  * Auth too weak error reply
 504  */
 505 void
 506 svcerr_weakauth(xprt)
 507         SVCXPRT *xprt;
 508 {
 509
 510         assert(xprt != NULL);
 511
 512         svcerr_auth(xprt, AUTH_TOOWEAK);
 513 }
 514
 515 /*
 516  * Program unavailable error reply
 517  */
 518 void
 519 svcerr_noprog(xprt)
 520         SVCXPRT *xprt;
 521 {
 522         struct rpc_msg rply;
 523
 524         assert(xprt != NULL);
 525
 526         rply.rm_direction = REPLY;
 527         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 528         rply.acpted_rply.ar_verf = xprt->xp_verf;
 529         rply.acpted_rply.ar_stat = PROG_UNAVAIL;
 530         SVC_REPLY(xprt, &rply);
 531 }
 532
 533 /*
 534  * Program version mismatch error reply
 535  */
 536 void
 537 svcerr_progvers(xprt, low_vers, high_vers)
 538         SVCXPRT *xprt;
 539         rpcvers_t low_vers;
 540         rpcvers_t high_vers;
 541 {
 542         struct rpc_msg rply;
 543
 544         assert(xprt != NULL);
 545
 546         rply.rm_direction = REPLY;
 547         rply.rm_reply.rp_stat = MSG_ACCEPTED;
 548         rply.acpted_rply.ar_verf = xprt->xp_verf;
 549         rply.acpted_rply.ar_stat = PROG_MISMATCH;
 550         rply.acpted_rply.ar_vers.low = (u_int32_t)low_vers;
 551         rply.acpted_rply.ar_vers.high = (u_int32_t)high_vers;
 552         SVC_REPLY(xprt, &rply);
 553 }
 554
 555 /*
 556  * Allocate a new server transport structure. All fields are
 557  * initialized to zero and xp_p3 is initialized to point at an
 558  * extension structure to hold various flags and authentication
 559  * parameters.
 560  */
 561 SVCXPRT *
 562 svc_xprt_alloc()
 563 {
 564         SVCXPRT *xprt;
 565         SVCXPRT_EXT *ext;
 566
 567         xprt = mem_alloc(sizeof(SVCXPRT));
 568         memset(xprt, 0, sizeof(SVCXPRT));
 569         ext = mem_alloc(sizeof(SVCXPRT_EXT));
 570         memset(ext, 0, sizeof(SVCXPRT_EXT));
 571         xprt->xp_p3 = ext;
 572         ext->xp_auth.svc_ah_ops = &svc_auth_null_ops;
 573
 574         return (xprt);
 575 }
 576
 577 /*
 578  * Free a server transport structure.
 579  */
 580 void
 581 svc_xprt_free(xprt)
 582         SVCXPRT *xprt;
 583 {
 584
 585         mem_free(xprt->xp_p3, sizeof(SVCXPRT_EXT));
 586         mem_free(xprt, sizeof(SVCXPRT));
 587 }
 588
 589 /* ******************* SERVER INPUT STUFF ******************* */
 590
 591 /*
 592  * Get server side input from some transport.
 593  *
 594  * Statement of authentication parameters management:
 595  * This function owns and manages all authentication parameters, specifically
 596  * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
 597  * the "cooked" credentials (rqst->rq_clntcred).
 598  * However, this function does not know the structure of the cooked
 599  * credentials, so it make the following assumptions:
 600  *   a) the structure is contiguous (no pointers), and
 601  *   b) the cred structure size does not exceed RQCRED_SIZE bytes.
 602  * In all events, all three parameters are freed upon exit from this routine.
 603  * The storage is trivially management on the call stack in user land, but
 604  * is mallocated in kernel land.
 605  */
 606
 607 void
 608 svc_getreq(rdfds)
 609         int rdfds;
 610 {
 611         fd_set readfds;
 612
 613         FD_ZERO(&readfds);
 614         readfds.fds_bits[0] = rdfds;
 615         svc_getreqset(&readfds);
 616 }
 617
 618 void
 619 svc_getreqset(readfds)
 620         fd_set *readfds;
 621 {
 622         int bit, fd;
 623         fd_mask mask, *maskp;
 624         int sock;
 625
 626         assert(readfds != NULL);
 627
 628         maskp = readfds->fds_bits;
 629         for (sock = 0; sock < FD_SETSIZE; sock += NFDBITS) {
 630             for (mask = *maskp++; (bit = ffsl(mask)) != 0;
 631                 mask ^= (1ul << (bit - 1))) {
 632                 /* sock has input waiting */
 633                 fd = sock + bit - 1;
 634                 svc_getreq_common(fd);
 635             }
 636         }
 637 }
 638
 639 void
 640 svc_getreq_common(fd)
 641         int fd;
 642 {
 643         SVCXPRT *xprt;
 644         struct svc_req r;
 645         struct rpc_msg msg;
 646         int prog_found;
 647         rpcvers_t low_vers;
 648         rpcvers_t high_vers;
 649         enum xprt_stat stat;
 650         char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
 651
 652         msg.rm_call.cb_cred.oa_base = cred_area;
 653         msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
 654         r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
 655
 656         rwlock_rdlock(&svc_fd_lock);
 657         xprt = __svc_xports[fd];
 658         rwlock_unlock(&svc_fd_lock);
 659         if (xprt == NULL)
 660                 /* But do we control sock? */
 661                 return;
 662         /* now receive msgs from xprtprt (support batch calls) */
 663         do {
 664                 if (SVC_RECV(xprt, &msg)) {
 665
 666                         /* now find the exported program and call it */
 667                         struct svc_callout *s;
 668                         enum auth_stat why;
 669
 670                         r.rq_xprt = xprt;
 671                         r.rq_prog = msg.rm_call.cb_prog;
 672                         r.rq_vers = msg.rm_call.cb_vers;
 673                         r.rq_proc = msg.rm_call.cb_proc;
 674                         r.rq_cred = msg.rm_call.cb_cred;
 675                         /* first authenticate the message */
 676                         if ((why = _authenticate(&r, &msg)) != AUTH_OK) {
 677                                 /*
 678                                  * RPCSEC_GSS uses this return code
 679                                  * for requests that form part of its
 680                                  * context establishment protocol and
 681                                  * should not be dispatched to the
 682                                  * application.
 683                                  */
 684                                 if (why != RPCSEC_GSS_NODISPATCH)
 685                                         svcerr_auth(xprt, why);
 686                                 goto call_done;
 687                         }
 688                         /* now match message with a registered service*/
 689                         prog_found = FALSE;
 690                         low_vers = (rpcvers_t) -1L;
 691                         high_vers = (rpcvers_t) 0L;
 692                         for (s = svc_head; s != NULL; s = s->sc_next) {
 693                                 if (s->sc_prog == r.rq_prog) {
 694                                         if (s->sc_vers == r.rq_vers) {
 695                                                 (*s->sc_dispatch)(&r, xprt);
 696                                                 goto call_done;
 697                                         }  /* found correct version */
 698                                         prog_found = TRUE;
 699                                         if (s->sc_vers < low_vers)
 700                                                 low_vers = s->sc_vers;
 701                                         if (s->sc_vers > high_vers)
 702                                                 high_vers = s->sc_vers;
 703                                 }   /* found correct program */
 704                         }
 705                         /*
 706                          * if we got here, the program or version
 707                          * is not served ...
 708                          */
 709                         if (prog_found)
 710                                 svcerr_progvers(xprt, low_vers, high_vers);
 711                         else
 712                                 svcerr_noprog(xprt);
 713                         /* Fall through to ... */
 714                 }
 715                 /*
 716                  * Check if the xprt has been disconnected in a
 717                  * recursive call in the service dispatch routine.
 718                  * If so, then break.
 719                  */
 720                 rwlock_rdlock(&svc_fd_lock);
 721                 if (xprt != __svc_xports[fd]) {
 722                         rwlock_unlock(&svc_fd_lock);
 723                         break;
 724                 }
 725                 rwlock_unlock(&svc_fd_lock);
 726 call_done:
 727                 if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
 728                         SVC_DESTROY(xprt);
 729                         break;
 730                 }
 731         } while (stat == XPRT_MOREREQS);
 732 }
 733
 734
 735 void
 736 svc_getreq_poll(pfdp, pollretval)
 737         struct pollfd   *pfdp;
 738         int     pollretval;
 739 {
 740         int i;
 741         int fds_found;
 742
 743         for (i = fds_found = 0; fds_found < pollretval; i++) {
 744                 struct pollfd *p = &pfdp[i];
 745
 746                 if (p->revents) {
 747                         /* fd has input waiting */
 748                         fds_found++;
 749                         /*
 750                          *      We assume that this function is only called
 751                          *      via someone _select()ing from svc_fdset or
 752                          *      _poll()ing from svc_pollset[].  Thus it's safe
 753                          *      to handle the POLLNVAL event by simply turning
 754                          *      the corresponding bit off in svc_fdset.  The
 755                          *      svc_pollset[] array is derived from svc_fdset
 756                          *      and so will also be updated eventually.
 757                          *
 758                          *      XXX Should we do an xprt_unregister() instead?
 759                          */
 760                         if (p->revents & POLLNVAL) {
 761                                 rwlock_wrlock(&svc_fd_lock);
 762                                 FD_CLR(p->fd, &svc_fdset);
 763                                 rwlock_unlock(&svc_fd_lock);
 764                         } else
 765                                 svc_getreq_common(p->fd);
 766                 }
 767         }
 768 }
 769
 770 bool_t
 771 rpc_control(int what, void *arg)
 772 {
 773         int val;
 774
 775         switch (what) {
 776         case RPC_SVC_CONNMAXREC_SET:
 777                 val = *(int *)arg;
 778                 if (val <= 0)
 779                         return FALSE;
 780                 __svc_maxrec = val;
 781                 return TRUE;
 782         case RPC_SVC_CONNMAXREC_GET:
 783                 *(int *)arg = __svc_maxrec;
 784                 return TRUE;
 785         default:
 786                 break;
 787         }
 788         return FALSE;
 789 }