17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
59acbbeafSnn * Common Development and Distribution License (the "License").
69acbbeafSnn * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
2161961e0fSrobinson
227c478bd9Sstevel@tonic-gate /*
239ff75adeSSurya Prakki * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
2429d91154SMarcel Telka * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
2548bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved.
26*b1cdc720SAlex Wilson * Copyright 2017 Joyent Inc
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate /*
297c478bd9Sstevel@tonic-gate * Copyright 1993 OpenVision Technologies, Inc., All Rights Reserved.
307c478bd9Sstevel@tonic-gate */
317c478bd9Sstevel@tonic-gate /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
327c478bd9Sstevel@tonic-gate /* All Rights Reserved */
337c478bd9Sstevel@tonic-gate /*
347c478bd9Sstevel@tonic-gate * Portions of this source code were derived from Berkeley
357c478bd9Sstevel@tonic-gate * 4.3 BSD under license from the Regents of the University of
367c478bd9Sstevel@tonic-gate * California.
377c478bd9Sstevel@tonic-gate */
387c478bd9Sstevel@tonic-gate
397c478bd9Sstevel@tonic-gate /*
407c478bd9Sstevel@tonic-gate * svc.c, Server-side remote procedure call interface.
417c478bd9Sstevel@tonic-gate *
427c478bd9Sstevel@tonic-gate * There are two sets of procedures here. The xprt routines are
437c478bd9Sstevel@tonic-gate * for handling transport handles. The svc routines handle the
447c478bd9Sstevel@tonic-gate * list of service routines.
457c478bd9Sstevel@tonic-gate *
467c478bd9Sstevel@tonic-gate */
477c478bd9Sstevel@tonic-gate
487c478bd9Sstevel@tonic-gate #include "mt.h"
497c478bd9Sstevel@tonic-gate #include "rpc_mt.h"
507c478bd9Sstevel@tonic-gate #include <assert.h>
517c478bd9Sstevel@tonic-gate #include <errno.h>
527c478bd9Sstevel@tonic-gate #include <sys/types.h>
537c478bd9Sstevel@tonic-gate #include <stropts.h>
547c478bd9Sstevel@tonic-gate #include <sys/conf.h>
557c478bd9Sstevel@tonic-gate #include <rpc/rpc.h>
56*b1cdc720SAlex Wilson #include <rpc/auth.h>
577c478bd9Sstevel@tonic-gate #ifdef PORTMAP
587c478bd9Sstevel@tonic-gate #include <rpc/pmap_clnt.h>
597c478bd9Sstevel@tonic-gate #endif
607c478bd9Sstevel@tonic-gate #include <sys/poll.h>
617c478bd9Sstevel@tonic-gate #include <netconfig.h>
627c478bd9Sstevel@tonic-gate #include <syslog.h>
637c478bd9Sstevel@tonic-gate #include <stdlib.h>
647c478bd9Sstevel@tonic-gate #include <unistd.h>
657c478bd9Sstevel@tonic-gate #include <string.h>
667c478bd9Sstevel@tonic-gate #include <limits.h>
677c478bd9Sstevel@tonic-gate
687c478bd9Sstevel@tonic-gate extern bool_t __svc_get_door_cred();
697c478bd9Sstevel@tonic-gate extern bool_t __rpc_get_local_cred();
707c478bd9Sstevel@tonic-gate
717c478bd9Sstevel@tonic-gate SVCXPRT **svc_xports;
727c478bd9Sstevel@tonic-gate static int nsvc_xports; /* total number of svc_xports allocated */
737c478bd9Sstevel@tonic-gate
747c478bd9Sstevel@tonic-gate XDR **svc_xdrs; /* common XDR receive area */
757c478bd9Sstevel@tonic-gate int nsvc_xdrs; /* total number of svc_xdrs allocated */
767c478bd9Sstevel@tonic-gate
777c478bd9Sstevel@tonic-gate int __rpc_use_pollfd_done; /* to unlimit the number of connections */
787c478bd9Sstevel@tonic-gate
797c478bd9Sstevel@tonic-gate #define NULL_SVC ((struct svc_callout *)0)
807c478bd9Sstevel@tonic-gate
817c478bd9Sstevel@tonic-gate /*
827c478bd9Sstevel@tonic-gate * The services list
837c478bd9Sstevel@tonic-gate * Each entry represents a set of procedures (an rpc program).
847c478bd9Sstevel@tonic-gate * The dispatch routine takes request structs and runs the
857c478bd9Sstevel@tonic-gate * appropriate procedure.
867c478bd9Sstevel@tonic-gate */
877c478bd9Sstevel@tonic-gate static struct svc_callout {
887c478bd9Sstevel@tonic-gate struct svc_callout *sc_next;
897c478bd9Sstevel@tonic-gate rpcprog_t sc_prog;
907c478bd9Sstevel@tonic-gate rpcvers_t sc_vers;
917c478bd9Sstevel@tonic-gate char *sc_netid;
927c478bd9Sstevel@tonic-gate void (*sc_dispatch)();
937c478bd9Sstevel@tonic-gate } *svc_head;
947c478bd9Sstevel@tonic-gate extern rwlock_t svc_lock;
957c478bd9Sstevel@tonic-gate
967c478bd9Sstevel@tonic-gate static struct svc_callout *svc_find();
977c478bd9Sstevel@tonic-gate int _svc_prog_dispatch();
987c478bd9Sstevel@tonic-gate void svc_getreq_common();
997c478bd9Sstevel@tonic-gate char *strdup();
1007c478bd9Sstevel@tonic-gate
1017c478bd9Sstevel@tonic-gate extern mutex_t svc_door_mutex;
1027c478bd9Sstevel@tonic-gate extern cond_t svc_door_waitcv;
1037c478bd9Sstevel@tonic-gate extern int svc_ndoorfds;
1047c478bd9Sstevel@tonic-gate extern SVCXPRT_LIST *_svc_xprtlist;
1057c478bd9Sstevel@tonic-gate extern mutex_t xprtlist_lock;
1067c478bd9Sstevel@tonic-gate extern void __svc_rm_from_xlist();
1077c478bd9Sstevel@tonic-gate
1082209d3c8SRichard Lowe #if !defined(_LP64)
1097c478bd9Sstevel@tonic-gate extern fd_set _new_svc_fdset;
1102209d3c8SRichard Lowe #endif
1117c478bd9Sstevel@tonic-gate
1127c478bd9Sstevel@tonic-gate /*
1137c478bd9Sstevel@tonic-gate * If the allocated array of reactor is too small, this value is used as a
1147c478bd9Sstevel@tonic-gate * margin. This reduces the number of allocations.
1157c478bd9Sstevel@tonic-gate */
1167c478bd9Sstevel@tonic-gate #define USER_FD_INCREMENT 5
1177c478bd9Sstevel@tonic-gate
1187c478bd9Sstevel@tonic-gate static void add_pollfd(int fd, short events);
1197c478bd9Sstevel@tonic-gate static void remove_pollfd(int fd);
1207c478bd9Sstevel@tonic-gate static void __svc_remove_input_of_fd(int fd);
1217c478bd9Sstevel@tonic-gate
1227c478bd9Sstevel@tonic-gate /*
1237c478bd9Sstevel@tonic-gate * Data used to handle reactor:
1247c478bd9Sstevel@tonic-gate * - one file descriptor we listen to,
1257c478bd9Sstevel@tonic-gate * - one callback we call if the fd pops,
1267c478bd9Sstevel@tonic-gate * - and a cookie passed as a parameter to the callback.
1277c478bd9Sstevel@tonic-gate *
1287c478bd9Sstevel@tonic-gate * The structure is an array indexed on the file descriptor. Each entry is
1297c478bd9Sstevel@tonic-gate * pointing to the first element of a double-linked list of callback.
1307c478bd9Sstevel@tonic-gate * only one callback may be associated to a couple (fd, event).
1317c478bd9Sstevel@tonic-gate */
1327c478bd9Sstevel@tonic-gate
1337c478bd9Sstevel@tonic-gate struct _svc_user_fd_head;
1347c478bd9Sstevel@tonic-gate
13561961e0fSrobinson typedef struct {
1367c478bd9Sstevel@tonic-gate struct _svc_user_fd_node *next;
1377c478bd9Sstevel@tonic-gate struct _svc_user_fd_node *previous;
1387c478bd9Sstevel@tonic-gate } _svc_user_link;
1397c478bd9Sstevel@tonic-gate
14061961e0fSrobinson typedef struct _svc_user_fd_node {
1417c478bd9Sstevel@tonic-gate _svc_user_link lnk;
1427c478bd9Sstevel@tonic-gate svc_input_id_t id;
1437c478bd9Sstevel@tonic-gate int fd;
1447c478bd9Sstevel@tonic-gate unsigned int events;
1457c478bd9Sstevel@tonic-gate svc_callback_t callback;
1467c478bd9Sstevel@tonic-gate void* cookie;
1477c478bd9Sstevel@tonic-gate } _svc_user_fd_node;
1487c478bd9Sstevel@tonic-gate
14961961e0fSrobinson typedef struct _svc_user_fd_head {
15029d91154SMarcel Telka struct _svc_user_fd_node *list;
1517c478bd9Sstevel@tonic-gate unsigned int mask; /* logical OR of all sub-masks */
1527c478bd9Sstevel@tonic-gate } _svc_user_fd_head;
1537c478bd9Sstevel@tonic-gate
1547c478bd9Sstevel@tonic-gate
1557c478bd9Sstevel@tonic-gate /* Array of defined reactor - indexed on file descriptor */
15629d91154SMarcel Telka static _svc_user_fd_head *svc_userfds = NULL;
1577c478bd9Sstevel@tonic-gate
1587c478bd9Sstevel@tonic-gate /* current size of file descriptor */
1597c478bd9Sstevel@tonic-gate static int svc_nuserfds = 0;
1607c478bd9Sstevel@tonic-gate
1617c478bd9Sstevel@tonic-gate /* Mutex to ensure MT safe operations for user fds callbacks. */
1627c478bd9Sstevel@tonic-gate static mutex_t svc_userfds_lock = DEFAULTMUTEX;
1637c478bd9Sstevel@tonic-gate
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate /*
1667c478bd9Sstevel@tonic-gate * This structure is used to have constant time alogrithms. There is an array
1677c478bd9Sstevel@tonic-gate * of this structure as large as svc_nuserfds. When the user is registering a
1687c478bd9Sstevel@tonic-gate * new callback, the address of the created structure is stored in a cell of
1697c478bd9Sstevel@tonic-gate * this array. The address of this cell is the returned unique identifier.
1707c478bd9Sstevel@tonic-gate *
1717c478bd9Sstevel@tonic-gate * On removing, the id is given by the user, then we know if this cell is
1727c478bd9Sstevel@tonic-gate * filled or not (with free). If it is free, we return an error. Otherwise,
1737c478bd9Sstevel@tonic-gate * we can free the structure pointed by fd_node.
1747c478bd9Sstevel@tonic-gate *
1757c478bd9Sstevel@tonic-gate * On insertion, we use the linked list created by (first_free,
1767c478bd9Sstevel@tonic-gate * next_free). In this way with a constant time computation, we can give a
1777c478bd9Sstevel@tonic-gate * correct index to the user.
1787c478bd9Sstevel@tonic-gate */
1797c478bd9Sstevel@tonic-gate
18061961e0fSrobinson typedef struct _svc_management_user_fd {
1817c478bd9Sstevel@tonic-gate bool_t free;
1827c478bd9Sstevel@tonic-gate union {
1837c478bd9Sstevel@tonic-gate svc_input_id_t next_free;
1847c478bd9Sstevel@tonic-gate _svc_user_fd_node *fd_node;
1857c478bd9Sstevel@tonic-gate } data;
1867c478bd9Sstevel@tonic-gate } _svc_management_user_fd;
1877c478bd9Sstevel@tonic-gate
1887c478bd9Sstevel@tonic-gate /* index to the first free elem */
1897c478bd9Sstevel@tonic-gate static svc_input_id_t first_free = (svc_input_id_t)-1;
1907c478bd9Sstevel@tonic-gate /* the size of this array is the same as svc_nuserfds */
1917c478bd9Sstevel@tonic-gate static _svc_management_user_fd* user_fd_mgt_array = NULL;
1927c478bd9Sstevel@tonic-gate
1937c478bd9Sstevel@tonic-gate /* current size of user_fd_mgt_array */
1947c478bd9Sstevel@tonic-gate static int svc_nmgtuserfds = 0;
1957c478bd9Sstevel@tonic-gate
1967c478bd9Sstevel@tonic-gate
1977c478bd9Sstevel@tonic-gate /* Define some macros to access data associated to registration ids. */
1987c478bd9Sstevel@tonic-gate #define node_from_id(id) (user_fd_mgt_array[(int)id].data.fd_node)
1997c478bd9Sstevel@tonic-gate #define is_free_id(id) (user_fd_mgt_array[(int)id].free)
2007c478bd9Sstevel@tonic-gate
2017c478bd9Sstevel@tonic-gate #ifndef POLLSTANDARD
2027c478bd9Sstevel@tonic-gate #define POLLSTANDARD \
2037c478bd9Sstevel@tonic-gate (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLRDBAND| \
2047c478bd9Sstevel@tonic-gate POLLWRBAND|POLLERR|POLLHUP|POLLNVAL)
2057c478bd9Sstevel@tonic-gate #endif
2067c478bd9Sstevel@tonic-gate
2077c478bd9Sstevel@tonic-gate /*
2087c478bd9Sstevel@tonic-gate * To free an Id, we set the cell as free and insert its address in the list
2097c478bd9Sstevel@tonic-gate * of free cell.
2107c478bd9Sstevel@tonic-gate */
2117c478bd9Sstevel@tonic-gate
2127c478bd9Sstevel@tonic-gate static void
_svc_free_id(const svc_input_id_t id)2137c478bd9Sstevel@tonic-gate _svc_free_id(const svc_input_id_t id)
2147c478bd9Sstevel@tonic-gate {
2157c478bd9Sstevel@tonic-gate assert(((int)id >= 0) && ((int)id < svc_nmgtuserfds));
2167c478bd9Sstevel@tonic-gate user_fd_mgt_array[(int)id].free = TRUE;
2177c478bd9Sstevel@tonic-gate user_fd_mgt_array[(int)id].data.next_free = first_free;
2187c478bd9Sstevel@tonic-gate first_free = id;
2197c478bd9Sstevel@tonic-gate }
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate /*
2227c478bd9Sstevel@tonic-gate * To get a free cell, we just have to take it from the free linked list and
2237c478bd9Sstevel@tonic-gate * set the flag to "not free". This function also allocates new memory if
2247c478bd9Sstevel@tonic-gate * necessary
2257c478bd9Sstevel@tonic-gate */
2267c478bd9Sstevel@tonic-gate static svc_input_id_t
_svc_attribute_new_id(_svc_user_fd_node * node)2277c478bd9Sstevel@tonic-gate _svc_attribute_new_id(_svc_user_fd_node *node)
2287c478bd9Sstevel@tonic-gate {
2297c478bd9Sstevel@tonic-gate int selected_index = (int)first_free;
2307c478bd9Sstevel@tonic-gate assert(node != NULL);
2317c478bd9Sstevel@tonic-gate
2327c478bd9Sstevel@tonic-gate if (selected_index == -1) {
2337c478bd9Sstevel@tonic-gate /* Allocate new entries */
2347c478bd9Sstevel@tonic-gate int L_inOldSize = svc_nmgtuserfds;
2357c478bd9Sstevel@tonic-gate int i;
23629d91154SMarcel Telka _svc_management_user_fd *tmp;
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate svc_nmgtuserfds += USER_FD_INCREMENT;
2397c478bd9Sstevel@tonic-gate
24029d91154SMarcel Telka tmp = realloc(user_fd_mgt_array,
24129d91154SMarcel Telka svc_nmgtuserfds * sizeof (_svc_management_user_fd));
2427c478bd9Sstevel@tonic-gate
24329d91154SMarcel Telka if (tmp == NULL) {
2447c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "_svc_attribute_new_id: out of memory");
24529d91154SMarcel Telka svc_nmgtuserfds = L_inOldSize;
2467c478bd9Sstevel@tonic-gate errno = ENOMEM;
2477c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
2487c478bd9Sstevel@tonic-gate }
2497c478bd9Sstevel@tonic-gate
25029d91154SMarcel Telka user_fd_mgt_array = tmp;
25129d91154SMarcel Telka
2527c478bd9Sstevel@tonic-gate for (i = svc_nmgtuserfds - 1; i >= L_inOldSize; i--)
2537c478bd9Sstevel@tonic-gate _svc_free_id((svc_input_id_t)i);
2547c478bd9Sstevel@tonic-gate selected_index = (int)first_free;
2557c478bd9Sstevel@tonic-gate }
2567c478bd9Sstevel@tonic-gate
2577c478bd9Sstevel@tonic-gate node->id = (svc_input_id_t)selected_index;
2587c478bd9Sstevel@tonic-gate first_free = user_fd_mgt_array[selected_index].data.next_free;
2597c478bd9Sstevel@tonic-gate
2607c478bd9Sstevel@tonic-gate user_fd_mgt_array[selected_index].data.fd_node = node;
2617c478bd9Sstevel@tonic-gate user_fd_mgt_array[selected_index].free = FALSE;
2627c478bd9Sstevel@tonic-gate
2637c478bd9Sstevel@tonic-gate return ((svc_input_id_t)selected_index);
2647c478bd9Sstevel@tonic-gate }
2657c478bd9Sstevel@tonic-gate
2667c478bd9Sstevel@tonic-gate /*
2677c478bd9Sstevel@tonic-gate * Access to a pollfd treatment. Scan all the associated callbacks that have
2687c478bd9Sstevel@tonic-gate * at least one bit in their mask that masks a received event.
2697c478bd9Sstevel@tonic-gate *
2707c478bd9Sstevel@tonic-gate * If event POLLNVAL is received, we check that one callback processes it, if
2717c478bd9Sstevel@tonic-gate * not, then remove the file descriptor from the poll. If there is one, let
2727c478bd9Sstevel@tonic-gate * the user do the work.
2737c478bd9Sstevel@tonic-gate */
2747c478bd9Sstevel@tonic-gate void
__svc_getreq_user(struct pollfd * pfd)2757c478bd9Sstevel@tonic-gate __svc_getreq_user(struct pollfd *pfd)
2767c478bd9Sstevel@tonic-gate {
2777c478bd9Sstevel@tonic-gate int fd = pfd->fd;
2787c478bd9Sstevel@tonic-gate short revents = pfd->revents;
2797c478bd9Sstevel@tonic-gate bool_t invalHandled = FALSE;
2807c478bd9Sstevel@tonic-gate _svc_user_fd_node *node;
2817c478bd9Sstevel@tonic-gate
28261961e0fSrobinson (void) mutex_lock(&svc_userfds_lock);
2837c478bd9Sstevel@tonic-gate
2847c478bd9Sstevel@tonic-gate if ((fd < 0) || (fd >= svc_nuserfds)) {
28561961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
2867c478bd9Sstevel@tonic-gate return;
2877c478bd9Sstevel@tonic-gate }
2887c478bd9Sstevel@tonic-gate
28929d91154SMarcel Telka node = svc_userfds[fd].list;
2907c478bd9Sstevel@tonic-gate
2917c478bd9Sstevel@tonic-gate /* check if at least one mask fits */
2927c478bd9Sstevel@tonic-gate if (0 == (revents & svc_userfds[fd].mask)) {
29361961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
2947c478bd9Sstevel@tonic-gate return;
2957c478bd9Sstevel@tonic-gate }
2967c478bd9Sstevel@tonic-gate
29729d91154SMarcel Telka while ((svc_userfds[fd].mask != 0) && (node != NULL)) {
2987c478bd9Sstevel@tonic-gate /*
2997c478bd9Sstevel@tonic-gate * If one of the received events maps the ones the node listens
3007c478bd9Sstevel@tonic-gate * to
3017c478bd9Sstevel@tonic-gate */
3027c478bd9Sstevel@tonic-gate _svc_user_fd_node *next = node->lnk.next;
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate if (node->callback != NULL) {
3057c478bd9Sstevel@tonic-gate if (node->events & revents) {
3067c478bd9Sstevel@tonic-gate if (revents & POLLNVAL) {
3077c478bd9Sstevel@tonic-gate invalHandled = TRUE;
3087c478bd9Sstevel@tonic-gate }
3097c478bd9Sstevel@tonic-gate
3107c478bd9Sstevel@tonic-gate /*
3117c478bd9Sstevel@tonic-gate * The lock must be released before calling the
3127c478bd9Sstevel@tonic-gate * user function, as this function can call
3137c478bd9Sstevel@tonic-gate * svc_remove_input() for example.
3147c478bd9Sstevel@tonic-gate */
31561961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
3167c478bd9Sstevel@tonic-gate node->callback(node->id, node->fd,
3177c478bd9Sstevel@tonic-gate node->events & revents, node->cookie);
3187c478bd9Sstevel@tonic-gate /*
3197c478bd9Sstevel@tonic-gate * Do not use the node structure anymore, as it
3207c478bd9Sstevel@tonic-gate * could have been deallocated by the previous
3217c478bd9Sstevel@tonic-gate * callback.
3227c478bd9Sstevel@tonic-gate */
32361961e0fSrobinson (void) mutex_lock(&svc_userfds_lock);
3247c478bd9Sstevel@tonic-gate }
3257c478bd9Sstevel@tonic-gate }
3267c478bd9Sstevel@tonic-gate node = next;
3277c478bd9Sstevel@tonic-gate }
3287c478bd9Sstevel@tonic-gate
3297c478bd9Sstevel@tonic-gate if ((revents & POLLNVAL) && !invalHandled)
3307c478bd9Sstevel@tonic-gate __svc_remove_input_of_fd(fd);
33161961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
3327c478bd9Sstevel@tonic-gate }
3337c478bd9Sstevel@tonic-gate
3347c478bd9Sstevel@tonic-gate
3357c478bd9Sstevel@tonic-gate /*
3367c478bd9Sstevel@tonic-gate * Check if a file descriptor is associated with a user reactor.
3377c478bd9Sstevel@tonic-gate * To do this, just check that the array indexed on fd has a non-void linked
3387c478bd9Sstevel@tonic-gate * list (ie. first element is not NULL)
3397c478bd9Sstevel@tonic-gate */
3407c478bd9Sstevel@tonic-gate bool_t
__is_a_userfd(int fd)3417c478bd9Sstevel@tonic-gate __is_a_userfd(int fd)
3427c478bd9Sstevel@tonic-gate {
3437c478bd9Sstevel@tonic-gate /* Checks argument */
3447c478bd9Sstevel@tonic-gate if ((fd < 0) || (fd >= svc_nuserfds))
3457c478bd9Sstevel@tonic-gate return (FALSE);
3467c478bd9Sstevel@tonic-gate return ((svc_userfds[fd].mask == 0x0000)? FALSE:TRUE);
3477c478bd9Sstevel@tonic-gate }
3487c478bd9Sstevel@tonic-gate
3497c478bd9Sstevel@tonic-gate /* free everything concerning user fd */
3507c478bd9Sstevel@tonic-gate /* used in svc_run.c => no static */
3517c478bd9Sstevel@tonic-gate
3527c478bd9Sstevel@tonic-gate void
__destroy_userfd(void)35361961e0fSrobinson __destroy_userfd(void)
3547c478bd9Sstevel@tonic-gate {
3557c478bd9Sstevel@tonic-gate int one_fd;
3567c478bd9Sstevel@tonic-gate /* Clean user fd */
3577c478bd9Sstevel@tonic-gate if (svc_userfds != NULL) {
3587c478bd9Sstevel@tonic-gate for (one_fd = 0; one_fd < svc_nuserfds; one_fd++) {
3597c478bd9Sstevel@tonic-gate _svc_user_fd_node *node;
3607c478bd9Sstevel@tonic-gate
36129d91154SMarcel Telka node = svc_userfds[one_fd].list;
36229d91154SMarcel Telka while (node != NULL) {
36329d91154SMarcel Telka _svc_user_fd_node *tmp = node;
3647c478bd9Sstevel@tonic-gate _svc_free_id(node->id);
3657c478bd9Sstevel@tonic-gate node = node->lnk.next;
36629d91154SMarcel Telka free(tmp);
3677c478bd9Sstevel@tonic-gate }
3687c478bd9Sstevel@tonic-gate }
3697c478bd9Sstevel@tonic-gate
3707c478bd9Sstevel@tonic-gate free(user_fd_mgt_array);
3717c478bd9Sstevel@tonic-gate user_fd_mgt_array = NULL;
3727c478bd9Sstevel@tonic-gate first_free = (svc_input_id_t)-1;
3737c478bd9Sstevel@tonic-gate
3747c478bd9Sstevel@tonic-gate free(svc_userfds);
3757c478bd9Sstevel@tonic-gate svc_userfds = NULL;
3767c478bd9Sstevel@tonic-gate svc_nuserfds = 0;
3777c478bd9Sstevel@tonic-gate }
3787c478bd9Sstevel@tonic-gate }
3797c478bd9Sstevel@tonic-gate
3807c478bd9Sstevel@tonic-gate /*
3817c478bd9Sstevel@tonic-gate * Remove all the callback associated with a fd => useful when the fd is
3827c478bd9Sstevel@tonic-gate * closed for instance
3837c478bd9Sstevel@tonic-gate */
3847c478bd9Sstevel@tonic-gate static void
__svc_remove_input_of_fd(int fd)3857c478bd9Sstevel@tonic-gate __svc_remove_input_of_fd(int fd)
3867c478bd9Sstevel@tonic-gate {
38729d91154SMarcel Telka _svc_user_fd_node **pnode;
38829d91154SMarcel Telka _svc_user_fd_node *tmp;
3897c478bd9Sstevel@tonic-gate
3907c478bd9Sstevel@tonic-gate if ((fd < 0) || (fd >= svc_nuserfds))
3917c478bd9Sstevel@tonic-gate return;
3927c478bd9Sstevel@tonic-gate
39329d91154SMarcel Telka pnode = &svc_userfds[fd].list;
39429d91154SMarcel Telka while ((tmp = *pnode) != NULL) {
39529d91154SMarcel Telka *pnode = tmp->lnk.next;
39629d91154SMarcel Telka
39729d91154SMarcel Telka _svc_free_id(tmp->id);
39829d91154SMarcel Telka free(tmp);
3997c478bd9Sstevel@tonic-gate }
4007c478bd9Sstevel@tonic-gate
4017c478bd9Sstevel@tonic-gate svc_userfds[fd].mask = 0;
4027c478bd9Sstevel@tonic-gate }
4037c478bd9Sstevel@tonic-gate
4047c478bd9Sstevel@tonic-gate /*
4057c478bd9Sstevel@tonic-gate * Allow user to add an fd in the poll list. If it does not succeed, return
4067c478bd9Sstevel@tonic-gate * -1. Otherwise, return a svc_id
4077c478bd9Sstevel@tonic-gate */
4087c478bd9Sstevel@tonic-gate
4097c478bd9Sstevel@tonic-gate svc_input_id_t
svc_add_input(int user_fd,unsigned int events,svc_callback_t user_callback,void * cookie)4107c478bd9Sstevel@tonic-gate svc_add_input(int user_fd, unsigned int events,
4117c478bd9Sstevel@tonic-gate svc_callback_t user_callback, void *cookie)
4127c478bd9Sstevel@tonic-gate {
4137c478bd9Sstevel@tonic-gate _svc_user_fd_node *new_node;
4147c478bd9Sstevel@tonic-gate
4157c478bd9Sstevel@tonic-gate if (user_fd < 0) {
4167c478bd9Sstevel@tonic-gate errno = EINVAL;
4177c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
4187c478bd9Sstevel@tonic-gate }
4197c478bd9Sstevel@tonic-gate
4207c478bd9Sstevel@tonic-gate if ((events == 0x0000) ||
4217c478bd9Sstevel@tonic-gate (events & ~(POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLRDBAND|\
4227c478bd9Sstevel@tonic-gate POLLWRBAND|POLLERR|POLLHUP|POLLNVAL))) {
4237c478bd9Sstevel@tonic-gate errno = EINVAL;
4247c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
4257c478bd9Sstevel@tonic-gate }
4267c478bd9Sstevel@tonic-gate
42761961e0fSrobinson (void) mutex_lock(&svc_userfds_lock);
4287c478bd9Sstevel@tonic-gate
4297c478bd9Sstevel@tonic-gate if ((user_fd < svc_nuserfds) &&
4307c478bd9Sstevel@tonic-gate (svc_userfds[user_fd].mask & events) != 0) {
4317c478bd9Sstevel@tonic-gate /* Already registrated call-back */
4327c478bd9Sstevel@tonic-gate errno = EEXIST;
43361961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
4347c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
4357c478bd9Sstevel@tonic-gate }
4367c478bd9Sstevel@tonic-gate
4377c478bd9Sstevel@tonic-gate /* Handle memory allocation. */
4387c478bd9Sstevel@tonic-gate if (user_fd >= svc_nuserfds) {
4397c478bd9Sstevel@tonic-gate int oldSize = svc_nuserfds;
4407c478bd9Sstevel@tonic-gate int i;
44129d91154SMarcel Telka _svc_user_fd_head *tmp;
4427c478bd9Sstevel@tonic-gate
4437c478bd9Sstevel@tonic-gate svc_nuserfds = (user_fd + 1) + USER_FD_INCREMENT;
4447c478bd9Sstevel@tonic-gate
44529d91154SMarcel Telka tmp = realloc(svc_userfds,
44629d91154SMarcel Telka svc_nuserfds * sizeof (_svc_user_fd_head));
4477c478bd9Sstevel@tonic-gate
44829d91154SMarcel Telka if (tmp == NULL) {
4497c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "svc_add_input: out of memory");
45029d91154SMarcel Telka svc_nuserfds = oldSize;
4517c478bd9Sstevel@tonic-gate errno = ENOMEM;
45261961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
4537c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
4547c478bd9Sstevel@tonic-gate }
4557c478bd9Sstevel@tonic-gate
45629d91154SMarcel Telka svc_userfds = tmp;
45729d91154SMarcel Telka
4587c478bd9Sstevel@tonic-gate for (i = oldSize; i < svc_nuserfds; i++) {
45929d91154SMarcel Telka svc_userfds[i].list = NULL;
4607c478bd9Sstevel@tonic-gate svc_userfds[i].mask = 0;
4617c478bd9Sstevel@tonic-gate }
4627c478bd9Sstevel@tonic-gate }
4637c478bd9Sstevel@tonic-gate
46461961e0fSrobinson new_node = malloc(sizeof (_svc_user_fd_node));
4657c478bd9Sstevel@tonic-gate if (new_node == NULL) {
4667c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "svc_add_input: out of memory");
4677c478bd9Sstevel@tonic-gate errno = ENOMEM;
46861961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
4697c478bd9Sstevel@tonic-gate return ((svc_input_id_t)-1);
4707c478bd9Sstevel@tonic-gate }
4717c478bd9Sstevel@tonic-gate
4727c478bd9Sstevel@tonic-gate /* create a new node */
4737c478bd9Sstevel@tonic-gate new_node->fd = user_fd;
4747c478bd9Sstevel@tonic-gate new_node->events = events;
4757c478bd9Sstevel@tonic-gate new_node->callback = user_callback;
4767c478bd9Sstevel@tonic-gate new_node->cookie = cookie;
4777c478bd9Sstevel@tonic-gate
47829d91154SMarcel Telka if (_svc_attribute_new_id(new_node) == -1) {
47929d91154SMarcel Telka (void) mutex_unlock(&svc_userfds_lock);
48029d91154SMarcel Telka free(new_node);
48129d91154SMarcel Telka return ((svc_input_id_t)-1);
48229d91154SMarcel Telka }
4837c478bd9Sstevel@tonic-gate
4847c478bd9Sstevel@tonic-gate /* Add the new element at the beginning of the list. */
48529d91154SMarcel Telka if (svc_userfds[user_fd].list != NULL)
48629d91154SMarcel Telka svc_userfds[user_fd].list->lnk.previous = new_node;
48729d91154SMarcel Telka new_node->lnk.next = svc_userfds[user_fd].list;
48829d91154SMarcel Telka new_node->lnk.previous = NULL;
4897c478bd9Sstevel@tonic-gate
49029d91154SMarcel Telka svc_userfds[user_fd].list = new_node;
4917c478bd9Sstevel@tonic-gate
4927c478bd9Sstevel@tonic-gate /* refresh global mask for this file desciptor */
4937c478bd9Sstevel@tonic-gate svc_userfds[user_fd].mask |= events;
4947c478bd9Sstevel@tonic-gate
4957c478bd9Sstevel@tonic-gate /* refresh mask for the poll */
4967c478bd9Sstevel@tonic-gate add_pollfd(user_fd, (svc_userfds[user_fd].mask));
4977c478bd9Sstevel@tonic-gate
49861961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
4997c478bd9Sstevel@tonic-gate return (new_node->id);
5007c478bd9Sstevel@tonic-gate }
5017c478bd9Sstevel@tonic-gate
5027c478bd9Sstevel@tonic-gate int
svc_remove_input(svc_input_id_t id)5037c478bd9Sstevel@tonic-gate svc_remove_input(svc_input_id_t id)
5047c478bd9Sstevel@tonic-gate {
5057c478bd9Sstevel@tonic-gate _svc_user_fd_node* node;
5067c478bd9Sstevel@tonic-gate _svc_user_fd_node* next;
5077c478bd9Sstevel@tonic-gate _svc_user_fd_node* previous;
5087c478bd9Sstevel@tonic-gate int fd; /* caching optim */
5097c478bd9Sstevel@tonic-gate
51061961e0fSrobinson (void) mutex_lock(&svc_userfds_lock);
5117c478bd9Sstevel@tonic-gate
5127c478bd9Sstevel@tonic-gate /* Immediately update data for id management */
5137c478bd9Sstevel@tonic-gate if (user_fd_mgt_array == NULL || id >= svc_nmgtuserfds ||
5147c478bd9Sstevel@tonic-gate is_free_id(id)) {
5157c478bd9Sstevel@tonic-gate errno = EINVAL;
51661961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
5177c478bd9Sstevel@tonic-gate return (-1);
5187c478bd9Sstevel@tonic-gate }
5197c478bd9Sstevel@tonic-gate
5207c478bd9Sstevel@tonic-gate node = node_from_id(id);
5217c478bd9Sstevel@tonic-gate assert(node != NULL);
5227c478bd9Sstevel@tonic-gate
5237c478bd9Sstevel@tonic-gate _svc_free_id(id);
5247c478bd9Sstevel@tonic-gate next = node->lnk.next;
5257c478bd9Sstevel@tonic-gate previous = node->lnk.previous;
5267c478bd9Sstevel@tonic-gate fd = node->fd; /* caching optim */
5277c478bd9Sstevel@tonic-gate
52829d91154SMarcel Telka /* Remove this node from the list. */
52929d91154SMarcel Telka if (previous != NULL) {
53029d91154SMarcel Telka previous->lnk.next = next;
53129d91154SMarcel Telka } else {
53229d91154SMarcel Telka assert(svc_userfds[fd].list == node);
53329d91154SMarcel Telka svc_userfds[fd].list = next;
53429d91154SMarcel Telka }
53529d91154SMarcel Telka if (next != NULL)
53629d91154SMarcel Telka next->lnk.previous = previous;
5377c478bd9Sstevel@tonic-gate
53829d91154SMarcel Telka /* Remove the node flags from the global mask */
5397c478bd9Sstevel@tonic-gate svc_userfds[fd].mask ^= node->events;
5407c478bd9Sstevel@tonic-gate
5417c478bd9Sstevel@tonic-gate free(node);
5427c478bd9Sstevel@tonic-gate if (svc_userfds[fd].mask == 0) {
54329d91154SMarcel Telka assert(svc_userfds[fd].list == NULL);
5447c478bd9Sstevel@tonic-gate remove_pollfd(fd);
54529d91154SMarcel Telka } else {
54629d91154SMarcel Telka assert(svc_userfds[fd].list != NULL);
5477c478bd9Sstevel@tonic-gate }
5487c478bd9Sstevel@tonic-gate /* <=> CLEAN NEEDED TO SHRINK MEMORY USAGE */
5497c478bd9Sstevel@tonic-gate
55061961e0fSrobinson (void) mutex_unlock(&svc_userfds_lock);
5517c478bd9Sstevel@tonic-gate return (0);
5527c478bd9Sstevel@tonic-gate }
5537c478bd9Sstevel@tonic-gate
5547c478bd9Sstevel@tonic-gate /*
5557c478bd9Sstevel@tonic-gate * Provides default service-side functions for authentication flavors
5567c478bd9Sstevel@tonic-gate * that do not use all the fields in struct svc_auth_ops.
5577c478bd9Sstevel@tonic-gate */
5587c478bd9Sstevel@tonic-gate
5597c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5607c478bd9Sstevel@tonic-gate static int
authany_wrap(AUTH * auth,XDR * xdrs,xdrproc_t xfunc,caddr_t xwhere)56161961e0fSrobinson authany_wrap(AUTH *auth, XDR *xdrs, xdrproc_t xfunc, caddr_t xwhere)
5627c478bd9Sstevel@tonic-gate {
5637c478bd9Sstevel@tonic-gate return (*xfunc)(xdrs, xwhere);
5647c478bd9Sstevel@tonic-gate }
5657c478bd9Sstevel@tonic-gate
5667c478bd9Sstevel@tonic-gate struct svc_auth_ops svc_auth_any_ops = {
5677c478bd9Sstevel@tonic-gate authany_wrap,
5687c478bd9Sstevel@tonic-gate authany_wrap,
5697c478bd9Sstevel@tonic-gate };
5707c478bd9Sstevel@tonic-gate
5717c478bd9Sstevel@tonic-gate /*
5727c478bd9Sstevel@tonic-gate * Return pointer to server authentication structure.
5737c478bd9Sstevel@tonic-gate */
5747c478bd9Sstevel@tonic-gate SVCAUTH *
__svc_get_svcauth(SVCXPRT * xprt)57561961e0fSrobinson __svc_get_svcauth(SVCXPRT *xprt)
5767c478bd9Sstevel@tonic-gate {
5777c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
5787c478bd9Sstevel@tonic-gate return (&SVC_XP_AUTH(xprt));
5797c478bd9Sstevel@tonic-gate }
5807c478bd9Sstevel@tonic-gate
5817c478bd9Sstevel@tonic-gate /*
5827c478bd9Sstevel@tonic-gate * A callback routine to cleanup after a procedure is executed.
5837c478bd9Sstevel@tonic-gate */
5847c478bd9Sstevel@tonic-gate void (*__proc_cleanup_cb)() = NULL;
5857c478bd9Sstevel@tonic-gate
5867c478bd9Sstevel@tonic-gate void *
__svc_set_proc_cleanup_cb(void * cb)58761961e0fSrobinson __svc_set_proc_cleanup_cb(void *cb)
5887c478bd9Sstevel@tonic-gate {
5897c478bd9Sstevel@tonic-gate void *tmp = (void *)__proc_cleanup_cb;
5907c478bd9Sstevel@tonic-gate
5917c478bd9Sstevel@tonic-gate __proc_cleanup_cb = (void (*)())cb;
5927c478bd9Sstevel@tonic-gate return (tmp);
5937c478bd9Sstevel@tonic-gate }
5947c478bd9Sstevel@tonic-gate
5957c478bd9Sstevel@tonic-gate /* *************** SVCXPRT related stuff **************** */
5967c478bd9Sstevel@tonic-gate
5977c478bd9Sstevel@tonic-gate
5987c478bd9Sstevel@tonic-gate static int pollfd_shrinking = 1;
5997c478bd9Sstevel@tonic-gate
6007c478bd9Sstevel@tonic-gate
6017c478bd9Sstevel@tonic-gate /*
6027c478bd9Sstevel@tonic-gate * Add fd to svc_pollfd
6037c478bd9Sstevel@tonic-gate */
6047c478bd9Sstevel@tonic-gate static void
add_pollfd(int fd,short events)6057c478bd9Sstevel@tonic-gate add_pollfd(int fd, short events)
6067c478bd9Sstevel@tonic-gate {
6077c478bd9Sstevel@tonic-gate if (fd < FD_SETSIZE) {
6087c478bd9Sstevel@tonic-gate FD_SET(fd, &svc_fdset);
6097c478bd9Sstevel@tonic-gate #if !defined(_LP64)
6107c478bd9Sstevel@tonic-gate FD_SET(fd, &_new_svc_fdset);
6117c478bd9Sstevel@tonic-gate #endif
6127c478bd9Sstevel@tonic-gate svc_nfds++;
6137c478bd9Sstevel@tonic-gate svc_nfds_set++;
6147c478bd9Sstevel@tonic-gate if (fd >= svc_max_fd)
6157c478bd9Sstevel@tonic-gate svc_max_fd = fd + 1;
6167c478bd9Sstevel@tonic-gate }
6177c478bd9Sstevel@tonic-gate if (fd >= svc_max_pollfd)
6187c478bd9Sstevel@tonic-gate svc_max_pollfd = fd + 1;
6197c478bd9Sstevel@tonic-gate if (svc_max_pollfd > svc_pollfd_allocd) {
6207c478bd9Sstevel@tonic-gate int i = svc_pollfd_allocd;
6217c478bd9Sstevel@tonic-gate pollfd_t *tmp;
6227c478bd9Sstevel@tonic-gate do {
6237c478bd9Sstevel@tonic-gate svc_pollfd_allocd += POLLFD_EXTEND;
6247c478bd9Sstevel@tonic-gate } while (svc_max_pollfd > svc_pollfd_allocd);
6257c478bd9Sstevel@tonic-gate tmp = realloc(svc_pollfd,
62629d91154SMarcel Telka sizeof (pollfd_t) * svc_pollfd_allocd);
6277c478bd9Sstevel@tonic-gate if (tmp != NULL) {
6287c478bd9Sstevel@tonic-gate svc_pollfd = tmp;
6297c478bd9Sstevel@tonic-gate for (; i < svc_pollfd_allocd; i++)
6307c478bd9Sstevel@tonic-gate POLLFD_CLR(i, tmp);
6317c478bd9Sstevel@tonic-gate } else {
6327c478bd9Sstevel@tonic-gate /*
6337c478bd9Sstevel@tonic-gate * give an error message; undo fdset setting
6347c478bd9Sstevel@tonic-gate * above; reset the pollfd_shrinking flag.
6357c478bd9Sstevel@tonic-gate * because of this poll will not be done
6367c478bd9Sstevel@tonic-gate * on these fds.
6377c478bd9Sstevel@tonic-gate */
6387c478bd9Sstevel@tonic-gate if (fd < FD_SETSIZE) {
6397c478bd9Sstevel@tonic-gate FD_CLR(fd, &svc_fdset);
6407c478bd9Sstevel@tonic-gate #if !defined(_LP64)
6417c478bd9Sstevel@tonic-gate FD_CLR(fd, &_new_svc_fdset);
6427c478bd9Sstevel@tonic-gate #endif
6437c478bd9Sstevel@tonic-gate svc_nfds--;
6447c478bd9Sstevel@tonic-gate svc_nfds_set--;
6457c478bd9Sstevel@tonic-gate if (fd == (svc_max_fd - 1))
6467c478bd9Sstevel@tonic-gate svc_max_fd--;
6477c478bd9Sstevel@tonic-gate }
6487c478bd9Sstevel@tonic-gate if (fd == (svc_max_pollfd - 1))
6497c478bd9Sstevel@tonic-gate svc_max_pollfd--;
6507c478bd9Sstevel@tonic-gate pollfd_shrinking = 0;
6517c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "add_pollfd: out of memory");
6527c478bd9Sstevel@tonic-gate _exit(1);
6537c478bd9Sstevel@tonic-gate }
6547c478bd9Sstevel@tonic-gate }
6557c478bd9Sstevel@tonic-gate svc_pollfd[fd].fd = fd;
6567c478bd9Sstevel@tonic-gate svc_pollfd[fd].events = events;
6577c478bd9Sstevel@tonic-gate svc_npollfds++;
6587c478bd9Sstevel@tonic-gate svc_npollfds_set++;
6597c478bd9Sstevel@tonic-gate }
6607c478bd9Sstevel@tonic-gate
6617c478bd9Sstevel@tonic-gate /*
6627c478bd9Sstevel@tonic-gate * the fd is still active but only the bit in fdset is cleared.
6637c478bd9Sstevel@tonic-gate * do not subtract svc_nfds or svc_npollfds
6647c478bd9Sstevel@tonic-gate */
6657c478bd9Sstevel@tonic-gate void
clear_pollfd(int fd)6667c478bd9Sstevel@tonic-gate clear_pollfd(int fd)
6677c478bd9Sstevel@tonic-gate {
6687c478bd9Sstevel@tonic-gate if (fd < FD_SETSIZE && FD_ISSET(fd, &svc_fdset)) {
6697c478bd9Sstevel@tonic-gate FD_CLR(fd, &svc_fdset);
6707c478bd9Sstevel@tonic-gate #if !defined(_LP64)
6717c478bd9Sstevel@tonic-gate FD_CLR(fd, &_new_svc_fdset);
6727c478bd9Sstevel@tonic-gate #endif
6737c478bd9Sstevel@tonic-gate svc_nfds_set--;
6747c478bd9Sstevel@tonic-gate }
6757c478bd9Sstevel@tonic-gate if (fd < svc_pollfd_allocd && POLLFD_ISSET(fd, svc_pollfd)) {
6767c478bd9Sstevel@tonic-gate POLLFD_CLR(fd, svc_pollfd);
6777c478bd9Sstevel@tonic-gate svc_npollfds_set--;
6787c478bd9Sstevel@tonic-gate }
6797c478bd9Sstevel@tonic-gate }
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate /*
6827c478bd9Sstevel@tonic-gate * sets the bit in fdset for an active fd so that poll() is done for that
6837c478bd9Sstevel@tonic-gate */
6847c478bd9Sstevel@tonic-gate void
set_pollfd(int fd,short events)6857c478bd9Sstevel@tonic-gate set_pollfd(int fd, short events)
6867c478bd9Sstevel@tonic-gate {
6877c478bd9Sstevel@tonic-gate if (fd < FD_SETSIZE) {
6887c478bd9Sstevel@tonic-gate FD_SET(fd, &svc_fdset);
6897c478bd9Sstevel@tonic-gate #if !defined(_LP64)
6907c478bd9Sstevel@tonic-gate FD_SET(fd, &_new_svc_fdset);
6917c478bd9Sstevel@tonic-gate #endif
6927c478bd9Sstevel@tonic-gate svc_nfds_set++;
6937c478bd9Sstevel@tonic-gate }
6947c478bd9Sstevel@tonic-gate if (fd < svc_pollfd_allocd) {
6957c478bd9Sstevel@tonic-gate svc_pollfd[fd].fd = fd;
6967c478bd9Sstevel@tonic-gate svc_pollfd[fd].events = events;
6977c478bd9Sstevel@tonic-gate svc_npollfds_set++;
6987c478bd9Sstevel@tonic-gate }
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate
7017c478bd9Sstevel@tonic-gate /*
7027c478bd9Sstevel@tonic-gate * remove a svc_pollfd entry; it does not shrink the memory
7037c478bd9Sstevel@tonic-gate */
7047c478bd9Sstevel@tonic-gate static void
remove_pollfd(int fd)70561961e0fSrobinson remove_pollfd(int fd)
7067c478bd9Sstevel@tonic-gate {
7077c478bd9Sstevel@tonic-gate clear_pollfd(fd);
7087c478bd9Sstevel@tonic-gate if (fd == (svc_max_fd - 1))
7097c478bd9Sstevel@tonic-gate svc_max_fd--;
7107c478bd9Sstevel@tonic-gate svc_nfds--;
7117c478bd9Sstevel@tonic-gate if (fd == (svc_max_pollfd - 1))
7127c478bd9Sstevel@tonic-gate svc_max_pollfd--;
7137c478bd9Sstevel@tonic-gate svc_npollfds--;
7147c478bd9Sstevel@tonic-gate }
7157c478bd9Sstevel@tonic-gate
7167c478bd9Sstevel@tonic-gate /*
7177c478bd9Sstevel@tonic-gate * delete a svc_pollfd entry; it shrinks the memory
7187c478bd9Sstevel@tonic-gate * use remove_pollfd if you do not want to shrink
7197c478bd9Sstevel@tonic-gate */
7207c478bd9Sstevel@tonic-gate static void
delete_pollfd(int fd)7217c478bd9Sstevel@tonic-gate delete_pollfd(int fd)
7227c478bd9Sstevel@tonic-gate {
7237c478bd9Sstevel@tonic-gate remove_pollfd(fd);
7247c478bd9Sstevel@tonic-gate if (pollfd_shrinking && svc_max_pollfd <
72529d91154SMarcel Telka (svc_pollfd_allocd - POLLFD_SHRINK)) {
7267c478bd9Sstevel@tonic-gate do {
7277c478bd9Sstevel@tonic-gate svc_pollfd_allocd -= POLLFD_SHRINK;
7287c478bd9Sstevel@tonic-gate } while (svc_max_pollfd < (svc_pollfd_allocd - POLLFD_SHRINK));
7297c478bd9Sstevel@tonic-gate svc_pollfd = realloc(svc_pollfd,
73029d91154SMarcel Telka sizeof (pollfd_t) * svc_pollfd_allocd);
7317c478bd9Sstevel@tonic-gate if (svc_pollfd == NULL) {
7327c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "delete_pollfd: out of memory");
7337c478bd9Sstevel@tonic-gate _exit(1);
7347c478bd9Sstevel@tonic-gate }
7357c478bd9Sstevel@tonic-gate }
7367c478bd9Sstevel@tonic-gate }
7377c478bd9Sstevel@tonic-gate
7387c478bd9Sstevel@tonic-gate
7397c478bd9Sstevel@tonic-gate /*
7407c478bd9Sstevel@tonic-gate * Activate a transport handle.
7417c478bd9Sstevel@tonic-gate */
7427c478bd9Sstevel@tonic-gate void
xprt_register(const SVCXPRT * xprt)74361961e0fSrobinson xprt_register(const SVCXPRT *xprt)
7447c478bd9Sstevel@tonic-gate {
7457c478bd9Sstevel@tonic-gate int fd = xprt->xp_fd;
7467c478bd9Sstevel@tonic-gate #ifdef CALLBACK
7477c478bd9Sstevel@tonic-gate extern void (*_svc_getreqset_proc)();
7487c478bd9Sstevel@tonic-gate #endif
7497c478bd9Sstevel@tonic-gate /* VARIABLES PROTECTED BY svc_fd_lock: svc_xports, svc_fdset */
7507c478bd9Sstevel@tonic-gate
75161961e0fSrobinson (void) rw_wrlock(&svc_fd_lock);
7527c478bd9Sstevel@tonic-gate if (svc_xports == NULL) {
7537c478bd9Sstevel@tonic-gate /* allocate some small amount first */
7547c478bd9Sstevel@tonic-gate svc_xports = calloc(FD_INCREMENT, sizeof (SVCXPRT *));
7557c478bd9Sstevel@tonic-gate if (svc_xports == NULL) {
7567c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "xprt_register: out of memory");
7577c478bd9Sstevel@tonic-gate _exit(1);
7587c478bd9Sstevel@tonic-gate }
7597c478bd9Sstevel@tonic-gate nsvc_xports = FD_INCREMENT;
7607c478bd9Sstevel@tonic-gate
7617c478bd9Sstevel@tonic-gate #ifdef CALLBACK
7627c478bd9Sstevel@tonic-gate /*
7637c478bd9Sstevel@tonic-gate * XXX: This code does not keep track of the server state.
7647c478bd9Sstevel@tonic-gate *
7657c478bd9Sstevel@tonic-gate * This provides for callback support. When a client
7667c478bd9Sstevel@tonic-gate * recv's a call from another client on the server fd's,
7677c478bd9Sstevel@tonic-gate * it calls _svc_getreqset_proc() which would return
7687c478bd9Sstevel@tonic-gate * after serving all the server requests. Also look under
7697c478bd9Sstevel@tonic-gate * clnt_dg.c and clnt_vc.c (clnt_call part of it)
7707c478bd9Sstevel@tonic-gate */
7717c478bd9Sstevel@tonic-gate _svc_getreqset_proc = svc_getreq_poll;
7727c478bd9Sstevel@tonic-gate #endif
7737c478bd9Sstevel@tonic-gate }
7747c478bd9Sstevel@tonic-gate
7757c478bd9Sstevel@tonic-gate while (fd >= nsvc_xports) {
7767c478bd9Sstevel@tonic-gate SVCXPRT **tmp_xprts = svc_xports;
7777c478bd9Sstevel@tonic-gate
7787c478bd9Sstevel@tonic-gate /* time to expand svc_xprts */
7797c478bd9Sstevel@tonic-gate tmp_xprts = realloc(svc_xports,
78029d91154SMarcel Telka sizeof (SVCXPRT *) * (nsvc_xports + FD_INCREMENT));
7817c478bd9Sstevel@tonic-gate if (tmp_xprts == NULL) {
7827c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "xprt_register : out of memory.");
7837c478bd9Sstevel@tonic-gate _exit(1);
7847c478bd9Sstevel@tonic-gate }
7857c478bd9Sstevel@tonic-gate
7867c478bd9Sstevel@tonic-gate svc_xports = tmp_xprts;
7877c478bd9Sstevel@tonic-gate (void) memset(&svc_xports[nsvc_xports], 0,
78829d91154SMarcel Telka sizeof (SVCXPRT *) * FD_INCREMENT);
7897c478bd9Sstevel@tonic-gate nsvc_xports += FD_INCREMENT;
7907c478bd9Sstevel@tonic-gate }
7917c478bd9Sstevel@tonic-gate
7927c478bd9Sstevel@tonic-gate svc_xports[fd] = (SVCXPRT *)xprt;
7937c478bd9Sstevel@tonic-gate
7947c478bd9Sstevel@tonic-gate add_pollfd(fd, MASKVAL);
7957c478bd9Sstevel@tonic-gate
7967c478bd9Sstevel@tonic-gate if (svc_polling) {
7977c478bd9Sstevel@tonic-gate char dummy;
7987c478bd9Sstevel@tonic-gate
7997c478bd9Sstevel@tonic-gate /*
8007c478bd9Sstevel@tonic-gate * This happens only in one of the MT modes.
8017c478bd9Sstevel@tonic-gate * Wake up poller.
8027c478bd9Sstevel@tonic-gate */
80361961e0fSrobinson (void) write(svc_pipe[1], &dummy, sizeof (dummy));
8047c478bd9Sstevel@tonic-gate }
8057c478bd9Sstevel@tonic-gate /*
8067c478bd9Sstevel@tonic-gate * If already dispatching door based services, start
8077c478bd9Sstevel@tonic-gate * dispatching TLI based services now.
8087c478bd9Sstevel@tonic-gate */
80961961e0fSrobinson (void) mutex_lock(&svc_door_mutex);
8107c478bd9Sstevel@tonic-gate if (svc_ndoorfds > 0)
81161961e0fSrobinson (void) cond_signal(&svc_door_waitcv);
81261961e0fSrobinson (void) mutex_unlock(&svc_door_mutex);
8137c478bd9Sstevel@tonic-gate
8147c478bd9Sstevel@tonic-gate if (svc_xdrs == NULL) {
8157c478bd9Sstevel@tonic-gate /* allocate initial chunk */
8167c478bd9Sstevel@tonic-gate svc_xdrs = calloc(FD_INCREMENT, sizeof (XDR *));
8177c478bd9Sstevel@tonic-gate if (svc_xdrs != NULL)
8187c478bd9Sstevel@tonic-gate nsvc_xdrs = FD_INCREMENT;
8197c478bd9Sstevel@tonic-gate else {
8207c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "xprt_register : out of memory.");
8217c478bd9Sstevel@tonic-gate _exit(1);
8227c478bd9Sstevel@tonic-gate }
8237c478bd9Sstevel@tonic-gate }
82461961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
8257c478bd9Sstevel@tonic-gate }
8267c478bd9Sstevel@tonic-gate
8277c478bd9Sstevel@tonic-gate /*
8287c478bd9Sstevel@tonic-gate * De-activate a transport handle.
8297c478bd9Sstevel@tonic-gate */
8307c478bd9Sstevel@tonic-gate void
__xprt_unregister_private(const SVCXPRT * xprt,bool_t lock_not_held)8317c478bd9Sstevel@tonic-gate __xprt_unregister_private(const SVCXPRT *xprt, bool_t lock_not_held)
8327c478bd9Sstevel@tonic-gate {
8337c478bd9Sstevel@tonic-gate int fd = xprt->xp_fd;
8347c478bd9Sstevel@tonic-gate
8357c478bd9Sstevel@tonic-gate if (lock_not_held)
83661961e0fSrobinson (void) rw_wrlock(&svc_fd_lock);
8377c478bd9Sstevel@tonic-gate if ((fd < nsvc_xports) && (svc_xports[fd] == xprt)) {
83861961e0fSrobinson svc_xports[fd] = NULL;
8397c478bd9Sstevel@tonic-gate delete_pollfd(fd);
8407c478bd9Sstevel@tonic-gate }
8417c478bd9Sstevel@tonic-gate if (lock_not_held)
84261961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
8437c478bd9Sstevel@tonic-gate __svc_rm_from_xlist(&_svc_xprtlist, xprt, &xprtlist_lock);
8447c478bd9Sstevel@tonic-gate }
8457c478bd9Sstevel@tonic-gate
8467c478bd9Sstevel@tonic-gate void
xprt_unregister(const SVCXPRT * xprt)84761961e0fSrobinson xprt_unregister(const SVCXPRT *xprt)
8487c478bd9Sstevel@tonic-gate {
8497c478bd9Sstevel@tonic-gate __xprt_unregister_private(xprt, TRUE);
8507c478bd9Sstevel@tonic-gate }
8517c478bd9Sstevel@tonic-gate
8527c478bd9Sstevel@tonic-gate /* ********************** CALLOUT list related stuff ************* */
8537c478bd9Sstevel@tonic-gate
8547c478bd9Sstevel@tonic-gate /*
8557c478bd9Sstevel@tonic-gate * Add a service program to the callout list.
8567c478bd9Sstevel@tonic-gate * The dispatch routine will be called when a rpc request for this
8577c478bd9Sstevel@tonic-gate * program number comes in.
8587c478bd9Sstevel@tonic-gate */
8597c478bd9Sstevel@tonic-gate bool_t
svc_reg(const SVCXPRT * xprt,const rpcprog_t prog,const rpcvers_t vers,void (* dispatch)(),const struct netconfig * nconf)86061961e0fSrobinson svc_reg(const SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers,
8612209d3c8SRichard Lowe void (*dispatch)(), const struct netconfig *nconf)
8627c478bd9Sstevel@tonic-gate {
8637c478bd9Sstevel@tonic-gate struct svc_callout *prev;
8647c478bd9Sstevel@tonic-gate struct svc_callout *s, **s2;
8657c478bd9Sstevel@tonic-gate struct netconfig *tnconf;
8667c478bd9Sstevel@tonic-gate char *netid = NULL;
8677c478bd9Sstevel@tonic-gate int flag = 0;
8687c478bd9Sstevel@tonic-gate
8697c478bd9Sstevel@tonic-gate /* VARIABLES PROTECTED BY svc_lock: s, prev, svc_head */
8707c478bd9Sstevel@tonic-gate
8717c478bd9Sstevel@tonic-gate if (xprt->xp_netid) {
8727c478bd9Sstevel@tonic-gate netid = strdup(xprt->xp_netid);
8737c478bd9Sstevel@tonic-gate flag = 1;
8747c478bd9Sstevel@tonic-gate } else if (nconf && nconf->nc_netid) {
8757c478bd9Sstevel@tonic-gate netid = strdup(nconf->nc_netid);
8767c478bd9Sstevel@tonic-gate flag = 1;
8777c478bd9Sstevel@tonic-gate } else if ((tnconf = __rpcfd_to_nconf(xprt->xp_fd, xprt->xp_type))
87829d91154SMarcel Telka != NULL) {
8797c478bd9Sstevel@tonic-gate netid = strdup(tnconf->nc_netid);
8807c478bd9Sstevel@tonic-gate flag = 1;
8817c478bd9Sstevel@tonic-gate freenetconfigent(tnconf);
8827c478bd9Sstevel@tonic-gate } /* must have been created with svc_raw_create */
88361961e0fSrobinson if ((netid == NULL) && (flag == 1))
8847c478bd9Sstevel@tonic-gate return (FALSE);
8857c478bd9Sstevel@tonic-gate
88661961e0fSrobinson (void) rw_wrlock(&svc_lock);
8877c478bd9Sstevel@tonic-gate if ((s = svc_find(prog, vers, &prev, netid)) != NULL_SVC) {
8887c478bd9Sstevel@tonic-gate if (netid)
8897c478bd9Sstevel@tonic-gate free(netid);
8907c478bd9Sstevel@tonic-gate if (s->sc_dispatch == dispatch)
89148bbca81SDaniel Hoffman goto rpcb_it; /* it is registering another xptr */
89261961e0fSrobinson (void) rw_unlock(&svc_lock);
8937c478bd9Sstevel@tonic-gate return (FALSE);
8947c478bd9Sstevel@tonic-gate }
89561961e0fSrobinson s = malloc(sizeof (struct svc_callout));
89661961e0fSrobinson if (s == NULL) {
8977c478bd9Sstevel@tonic-gate if (netid)
8987c478bd9Sstevel@tonic-gate free(netid);
89961961e0fSrobinson (void) rw_unlock(&svc_lock);
9007c478bd9Sstevel@tonic-gate return (FALSE);
9017c478bd9Sstevel@tonic-gate }
9027c478bd9Sstevel@tonic-gate
9037c478bd9Sstevel@tonic-gate s->sc_prog = prog;
9047c478bd9Sstevel@tonic-gate s->sc_vers = vers;
9057c478bd9Sstevel@tonic-gate s->sc_dispatch = dispatch;
9067c478bd9Sstevel@tonic-gate s->sc_netid = netid;
9077c478bd9Sstevel@tonic-gate s->sc_next = NULL;
9087c478bd9Sstevel@tonic-gate
9097c478bd9Sstevel@tonic-gate /*
9107c478bd9Sstevel@tonic-gate * The ordering of transports is such that the most frequently used
9117c478bd9Sstevel@tonic-gate * one appears first. So add the new entry to the end of the list.
9127c478bd9Sstevel@tonic-gate */
9137c478bd9Sstevel@tonic-gate for (s2 = &svc_head; *s2 != NULL; s2 = &(*s2)->sc_next)
9147c478bd9Sstevel@tonic-gate ;
9157c478bd9Sstevel@tonic-gate *s2 = s;
9167c478bd9Sstevel@tonic-gate
9177c478bd9Sstevel@tonic-gate if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
9187c478bd9Sstevel@tonic-gate if ((((SVCXPRT *)xprt)->xp_netid = strdup(netid)) == NULL) {
9197c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "svc_reg : strdup failed.");
9207c478bd9Sstevel@tonic-gate free(netid);
92161961e0fSrobinson free(s);
9227c478bd9Sstevel@tonic-gate *s2 = NULL;
92361961e0fSrobinson (void) rw_unlock(&svc_lock);
9247c478bd9Sstevel@tonic-gate return (FALSE);
9257c478bd9Sstevel@tonic-gate }
9267c478bd9Sstevel@tonic-gate
9277c478bd9Sstevel@tonic-gate rpcb_it:
92861961e0fSrobinson (void) rw_unlock(&svc_lock);
9299acbbeafSnn
9307c478bd9Sstevel@tonic-gate /* now register the information with the local binder service */
9319ff75adeSSurya Prakki if (nconf)
93261961e0fSrobinson return (rpcb_set(prog, vers, nconf, &xprt->xp_ltaddr));
9339ff75adeSSurya Prakki return (TRUE);
9349acbbeafSnn /*NOTREACHED*/
9357c478bd9Sstevel@tonic-gate }
9367c478bd9Sstevel@tonic-gate
9377c478bd9Sstevel@tonic-gate /*
9387c478bd9Sstevel@tonic-gate * Remove a service program from the callout list.
9397c478bd9Sstevel@tonic-gate */
9407c478bd9Sstevel@tonic-gate void
svc_unreg(const rpcprog_t prog,const rpcvers_t vers)94161961e0fSrobinson svc_unreg(const rpcprog_t prog, const rpcvers_t vers)
9427c478bd9Sstevel@tonic-gate {
9437c478bd9Sstevel@tonic-gate struct svc_callout *prev;
9447c478bd9Sstevel@tonic-gate struct svc_callout *s;
9457c478bd9Sstevel@tonic-gate
9467c478bd9Sstevel@tonic-gate /* unregister the information anyway */
9479ff75adeSSurya Prakki (void) rpcb_unset(prog, vers, NULL);
9489ff75adeSSurya Prakki
94961961e0fSrobinson (void) rw_wrlock(&svc_lock);
9507c478bd9Sstevel@tonic-gate while ((s = svc_find(prog, vers, &prev, NULL)) != NULL_SVC) {
9517c478bd9Sstevel@tonic-gate if (prev == NULL_SVC) {
9527c478bd9Sstevel@tonic-gate svc_head = s->sc_next;
9537c478bd9Sstevel@tonic-gate } else {
9547c478bd9Sstevel@tonic-gate prev->sc_next = s->sc_next;
9557c478bd9Sstevel@tonic-gate }
9567c478bd9Sstevel@tonic-gate s->sc_next = NULL_SVC;
9577c478bd9Sstevel@tonic-gate if (s->sc_netid)
95861961e0fSrobinson free(s->sc_netid);
95961961e0fSrobinson free(s);
9607c478bd9Sstevel@tonic-gate }
96161961e0fSrobinson (void) rw_unlock(&svc_lock);
9627c478bd9Sstevel@tonic-gate }
9637c478bd9Sstevel@tonic-gate
9647c478bd9Sstevel@tonic-gate #ifdef PORTMAP
9657c478bd9Sstevel@tonic-gate /*
9667c478bd9Sstevel@tonic-gate * Add a service program to the callout list.
9677c478bd9Sstevel@tonic-gate * The dispatch routine will be called when a rpc request for this
9687c478bd9Sstevel@tonic-gate * program number comes in.
9697c478bd9Sstevel@tonic-gate * For version 2 portmappers.
9707c478bd9Sstevel@tonic-gate */
9717c478bd9Sstevel@tonic-gate bool_t
svc_register(SVCXPRT * xprt,rpcprog_t prog,rpcvers_t vers,void (* dispatch)(),int protocol)97261961e0fSrobinson svc_register(SVCXPRT *xprt, rpcprog_t prog, rpcvers_t vers,
9732209d3c8SRichard Lowe void (*dispatch)(), int protocol)
9747c478bd9Sstevel@tonic-gate {
9757c478bd9Sstevel@tonic-gate struct svc_callout *prev;
9767c478bd9Sstevel@tonic-gate struct svc_callout *s;
9777c478bd9Sstevel@tonic-gate struct netconfig *nconf;
9787c478bd9Sstevel@tonic-gate char *netid = NULL;
9797c478bd9Sstevel@tonic-gate int flag = 0;
9807c478bd9Sstevel@tonic-gate
9817c478bd9Sstevel@tonic-gate if (xprt->xp_netid) {
9827c478bd9Sstevel@tonic-gate netid = strdup(xprt->xp_netid);
9837c478bd9Sstevel@tonic-gate flag = 1;
9847c478bd9Sstevel@tonic-gate } else if ((ioctl(xprt->xp_fd, I_FIND, "timod") > 0) && ((nconf =
98529d91154SMarcel Telka __rpcfd_to_nconf(xprt->xp_fd, xprt->xp_type)) != NULL)) {
9867c478bd9Sstevel@tonic-gate /* fill in missing netid field in SVCXPRT */
9877c478bd9Sstevel@tonic-gate netid = strdup(nconf->nc_netid);
9887c478bd9Sstevel@tonic-gate flag = 1;
9897c478bd9Sstevel@tonic-gate freenetconfigent(nconf);
9907c478bd9Sstevel@tonic-gate } /* must be svc_raw_create */
9917c478bd9Sstevel@tonic-gate
99261961e0fSrobinson if ((netid == NULL) && (flag == 1))
9937c478bd9Sstevel@tonic-gate return (FALSE);
9947c478bd9Sstevel@tonic-gate
99561961e0fSrobinson (void) rw_wrlock(&svc_lock);
9967c478bd9Sstevel@tonic-gate if ((s = svc_find(prog, vers, &prev, netid)) != NULL_SVC) {
9977c478bd9Sstevel@tonic-gate if (netid)
9987c478bd9Sstevel@tonic-gate free(netid);
9997c478bd9Sstevel@tonic-gate if (s->sc_dispatch == dispatch)
100048bbca81SDaniel Hoffman goto pmap_it; /* it is registering another xptr */
100161961e0fSrobinson (void) rw_unlock(&svc_lock);
10027c478bd9Sstevel@tonic-gate return (FALSE);
10037c478bd9Sstevel@tonic-gate }
100461961e0fSrobinson s = malloc(sizeof (struct svc_callout));
10057c478bd9Sstevel@tonic-gate if (s == (struct svc_callout *)0) {
10067c478bd9Sstevel@tonic-gate if (netid)
10077c478bd9Sstevel@tonic-gate free(netid);
100861961e0fSrobinson (void) rw_unlock(&svc_lock);
10097c478bd9Sstevel@tonic-gate return (FALSE);
10107c478bd9Sstevel@tonic-gate }
10117c478bd9Sstevel@tonic-gate s->sc_prog = prog;
10127c478bd9Sstevel@tonic-gate s->sc_vers = vers;
10137c478bd9Sstevel@tonic-gate s->sc_dispatch = dispatch;
10147c478bd9Sstevel@tonic-gate s->sc_netid = netid;
10157c478bd9Sstevel@tonic-gate s->sc_next = svc_head;
10167c478bd9Sstevel@tonic-gate svc_head = s;
10177c478bd9Sstevel@tonic-gate
10187c478bd9Sstevel@tonic-gate if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
10197c478bd9Sstevel@tonic-gate if ((xprt->xp_netid = strdup(netid)) == NULL) {
10207c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "svc_register : strdup failed.");
10217c478bd9Sstevel@tonic-gate free(netid);
10227c478bd9Sstevel@tonic-gate svc_head = s->sc_next;
102361961e0fSrobinson free(s);
102461961e0fSrobinson (void) rw_unlock(&svc_lock);
10257c478bd9Sstevel@tonic-gate return (FALSE);
10267c478bd9Sstevel@tonic-gate }
10277c478bd9Sstevel@tonic-gate
10287c478bd9Sstevel@tonic-gate pmap_it:
102961961e0fSrobinson (void) rw_unlock(&svc_lock);
10307c478bd9Sstevel@tonic-gate /* now register the information with the local binder service */
103161961e0fSrobinson if (protocol)
103261961e0fSrobinson return (pmap_set(prog, vers, protocol, xprt->xp_port));
10337c478bd9Sstevel@tonic-gate return (TRUE);
10347c478bd9Sstevel@tonic-gate }
10357c478bd9Sstevel@tonic-gate
10367c478bd9Sstevel@tonic-gate /*
10377c478bd9Sstevel@tonic-gate * Remove a service program from the callout list.
10387c478bd9Sstevel@tonic-gate * For version 2 portmappers.
10397c478bd9Sstevel@tonic-gate */
10407c478bd9Sstevel@tonic-gate void
svc_unregister(rpcprog_t prog,rpcvers_t vers)104161961e0fSrobinson svc_unregister(rpcprog_t prog, rpcvers_t vers)
10427c478bd9Sstevel@tonic-gate {
10437c478bd9Sstevel@tonic-gate struct svc_callout *prev;
10447c478bd9Sstevel@tonic-gate struct svc_callout *s;
10457c478bd9Sstevel@tonic-gate
104661961e0fSrobinson (void) rw_wrlock(&svc_lock);
10477c478bd9Sstevel@tonic-gate while ((s = svc_find(prog, vers, &prev, NULL)) != NULL_SVC) {
10487c478bd9Sstevel@tonic-gate if (prev == NULL_SVC) {
10497c478bd9Sstevel@tonic-gate svc_head = s->sc_next;
10507c478bd9Sstevel@tonic-gate } else {
10517c478bd9Sstevel@tonic-gate prev->sc_next = s->sc_next;
10527c478bd9Sstevel@tonic-gate }
10537c478bd9Sstevel@tonic-gate s->sc_next = NULL_SVC;
10547c478bd9Sstevel@tonic-gate if (s->sc_netid)
105561961e0fSrobinson free(s->sc_netid);
105661961e0fSrobinson free(s);
10577c478bd9Sstevel@tonic-gate /* unregister the information with the local binder service */
10587c478bd9Sstevel@tonic-gate (void) pmap_unset(prog, vers);
10597c478bd9Sstevel@tonic-gate }
106061961e0fSrobinson (void) rw_unlock(&svc_lock);
10617c478bd9Sstevel@tonic-gate }
10627c478bd9Sstevel@tonic-gate #endif /* PORTMAP */
106361961e0fSrobinson
10647c478bd9Sstevel@tonic-gate /*
10657c478bd9Sstevel@tonic-gate * Search the callout list for a program number, return the callout
10667c478bd9Sstevel@tonic-gate * struct.
10677c478bd9Sstevel@tonic-gate * Also check for transport as well. Many routines such as svc_unreg
10687c478bd9Sstevel@tonic-gate * dont give any corresponding transport, so dont check for transport if
10697c478bd9Sstevel@tonic-gate * netid == NULL
10707c478bd9Sstevel@tonic-gate */
10717c478bd9Sstevel@tonic-gate static struct svc_callout *
svc_find(rpcprog_t prog,rpcvers_t vers,struct svc_callout ** prev,char * netid)107261961e0fSrobinson svc_find(rpcprog_t prog, rpcvers_t vers, struct svc_callout **prev, char *netid)
10737c478bd9Sstevel@tonic-gate {
10747c478bd9Sstevel@tonic-gate struct svc_callout *s, *p;
10757c478bd9Sstevel@tonic-gate
10767c478bd9Sstevel@tonic-gate /* WRITE LOCK HELD ON ENTRY: svc_lock */
10777c478bd9Sstevel@tonic-gate
10787c478bd9Sstevel@tonic-gate /* assert(RW_WRITE_HELD(&svc_lock)); */
10797c478bd9Sstevel@tonic-gate p = NULL_SVC;
10807c478bd9Sstevel@tonic-gate for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
10817c478bd9Sstevel@tonic-gate if (((s->sc_prog == prog) && (s->sc_vers == vers)) &&
108229d91154SMarcel Telka ((netid == NULL) || (s->sc_netid == NULL) ||
108329d91154SMarcel Telka (strcmp(netid, s->sc_netid) == 0)))
108429d91154SMarcel Telka break;
10857c478bd9Sstevel@tonic-gate p = s;
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate *prev = p;
10887c478bd9Sstevel@tonic-gate return (s);
10897c478bd9Sstevel@tonic-gate }
10907c478bd9Sstevel@tonic-gate
10917c478bd9Sstevel@tonic-gate
10927c478bd9Sstevel@tonic-gate /* ******************* REPLY GENERATION ROUTINES ************ */
10937c478bd9Sstevel@tonic-gate
10947c478bd9Sstevel@tonic-gate /*
10957c478bd9Sstevel@tonic-gate * Send a reply to an rpc request
10967c478bd9Sstevel@tonic-gate */
10977c478bd9Sstevel@tonic-gate bool_t
svc_sendreply(const SVCXPRT * xprt,const xdrproc_t xdr_results,const caddr_t xdr_location)109861961e0fSrobinson svc_sendreply(const SVCXPRT *xprt, const xdrproc_t xdr_results,
10992209d3c8SRichard Lowe const caddr_t xdr_location)
11007c478bd9Sstevel@tonic-gate {
11017c478bd9Sstevel@tonic-gate struct rpc_msg rply;
11027c478bd9Sstevel@tonic-gate
11037c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
11047c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
11057c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
11067c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = SUCCESS;
11077c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_results.where = xdr_location;
11087c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_results.proc = xdr_results;
110961961e0fSrobinson return (SVC_REPLY((SVCXPRT *)xprt, &rply));
11107c478bd9Sstevel@tonic-gate }
11117c478bd9Sstevel@tonic-gate
11127c478bd9Sstevel@tonic-gate /*
11137c478bd9Sstevel@tonic-gate * No procedure error reply
11147c478bd9Sstevel@tonic-gate */
11157c478bd9Sstevel@tonic-gate void
svcerr_noproc(const SVCXPRT * xprt)111661961e0fSrobinson svcerr_noproc(const SVCXPRT *xprt)
11177c478bd9Sstevel@tonic-gate {
11187c478bd9Sstevel@tonic-gate struct rpc_msg rply;
11197c478bd9Sstevel@tonic-gate
11207c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
11217c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
11227c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
11237c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = PROC_UNAVAIL;
11247c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
11257c478bd9Sstevel@tonic-gate }
11267c478bd9Sstevel@tonic-gate
11277c478bd9Sstevel@tonic-gate /*
11287c478bd9Sstevel@tonic-gate * Can't decode args error reply
11297c478bd9Sstevel@tonic-gate */
11307c478bd9Sstevel@tonic-gate void
svcerr_decode(const SVCXPRT * xprt)113161961e0fSrobinson svcerr_decode(const SVCXPRT *xprt)
11327c478bd9Sstevel@tonic-gate {
11337c478bd9Sstevel@tonic-gate struct rpc_msg rply;
11347c478bd9Sstevel@tonic-gate
11357c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
11367c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
11377c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
11387c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = GARBAGE_ARGS;
11397c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
11407c478bd9Sstevel@tonic-gate }
11417c478bd9Sstevel@tonic-gate
11427c478bd9Sstevel@tonic-gate /*
11437c478bd9Sstevel@tonic-gate * Some system error
11447c478bd9Sstevel@tonic-gate */
11457c478bd9Sstevel@tonic-gate void
svcerr_systemerr(const SVCXPRT * xprt)114661961e0fSrobinson svcerr_systemerr(const SVCXPRT *xprt)
11477c478bd9Sstevel@tonic-gate {
11487c478bd9Sstevel@tonic-gate struct rpc_msg rply;
11497c478bd9Sstevel@tonic-gate
11507c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
11517c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
11527c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
11537c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = SYSTEM_ERR;
11547c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
11557c478bd9Sstevel@tonic-gate }
11567c478bd9Sstevel@tonic-gate
11577c478bd9Sstevel@tonic-gate /*
11587c478bd9Sstevel@tonic-gate * Tell RPC package to not complain about version errors to the client. This
11597c478bd9Sstevel@tonic-gate * is useful when revving broadcast protocols that sit on a fixed address.
11607c478bd9Sstevel@tonic-gate * There is really one (or should be only one) example of this kind of
11617c478bd9Sstevel@tonic-gate * protocol: the portmapper (or rpc binder).
11627c478bd9Sstevel@tonic-gate */
11637c478bd9Sstevel@tonic-gate void
__svc_versquiet_on(const SVCXPRT * xprt)116461961e0fSrobinson __svc_versquiet_on(const SVCXPRT *xprt)
11657c478bd9Sstevel@tonic-gate {
11667c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
11677c478bd9Sstevel@tonic-gate svc_flags(xprt) |= SVC_VERSQUIET;
11687c478bd9Sstevel@tonic-gate }
11697c478bd9Sstevel@tonic-gate
11707c478bd9Sstevel@tonic-gate void
__svc_versquiet_off(const SVCXPRT * xprt)117161961e0fSrobinson __svc_versquiet_off(const SVCXPRT *xprt)
11727c478bd9Sstevel@tonic-gate {
11737c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
11747c478bd9Sstevel@tonic-gate svc_flags(xprt) &= ~SVC_VERSQUIET;
11757c478bd9Sstevel@tonic-gate }
11767c478bd9Sstevel@tonic-gate
11777c478bd9Sstevel@tonic-gate void
svc_versquiet(const SVCXPRT * xprt)117861961e0fSrobinson svc_versquiet(const SVCXPRT *xprt)
11797c478bd9Sstevel@tonic-gate {
11807c478bd9Sstevel@tonic-gate __svc_versquiet_on(xprt);
11817c478bd9Sstevel@tonic-gate }
11827c478bd9Sstevel@tonic-gate
11837c478bd9Sstevel@tonic-gate int
__svc_versquiet_get(const SVCXPRT * xprt)118461961e0fSrobinson __svc_versquiet_get(const SVCXPRT *xprt)
11857c478bd9Sstevel@tonic-gate {
11867c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
11877c478bd9Sstevel@tonic-gate return (svc_flags(xprt) & SVC_VERSQUIET);
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate
11907c478bd9Sstevel@tonic-gate /*
11917c478bd9Sstevel@tonic-gate * Authentication error reply
11927c478bd9Sstevel@tonic-gate */
11937c478bd9Sstevel@tonic-gate void
svcerr_auth(const SVCXPRT * xprt,const enum auth_stat why)119461961e0fSrobinson svcerr_auth(const SVCXPRT *xprt, const enum auth_stat why)
11957c478bd9Sstevel@tonic-gate {
11967c478bd9Sstevel@tonic-gate struct rpc_msg rply;
11977c478bd9Sstevel@tonic-gate
11987c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
11997c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_DENIED;
12007c478bd9Sstevel@tonic-gate rply.rjcted_rply.rj_stat = AUTH_ERROR;
12017c478bd9Sstevel@tonic-gate rply.rjcted_rply.rj_why = why;
12027c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
12037c478bd9Sstevel@tonic-gate }
12047c478bd9Sstevel@tonic-gate
12057c478bd9Sstevel@tonic-gate /*
12067c478bd9Sstevel@tonic-gate * Auth too weak error reply
12077c478bd9Sstevel@tonic-gate */
12087c478bd9Sstevel@tonic-gate void
svcerr_weakauth(const SVCXPRT * xprt)120961961e0fSrobinson svcerr_weakauth(const SVCXPRT *xprt)
12107c478bd9Sstevel@tonic-gate {
12117c478bd9Sstevel@tonic-gate svcerr_auth(xprt, AUTH_TOOWEAK);
12127c478bd9Sstevel@tonic-gate }
12137c478bd9Sstevel@tonic-gate
12147c478bd9Sstevel@tonic-gate /*
12157c478bd9Sstevel@tonic-gate * Program unavailable error reply
12167c478bd9Sstevel@tonic-gate */
12177c478bd9Sstevel@tonic-gate void
svcerr_noprog(const SVCXPRT * xprt)121861961e0fSrobinson svcerr_noprog(const SVCXPRT *xprt)
12197c478bd9Sstevel@tonic-gate {
12207c478bd9Sstevel@tonic-gate struct rpc_msg rply;
12217c478bd9Sstevel@tonic-gate
12227c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
12237c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
12247c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
12257c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = PROG_UNAVAIL;
12267c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
12277c478bd9Sstevel@tonic-gate }
12287c478bd9Sstevel@tonic-gate
12297c478bd9Sstevel@tonic-gate /*
12307c478bd9Sstevel@tonic-gate * Program version mismatch error reply
12317c478bd9Sstevel@tonic-gate */
12327c478bd9Sstevel@tonic-gate void
svcerr_progvers(const SVCXPRT * xprt,const rpcvers_t low_vers,const rpcvers_t high_vers)123361961e0fSrobinson svcerr_progvers(const SVCXPRT *xprt, const rpcvers_t low_vers,
12342209d3c8SRichard Lowe const rpcvers_t high_vers)
12357c478bd9Sstevel@tonic-gate {
12367c478bd9Sstevel@tonic-gate struct rpc_msg rply;
12377c478bd9Sstevel@tonic-gate
12387c478bd9Sstevel@tonic-gate rply.rm_direction = REPLY;
12397c478bd9Sstevel@tonic-gate rply.rm_reply.rp_stat = MSG_ACCEPTED;
12407c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_verf = xprt->xp_verf;
12417c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_stat = PROG_MISMATCH;
12427c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_vers.low = low_vers;
12437c478bd9Sstevel@tonic-gate rply.acpted_rply.ar_vers.high = high_vers;
12447c478bd9Sstevel@tonic-gate SVC_REPLY((SVCXPRT *)xprt, &rply);
12457c478bd9Sstevel@tonic-gate }
12467c478bd9Sstevel@tonic-gate
12477c478bd9Sstevel@tonic-gate /* ******************* SERVER INPUT STUFF ******************* */
12487c478bd9Sstevel@tonic-gate
12497c478bd9Sstevel@tonic-gate /*
12507c478bd9Sstevel@tonic-gate * Get server side input from some transport.
12517c478bd9Sstevel@tonic-gate *
12527c478bd9Sstevel@tonic-gate * Statement of authentication parameters management:
12537c478bd9Sstevel@tonic-gate * This function owns and manages all authentication parameters, specifically
12547c478bd9Sstevel@tonic-gate * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
12557c478bd9Sstevel@tonic-gate * the "cooked" credentials (rqst->rq_clntcred).
12567c478bd9Sstevel@tonic-gate * However, this function does not know the structure of the cooked
12577c478bd9Sstevel@tonic-gate * credentials, so it make the following assumptions:
12587c478bd9Sstevel@tonic-gate * a) the structure is contiguous (no pointers), and
12597c478bd9Sstevel@tonic-gate * b) the cred structure size does not exceed RQCRED_SIZE bytes.
12607c478bd9Sstevel@tonic-gate * In all events, all three parameters are freed upon exit from this routine.
12617c478bd9Sstevel@tonic-gate * The storage is trivially management on the call stack in user land, but
12627c478bd9Sstevel@tonic-gate * is mallocated in kernel land.
12637c478bd9Sstevel@tonic-gate */
12647c478bd9Sstevel@tonic-gate
12657c478bd9Sstevel@tonic-gate void
svc_getreq(int rdfds)126661961e0fSrobinson svc_getreq(int rdfds)
12677c478bd9Sstevel@tonic-gate {
12687c478bd9Sstevel@tonic-gate fd_set readfds;
12697c478bd9Sstevel@tonic-gate
12707c478bd9Sstevel@tonic-gate FD_ZERO(&readfds);
12717c478bd9Sstevel@tonic-gate readfds.fds_bits[0] = rdfds;
12727c478bd9Sstevel@tonic-gate svc_getreqset(&readfds);
12737c478bd9Sstevel@tonic-gate }
12747c478bd9Sstevel@tonic-gate
12757c478bd9Sstevel@tonic-gate void
svc_getreqset(fd_set * readfds)127661961e0fSrobinson svc_getreqset(fd_set *readfds)
12777c478bd9Sstevel@tonic-gate {
12787c478bd9Sstevel@tonic-gate int i;
12797c478bd9Sstevel@tonic-gate
12807c478bd9Sstevel@tonic-gate for (i = 0; i < svc_max_fd; i++) {
12817c478bd9Sstevel@tonic-gate /* fd has input waiting */
12827c478bd9Sstevel@tonic-gate if (FD_ISSET(i, readfds))
12837c478bd9Sstevel@tonic-gate svc_getreq_common(i);
12847c478bd9Sstevel@tonic-gate }
12857c478bd9Sstevel@tonic-gate }
12867c478bd9Sstevel@tonic-gate
12877c478bd9Sstevel@tonic-gate void
svc_getreq_poll(struct pollfd * pfdp,const int pollretval)128861961e0fSrobinson svc_getreq_poll(struct pollfd *pfdp, const int pollretval)
12897c478bd9Sstevel@tonic-gate {
12907c478bd9Sstevel@tonic-gate int i;
12917c478bd9Sstevel@tonic-gate int fds_found;
12927c478bd9Sstevel@tonic-gate
12937c478bd9Sstevel@tonic-gate for (i = fds_found = 0; fds_found < pollretval; i++) {
12947c478bd9Sstevel@tonic-gate struct pollfd *p = &pfdp[i];
12957c478bd9Sstevel@tonic-gate
12967c478bd9Sstevel@tonic-gate if (p->revents) {
12977c478bd9Sstevel@tonic-gate /* fd has input waiting */
12987c478bd9Sstevel@tonic-gate fds_found++;
12997c478bd9Sstevel@tonic-gate /*
13007c478bd9Sstevel@tonic-gate * We assume that this function is only called
13017c478bd9Sstevel@tonic-gate * via someone select()ing from svc_fdset or
13027c478bd9Sstevel@tonic-gate * poll()ing from svc_pollset[]. Thus it's safe
13037c478bd9Sstevel@tonic-gate * to handle the POLLNVAL event by simply turning
13047c478bd9Sstevel@tonic-gate * the corresponding bit off in svc_fdset. The
13057c478bd9Sstevel@tonic-gate * svc_pollset[] array is derived from svc_fdset
13067c478bd9Sstevel@tonic-gate * and so will also be updated eventually.
13077c478bd9Sstevel@tonic-gate *
13087c478bd9Sstevel@tonic-gate * XXX Should we do an xprt_unregister() instead?
13097c478bd9Sstevel@tonic-gate */
13107c478bd9Sstevel@tonic-gate /* Handle user callback */
13117c478bd9Sstevel@tonic-gate if (__is_a_userfd(p->fd) == TRUE) {
131261961e0fSrobinson (void) rw_rdlock(&svc_fd_lock);
13137c478bd9Sstevel@tonic-gate __svc_getreq_user(p);
131461961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13157c478bd9Sstevel@tonic-gate } else {
13167c478bd9Sstevel@tonic-gate if (p->revents & POLLNVAL) {
131761961e0fSrobinson (void) rw_wrlock(&svc_fd_lock);
13187c478bd9Sstevel@tonic-gate remove_pollfd(p->fd); /* XXX */
131961961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
132061961e0fSrobinson } else {
13217c478bd9Sstevel@tonic-gate svc_getreq_common(p->fd);
132261961e0fSrobinson }
13237c478bd9Sstevel@tonic-gate }
13247c478bd9Sstevel@tonic-gate }
13257c478bd9Sstevel@tonic-gate }
13267c478bd9Sstevel@tonic-gate }
13277c478bd9Sstevel@tonic-gate
13287c478bd9Sstevel@tonic-gate void
svc_getreq_common(const int fd)132961961e0fSrobinson svc_getreq_common(const int fd)
13307c478bd9Sstevel@tonic-gate {
13317c478bd9Sstevel@tonic-gate SVCXPRT *xprt;
13327c478bd9Sstevel@tonic-gate enum xprt_stat stat;
13337c478bd9Sstevel@tonic-gate struct rpc_msg *msg;
13347c478bd9Sstevel@tonic-gate struct svc_req *r;
13357c478bd9Sstevel@tonic-gate char *cred_area;
13367c478bd9Sstevel@tonic-gate
133761961e0fSrobinson (void) rw_rdlock(&svc_fd_lock);
13387c478bd9Sstevel@tonic-gate
13397c478bd9Sstevel@tonic-gate /* HANDLE USER CALLBACK */
13407c478bd9Sstevel@tonic-gate if (__is_a_userfd(fd) == TRUE) {
13417c478bd9Sstevel@tonic-gate struct pollfd virtual_fd;
13427c478bd9Sstevel@tonic-gate
13437c478bd9Sstevel@tonic-gate virtual_fd.events = virtual_fd.revents = (short)0xFFFF;
13447c478bd9Sstevel@tonic-gate virtual_fd.fd = fd;
13457c478bd9Sstevel@tonic-gate __svc_getreq_user(&virtual_fd);
134661961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13477c478bd9Sstevel@tonic-gate return;
13487c478bd9Sstevel@tonic-gate }
13497c478bd9Sstevel@tonic-gate
13507c478bd9Sstevel@tonic-gate /*
13517c478bd9Sstevel@tonic-gate * The transport associated with this fd could have been
13527c478bd9Sstevel@tonic-gate * removed from svc_timeout_nonblock_xprt_and_LRU, for instance.
13537c478bd9Sstevel@tonic-gate * This can happen if two or more fds get read events and are
13547c478bd9Sstevel@tonic-gate * passed to svc_getreq_poll/set, the first fd is seviced by
13557c478bd9Sstevel@tonic-gate * the dispatch routine and cleans up any dead transports. If
13567c478bd9Sstevel@tonic-gate * one of the dead transports removed is the other fd that
13577c478bd9Sstevel@tonic-gate * had a read event then svc_getreq_common() will be called with no
13587c478bd9Sstevel@tonic-gate * xprt associated with the fd that had the original read event.
13597c478bd9Sstevel@tonic-gate */
13607c478bd9Sstevel@tonic-gate if ((fd >= nsvc_xports) || (xprt = svc_xports[fd]) == NULL) {
136161961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13627c478bd9Sstevel@tonic-gate return;
13637c478bd9Sstevel@tonic-gate }
136461961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13657c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
13667c478bd9Sstevel@tonic-gate msg = SVCEXT(xprt)->msg;
13677c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
13687c478bd9Sstevel@tonic-gate r = SVCEXT(xprt)->req;
13697c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
13707c478bd9Sstevel@tonic-gate cred_area = SVCEXT(xprt)->cred_area;
13717c478bd9Sstevel@tonic-gate msg->rm_call.cb_cred.oa_base = cred_area;
13727c478bd9Sstevel@tonic-gate msg->rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
13737c478bd9Sstevel@tonic-gate r->rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);
13747c478bd9Sstevel@tonic-gate
13757c478bd9Sstevel@tonic-gate /* receive msgs from xprtprt (support batch calls) */
13767c478bd9Sstevel@tonic-gate do {
13777c478bd9Sstevel@tonic-gate bool_t dispatch;
13787c478bd9Sstevel@tonic-gate
13797c478bd9Sstevel@tonic-gate if (dispatch = SVC_RECV(xprt, msg))
13807c478bd9Sstevel@tonic-gate (void) _svc_prog_dispatch(xprt, msg, r);
13817c478bd9Sstevel@tonic-gate /*
13827c478bd9Sstevel@tonic-gate * Check if the xprt has been disconnected in a recursive call
13837c478bd9Sstevel@tonic-gate * in the service dispatch routine. If so, then break
13847c478bd9Sstevel@tonic-gate */
138561961e0fSrobinson (void) rw_rdlock(&svc_fd_lock);
13867c478bd9Sstevel@tonic-gate if (xprt != svc_xports[fd]) {
138761961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13887c478bd9Sstevel@tonic-gate break;
13897c478bd9Sstevel@tonic-gate }
139061961e0fSrobinson (void) rw_unlock(&svc_fd_lock);
13917c478bd9Sstevel@tonic-gate
13927c478bd9Sstevel@tonic-gate /*
13937c478bd9Sstevel@tonic-gate * Call cleanup procedure if set.
13947c478bd9Sstevel@tonic-gate */
13957c478bd9Sstevel@tonic-gate if (__proc_cleanup_cb != NULL && dispatch)
13967c478bd9Sstevel@tonic-gate (*__proc_cleanup_cb)(xprt);
13977c478bd9Sstevel@tonic-gate
13987c478bd9Sstevel@tonic-gate if ((stat = SVC_STAT(xprt)) == XPRT_DIED) {
13997c478bd9Sstevel@tonic-gate SVC_DESTROY(xprt);
14007c478bd9Sstevel@tonic-gate break;
14017c478bd9Sstevel@tonic-gate }
14027c478bd9Sstevel@tonic-gate } while (stat == XPRT_MOREREQS);
14037c478bd9Sstevel@tonic-gate }
14047c478bd9Sstevel@tonic-gate
14057c478bd9Sstevel@tonic-gate int
_svc_prog_dispatch(SVCXPRT * xprt,struct rpc_msg * msg,struct svc_req * r)140661961e0fSrobinson _svc_prog_dispatch(SVCXPRT *xprt, struct rpc_msg *msg, struct svc_req *r)
14077c478bd9Sstevel@tonic-gate {
14087c478bd9Sstevel@tonic-gate struct svc_callout *s;
14097c478bd9Sstevel@tonic-gate enum auth_stat why;
14107c478bd9Sstevel@tonic-gate int prog_found;
14117c478bd9Sstevel@tonic-gate rpcvers_t low_vers;
14127c478bd9Sstevel@tonic-gate rpcvers_t high_vers;
14137c478bd9Sstevel@tonic-gate void (*disp_fn)();
14147c478bd9Sstevel@tonic-gate
14157c478bd9Sstevel@tonic-gate r->rq_xprt = xprt;
14167c478bd9Sstevel@tonic-gate r->rq_prog = msg->rm_call.cb_prog;
14177c478bd9Sstevel@tonic-gate r->rq_vers = msg->rm_call.cb_vers;
14187c478bd9Sstevel@tonic-gate r->rq_proc = msg->rm_call.cb_proc;
14197c478bd9Sstevel@tonic-gate r->rq_cred = msg->rm_call.cb_cred;
14207c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
14217c478bd9Sstevel@tonic-gate SVC_XP_AUTH(r->rq_xprt).svc_ah_ops = svc_auth_any_ops;
14227c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
14237c478bd9Sstevel@tonic-gate SVC_XP_AUTH(r->rq_xprt).svc_ah_private = NULL;
14247c478bd9Sstevel@tonic-gate
14257c478bd9Sstevel@tonic-gate /* first authenticate the message */
14267c478bd9Sstevel@tonic-gate /* Check for null flavor and bypass these calls if possible */
14277c478bd9Sstevel@tonic-gate
14287c478bd9Sstevel@tonic-gate if (msg->rm_call.cb_cred.oa_flavor == AUTH_NULL) {
14297c478bd9Sstevel@tonic-gate r->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
14307c478bd9Sstevel@tonic-gate r->rq_xprt->xp_verf.oa_length = 0;
14317c478bd9Sstevel@tonic-gate } else {
14327c478bd9Sstevel@tonic-gate bool_t no_dispatch;
14337c478bd9Sstevel@tonic-gate
14347c478bd9Sstevel@tonic-gate if ((why = __gss_authenticate(r, msg,
143529d91154SMarcel Telka &no_dispatch)) != AUTH_OK) {
14367c478bd9Sstevel@tonic-gate svcerr_auth(xprt, why);
14377c478bd9Sstevel@tonic-gate return (0);
14387c478bd9Sstevel@tonic-gate }
14397c478bd9Sstevel@tonic-gate if (no_dispatch)
14407c478bd9Sstevel@tonic-gate return (0);
14417c478bd9Sstevel@tonic-gate }
14427c478bd9Sstevel@tonic-gate /* match message with a registered service */
14437c478bd9Sstevel@tonic-gate prog_found = FALSE;
14447c478bd9Sstevel@tonic-gate low_vers = (rpcvers_t)(0 - 1);
14457c478bd9Sstevel@tonic-gate high_vers = 0;
144661961e0fSrobinson (void) rw_rdlock(&svc_lock);
14477c478bd9Sstevel@tonic-gate for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
14487c478bd9Sstevel@tonic-gate if (s->sc_prog == r->rq_prog) {
14497c478bd9Sstevel@tonic-gate prog_found = TRUE;
14507c478bd9Sstevel@tonic-gate if (s->sc_vers == r->rq_vers) {
14517c478bd9Sstevel@tonic-gate if ((xprt->xp_netid == NULL) ||
14527c478bd9Sstevel@tonic-gate (s->sc_netid == NULL) ||
14537c478bd9Sstevel@tonic-gate (strcmp(xprt->xp_netid,
145429d91154SMarcel Telka s->sc_netid) == 0)) {
14557c478bd9Sstevel@tonic-gate disp_fn = (*s->sc_dispatch);
145661961e0fSrobinson (void) rw_unlock(&svc_lock);
14577c478bd9Sstevel@tonic-gate disp_fn(r, xprt);
14587c478bd9Sstevel@tonic-gate return (1);
14597c478bd9Sstevel@tonic-gate }
146061961e0fSrobinson prog_found = FALSE;
14617c478bd9Sstevel@tonic-gate }
14627c478bd9Sstevel@tonic-gate if (s->sc_vers < low_vers)
14637c478bd9Sstevel@tonic-gate low_vers = s->sc_vers;
14647c478bd9Sstevel@tonic-gate if (s->sc_vers > high_vers)
14657c478bd9Sstevel@tonic-gate high_vers = s->sc_vers;
14667c478bd9Sstevel@tonic-gate } /* found correct program */
14677c478bd9Sstevel@tonic-gate }
146861961e0fSrobinson (void) rw_unlock(&svc_lock);
14697c478bd9Sstevel@tonic-gate
14707c478bd9Sstevel@tonic-gate /*
14717c478bd9Sstevel@tonic-gate * if we got here, the program or version
14727c478bd9Sstevel@tonic-gate * is not served ...
14737c478bd9Sstevel@tonic-gate */
14747c478bd9Sstevel@tonic-gate if (prog_found) {
14757c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
14767c478bd9Sstevel@tonic-gate if (!version_keepquiet(xprt))
14777c478bd9Sstevel@tonic-gate svcerr_progvers(xprt, low_vers, high_vers);
14787c478bd9Sstevel@tonic-gate } else {
14797c478bd9Sstevel@tonic-gate svcerr_noprog(xprt);
14807c478bd9Sstevel@tonic-gate }
14817c478bd9Sstevel@tonic-gate return (0);
14827c478bd9Sstevel@tonic-gate }
14837c478bd9Sstevel@tonic-gate
14847c478bd9Sstevel@tonic-gate /* ******************* SVCXPRT allocation and deallocation ***************** */
14857c478bd9Sstevel@tonic-gate
14867c478bd9Sstevel@tonic-gate /*
14877c478bd9Sstevel@tonic-gate * svc_xprt_alloc() - allocate a service transport handle
14887c478bd9Sstevel@tonic-gate */
14897c478bd9Sstevel@tonic-gate SVCXPRT *
svc_xprt_alloc(void)149061961e0fSrobinson svc_xprt_alloc(void)
14917c478bd9Sstevel@tonic-gate {
14927c478bd9Sstevel@tonic-gate SVCXPRT *xprt = NULL;
14937c478bd9Sstevel@tonic-gate SVCXPRT_EXT *xt = NULL;
14947c478bd9Sstevel@tonic-gate SVCXPRT_LIST *xlist = NULL;
14957c478bd9Sstevel@tonic-gate struct rpc_msg *msg = NULL;
14967c478bd9Sstevel@tonic-gate struct svc_req *req = NULL;
14977c478bd9Sstevel@tonic-gate char *cred_area = NULL;
14987c478bd9Sstevel@tonic-gate
149961961e0fSrobinson if ((xprt = calloc(1, sizeof (SVCXPRT))) == NULL)
15007c478bd9Sstevel@tonic-gate goto err_exit;
15017c478bd9Sstevel@tonic-gate
150261961e0fSrobinson if ((xt = calloc(1, sizeof (SVCXPRT_EXT))) == NULL)
15037c478bd9Sstevel@tonic-gate goto err_exit;
15047c478bd9Sstevel@tonic-gate xprt->xp_p3 = (caddr_t)xt; /* SVCEXT(xprt) = xt */
15057c478bd9Sstevel@tonic-gate
150661961e0fSrobinson if ((xlist = calloc(1, sizeof (SVCXPRT_LIST))) == NULL)
15077c478bd9Sstevel@tonic-gate goto err_exit;
15087c478bd9Sstevel@tonic-gate xt->my_xlist = xlist;
15097c478bd9Sstevel@tonic-gate xlist->xprt = xprt;
15107c478bd9Sstevel@tonic-gate
151161961e0fSrobinson if ((msg = malloc(sizeof (struct rpc_msg))) == NULL)
15127c478bd9Sstevel@tonic-gate goto err_exit;
15137c478bd9Sstevel@tonic-gate xt->msg = msg;
15147c478bd9Sstevel@tonic-gate
151561961e0fSrobinson if ((req = malloc(sizeof (struct svc_req))) == NULL)
15167c478bd9Sstevel@tonic-gate goto err_exit;
15177c478bd9Sstevel@tonic-gate xt->req = req;
15187c478bd9Sstevel@tonic-gate
151961961e0fSrobinson if ((cred_area = malloc(2*MAX_AUTH_BYTES + RQCRED_SIZE)) == NULL)
15207c478bd9Sstevel@tonic-gate goto err_exit;
15217c478bd9Sstevel@tonic-gate xt->cred_area = cred_area;
15227c478bd9Sstevel@tonic-gate
15237c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
152461961e0fSrobinson (void) mutex_init(&svc_send_mutex(xprt), USYNC_THREAD, (void *)0);
15257c478bd9Sstevel@tonic-gate return (xprt);
15267c478bd9Sstevel@tonic-gate
15277c478bd9Sstevel@tonic-gate err_exit:
15287c478bd9Sstevel@tonic-gate svc_xprt_free(xprt);
15297c478bd9Sstevel@tonic-gate return (NULL);
15307c478bd9Sstevel@tonic-gate }
15317c478bd9Sstevel@tonic-gate
15327c478bd9Sstevel@tonic-gate
15337c478bd9Sstevel@tonic-gate /*
15347c478bd9Sstevel@tonic-gate * svc_xprt_free() - free a service handle
15357c478bd9Sstevel@tonic-gate */
15367c478bd9Sstevel@tonic-gate void
svc_xprt_free(SVCXPRT * xprt)153761961e0fSrobinson svc_xprt_free(SVCXPRT *xprt)
15387c478bd9Sstevel@tonic-gate {
15397c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
15407c478bd9Sstevel@tonic-gate SVCXPRT_EXT *xt = xprt ? SVCEXT(xprt) : NULL;
15417c478bd9Sstevel@tonic-gate SVCXPRT_LIST *my_xlist = xt ? xt->my_xlist: NULL;
15427c478bd9Sstevel@tonic-gate struct rpc_msg *msg = xt ? xt->msg : NULL;
15437c478bd9Sstevel@tonic-gate struct svc_req *req = xt ? xt->req : NULL;
15447c478bd9Sstevel@tonic-gate char *cred_area = xt ? xt->cred_area : NULL;
15457c478bd9Sstevel@tonic-gate
15467c478bd9Sstevel@tonic-gate if (xprt)
154761961e0fSrobinson free(xprt);
15487c478bd9Sstevel@tonic-gate if (xt)
154961961e0fSrobinson free(xt);
15507c478bd9Sstevel@tonic-gate if (my_xlist)
155161961e0fSrobinson free(my_xlist);
15527c478bd9Sstevel@tonic-gate if (msg)
155361961e0fSrobinson free(msg);
15547c478bd9Sstevel@tonic-gate if (req)
155561961e0fSrobinson free(req);
15567c478bd9Sstevel@tonic-gate if (cred_area)
155761961e0fSrobinson free(cred_area);
15587c478bd9Sstevel@tonic-gate }
15597c478bd9Sstevel@tonic-gate
15607c478bd9Sstevel@tonic-gate
15617c478bd9Sstevel@tonic-gate /*
15627c478bd9Sstevel@tonic-gate * svc_xprt_destroy() - free parent and child xprt list
15637c478bd9Sstevel@tonic-gate */
15647c478bd9Sstevel@tonic-gate void
svc_xprt_destroy(SVCXPRT * xprt)156561961e0fSrobinson svc_xprt_destroy(SVCXPRT *xprt)
15667c478bd9Sstevel@tonic-gate {
15677c478bd9Sstevel@tonic-gate SVCXPRT_LIST *xlist, *xnext = NULL;
15687c478bd9Sstevel@tonic-gate int type;
15697c478bd9Sstevel@tonic-gate
15707c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
15717c478bd9Sstevel@tonic-gate if (SVCEXT(xprt)->parent)
15727c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
15737c478bd9Sstevel@tonic-gate xprt = SVCEXT(xprt)->parent;
15747c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
15757c478bd9Sstevel@tonic-gate type = svc_type(xprt);
15767c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
15777c478bd9Sstevel@tonic-gate for (xlist = SVCEXT(xprt)->my_xlist; xlist != NULL; xlist = xnext) {
15787c478bd9Sstevel@tonic-gate xnext = xlist->next;
15797c478bd9Sstevel@tonic-gate xprt = xlist->xprt;
15807c478bd9Sstevel@tonic-gate switch (type) {
15817c478bd9Sstevel@tonic-gate case SVC_DGRAM:
15827c478bd9Sstevel@tonic-gate svc_dg_xprtfree(xprt);
15837c478bd9Sstevel@tonic-gate break;
15847c478bd9Sstevel@tonic-gate case SVC_RENDEZVOUS:
15857c478bd9Sstevel@tonic-gate svc_vc_xprtfree(xprt);
15867c478bd9Sstevel@tonic-gate break;
15877c478bd9Sstevel@tonic-gate case SVC_CONNECTION:
15887c478bd9Sstevel@tonic-gate svc_fd_xprtfree(xprt);
15897c478bd9Sstevel@tonic-gate break;
15907c478bd9Sstevel@tonic-gate case SVC_DOOR:
15917c478bd9Sstevel@tonic-gate svc_door_xprtfree(xprt);
15927c478bd9Sstevel@tonic-gate break;
15937c478bd9Sstevel@tonic-gate }
15947c478bd9Sstevel@tonic-gate }
15957c478bd9Sstevel@tonic-gate }
15967c478bd9Sstevel@tonic-gate
15977c478bd9Sstevel@tonic-gate
15987c478bd9Sstevel@tonic-gate /*
15997c478bd9Sstevel@tonic-gate * svc_copy() - make a copy of parent
16007c478bd9Sstevel@tonic-gate */
16017c478bd9Sstevel@tonic-gate SVCXPRT *
svc_copy(SVCXPRT * xprt)160261961e0fSrobinson svc_copy(SVCXPRT *xprt)
16037c478bd9Sstevel@tonic-gate {
16047c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
16057c478bd9Sstevel@tonic-gate switch (svc_type(xprt)) {
16067c478bd9Sstevel@tonic-gate case SVC_DGRAM:
16077c478bd9Sstevel@tonic-gate return (svc_dg_xprtcopy(xprt));
16087c478bd9Sstevel@tonic-gate case SVC_RENDEZVOUS:
16097c478bd9Sstevel@tonic-gate return (svc_vc_xprtcopy(xprt));
16107c478bd9Sstevel@tonic-gate case SVC_CONNECTION:
16117c478bd9Sstevel@tonic-gate return (svc_fd_xprtcopy(xprt));
16127c478bd9Sstevel@tonic-gate }
161361961e0fSrobinson return (NULL);
16147c478bd9Sstevel@tonic-gate }
16157c478bd9Sstevel@tonic-gate
16167c478bd9Sstevel@tonic-gate
16177c478bd9Sstevel@tonic-gate /*
16187c478bd9Sstevel@tonic-gate * _svc_destroy_private() - private SVC_DESTROY interface
16197c478bd9Sstevel@tonic-gate */
16207c478bd9Sstevel@tonic-gate void
_svc_destroy_private(SVCXPRT * xprt)162161961e0fSrobinson _svc_destroy_private(SVCXPRT *xprt)
16227c478bd9Sstevel@tonic-gate {
16237c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
16247c478bd9Sstevel@tonic-gate switch (svc_type(xprt)) {
16257c478bd9Sstevel@tonic-gate case SVC_DGRAM:
16267c478bd9Sstevel@tonic-gate _svc_dg_destroy_private(xprt);
16277c478bd9Sstevel@tonic-gate break;
16287c478bd9Sstevel@tonic-gate case SVC_RENDEZVOUS:
16297c478bd9Sstevel@tonic-gate case SVC_CONNECTION:
16307c478bd9Sstevel@tonic-gate _svc_vc_destroy_private(xprt, TRUE);
16317c478bd9Sstevel@tonic-gate break;
16327c478bd9Sstevel@tonic-gate }
16337c478bd9Sstevel@tonic-gate }
16347c478bd9Sstevel@tonic-gate
16357c478bd9Sstevel@tonic-gate /*
16367c478bd9Sstevel@tonic-gate * svc_get_local_cred() - fetch local user credentials. This always
16377c478bd9Sstevel@tonic-gate * works over doors based transports. For local transports, this
16387c478bd9Sstevel@tonic-gate * does not yield correct results unless the __rpc_negotiate_uid()
16397c478bd9Sstevel@tonic-gate * call has been invoked to enable this feature.
16407c478bd9Sstevel@tonic-gate */
16417c478bd9Sstevel@tonic-gate bool_t
svc_get_local_cred(SVCXPRT * xprt,svc_local_cred_t * lcred)164261961e0fSrobinson svc_get_local_cred(SVCXPRT *xprt, svc_local_cred_t *lcred)
16437c478bd9Sstevel@tonic-gate {
16447c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
16457c478bd9Sstevel@tonic-gate if (svc_type(xprt) == SVC_DOOR)
16467c478bd9Sstevel@tonic-gate return (__svc_get_door_cred(xprt, lcred));
16477c478bd9Sstevel@tonic-gate return (__rpc_get_local_cred(xprt, lcred));
16487c478bd9Sstevel@tonic-gate }
16497c478bd9Sstevel@tonic-gate
16507c478bd9Sstevel@tonic-gate
16517c478bd9Sstevel@tonic-gate /* ******************* DUPLICATE ENTRY HANDLING ROUTINES ************** */
16527c478bd9Sstevel@tonic-gate
16537c478bd9Sstevel@tonic-gate /*
16547c478bd9Sstevel@tonic-gate * the dup cacheing routines below provide a cache of received
16557c478bd9Sstevel@tonic-gate * transactions. rpc service routines can use this to detect
16567c478bd9Sstevel@tonic-gate * retransmissions and re-send a non-failure response. Uses a
16577c478bd9Sstevel@tonic-gate * lru scheme to find entries to get rid of entries in the cache,
16587c478bd9Sstevel@tonic-gate * though only DUP_DONE entries are placed on the lru list.
16597c478bd9Sstevel@tonic-gate * the routines were written towards development of a generic
16607c478bd9Sstevel@tonic-gate * SVC_DUP() interface, which can be expanded to encompass the
16617c478bd9Sstevel@tonic-gate * svc_dg_enablecache() routines as well. the cache is currently
16627c478bd9Sstevel@tonic-gate * private to the automounter.
16637c478bd9Sstevel@tonic-gate */
16647c478bd9Sstevel@tonic-gate
16657c478bd9Sstevel@tonic-gate
16667c478bd9Sstevel@tonic-gate /* dupcache header contains xprt specific information */
166761961e0fSrobinson struct dupcache {
16687c478bd9Sstevel@tonic-gate rwlock_t dc_lock;
16697c478bd9Sstevel@tonic-gate time_t dc_time;
16707c478bd9Sstevel@tonic-gate int dc_buckets;
16717c478bd9Sstevel@tonic-gate int dc_maxsz;
16727c478bd9Sstevel@tonic-gate int dc_basis;
16737c478bd9Sstevel@tonic-gate struct dupreq *dc_mru;
16747c478bd9Sstevel@tonic-gate struct dupreq **dc_hashtbl;
16757c478bd9Sstevel@tonic-gate };
16767c478bd9Sstevel@tonic-gate
16777c478bd9Sstevel@tonic-gate /*
16787c478bd9Sstevel@tonic-gate * private duplicate cache request routines
16797c478bd9Sstevel@tonic-gate */
16807c478bd9Sstevel@tonic-gate static int __svc_dupcache_check(struct svc_req *, caddr_t *, uint_t *,
16817c478bd9Sstevel@tonic-gate struct dupcache *, uint32_t, uint32_t);
16827c478bd9Sstevel@tonic-gate static struct dupreq *__svc_dupcache_victim(struct dupcache *, time_t);
16837c478bd9Sstevel@tonic-gate static int __svc_dupcache_enter(struct svc_req *, struct dupreq *,
16847c478bd9Sstevel@tonic-gate struct dupcache *, uint32_t, uint32_t, time_t);
16857c478bd9Sstevel@tonic-gate static int __svc_dupcache_update(struct svc_req *, caddr_t, uint_t, int,
16867c478bd9Sstevel@tonic-gate struct dupcache *, uint32_t, uint32_t);
16877c478bd9Sstevel@tonic-gate #ifdef DUP_DEBUG
16887c478bd9Sstevel@tonic-gate static void __svc_dupcache_debug(struct dupcache *);
16897c478bd9Sstevel@tonic-gate #endif /* DUP_DEBUG */
16907c478bd9Sstevel@tonic-gate
16917c478bd9Sstevel@tonic-gate /* default parameters for the dupcache */
16927c478bd9Sstevel@tonic-gate #define DUPCACHE_BUCKETS 257
16937c478bd9Sstevel@tonic-gate #define DUPCACHE_TIME 900
16947c478bd9Sstevel@tonic-gate #define DUPCACHE_MAXSZ INT_MAX
16957c478bd9Sstevel@tonic-gate
16967c478bd9Sstevel@tonic-gate /*
16977c478bd9Sstevel@tonic-gate * __svc_dupcache_init(void *condition, int basis, char *xprt_cache)
16987c478bd9Sstevel@tonic-gate * initialize the duprequest cache and assign it to the xprt_cache
16997c478bd9Sstevel@tonic-gate * Use default values depending on the cache condition and basis.
17007c478bd9Sstevel@tonic-gate * return TRUE on success and FALSE on failure
17017c478bd9Sstevel@tonic-gate */
17027c478bd9Sstevel@tonic-gate bool_t
__svc_dupcache_init(void * condition,int basis,char ** xprt_cache)17037c478bd9Sstevel@tonic-gate __svc_dupcache_init(void *condition, int basis, char **xprt_cache)
17047c478bd9Sstevel@tonic-gate {
17057c478bd9Sstevel@tonic-gate static mutex_t initdc_lock = DEFAULTMUTEX;
17067c478bd9Sstevel@tonic-gate int i;
17077c478bd9Sstevel@tonic-gate struct dupcache *dc;
17087c478bd9Sstevel@tonic-gate
170961961e0fSrobinson (void) mutex_lock(&initdc_lock);
17107c478bd9Sstevel@tonic-gate if (*xprt_cache != NULL) { /* do only once per xprt */
171161961e0fSrobinson (void) mutex_unlock(&initdc_lock);
17127c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
171329d91154SMarcel Telka "__svc_dupcache_init: multiply defined dup cache");
17147c478bd9Sstevel@tonic-gate return (FALSE);
17157c478bd9Sstevel@tonic-gate }
17167c478bd9Sstevel@tonic-gate
17177c478bd9Sstevel@tonic-gate switch (basis) {
17187c478bd9Sstevel@tonic-gate case DUPCACHE_FIXEDTIME:
171961961e0fSrobinson dc = malloc(sizeof (struct dupcache));
17207c478bd9Sstevel@tonic-gate if (dc == NULL) {
172161961e0fSrobinson (void) mutex_unlock(&initdc_lock);
17227c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
172329d91154SMarcel Telka "__svc_dupcache_init: memory alloc failed");
17247c478bd9Sstevel@tonic-gate return (FALSE);
17257c478bd9Sstevel@tonic-gate }
172661961e0fSrobinson (void) rwlock_init(&(dc->dc_lock), USYNC_THREAD, NULL);
17277c478bd9Sstevel@tonic-gate if (condition != NULL)
17287c478bd9Sstevel@tonic-gate dc->dc_time = *((time_t *)condition);
17297c478bd9Sstevel@tonic-gate else
17307c478bd9Sstevel@tonic-gate dc->dc_time = DUPCACHE_TIME;
17317c478bd9Sstevel@tonic-gate dc->dc_buckets = DUPCACHE_BUCKETS;
17327c478bd9Sstevel@tonic-gate dc->dc_maxsz = DUPCACHE_MAXSZ;
17337c478bd9Sstevel@tonic-gate dc->dc_basis = basis;
17347c478bd9Sstevel@tonic-gate dc->dc_mru = NULL;
173561961e0fSrobinson dc->dc_hashtbl = malloc(dc->dc_buckets *
173629d91154SMarcel Telka sizeof (struct dupreq *));
17377c478bd9Sstevel@tonic-gate if (dc->dc_hashtbl == NULL) {
173861961e0fSrobinson free(dc);
173961961e0fSrobinson (void) mutex_unlock(&initdc_lock);
17407c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
174129d91154SMarcel Telka "__svc_dupcache_init: memory alloc failed");
17427c478bd9Sstevel@tonic-gate return (FALSE);
17437c478bd9Sstevel@tonic-gate }
17447c478bd9Sstevel@tonic-gate for (i = 0; i < DUPCACHE_BUCKETS; i++)
17457c478bd9Sstevel@tonic-gate dc->dc_hashtbl[i] = NULL;
17467c478bd9Sstevel@tonic-gate *xprt_cache = (char *)dc;
17477c478bd9Sstevel@tonic-gate break;
17487c478bd9Sstevel@tonic-gate default:
174961961e0fSrobinson (void) mutex_unlock(&initdc_lock);
17507c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
175129d91154SMarcel Telka "__svc_dupcache_init: undefined dup cache basis");
17527c478bd9Sstevel@tonic-gate return (FALSE);
17537c478bd9Sstevel@tonic-gate }
17547c478bd9Sstevel@tonic-gate
175561961e0fSrobinson (void) mutex_unlock(&initdc_lock);
17567c478bd9Sstevel@tonic-gate
17577c478bd9Sstevel@tonic-gate return (TRUE);
17587c478bd9Sstevel@tonic-gate }
17597c478bd9Sstevel@tonic-gate
17607c478bd9Sstevel@tonic-gate /*
17617c478bd9Sstevel@tonic-gate * __svc_dup(struct svc_req *req, caddr_t *resp_buf, uint_t *resp_bufsz,
17627c478bd9Sstevel@tonic-gate * char *xprt_cache)
17637c478bd9Sstevel@tonic-gate * searches the request cache. Creates an entry and returns DUP_NEW if
17647c478bd9Sstevel@tonic-gate * the request is not found in the cache. If it is found, then it
17657c478bd9Sstevel@tonic-gate * returns the state of the request (in progress, drop, or done) and
17667c478bd9Sstevel@tonic-gate * also allocates, and passes back results to the user (if any) in
17677c478bd9Sstevel@tonic-gate * resp_buf, and its length in resp_bufsz. DUP_ERROR is returned on error.
17687c478bd9Sstevel@tonic-gate */
17697c478bd9Sstevel@tonic-gate int
__svc_dup(struct svc_req * req,caddr_t * resp_buf,uint_t * resp_bufsz,char * xprt_cache)17707c478bd9Sstevel@tonic-gate __svc_dup(struct svc_req *req, caddr_t *resp_buf, uint_t *resp_bufsz,
17712209d3c8SRichard Lowe char *xprt_cache)
17727c478bd9Sstevel@tonic-gate {
17737c478bd9Sstevel@tonic-gate uint32_t drxid, drhash;
17747c478bd9Sstevel@tonic-gate int rc;
17757c478bd9Sstevel@tonic-gate struct dupreq *dr = NULL;
17767c478bd9Sstevel@tonic-gate time_t timenow = time(NULL);
17777c478bd9Sstevel@tonic-gate
17787c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
17797c478bd9Sstevel@tonic-gate struct dupcache *dc = (struct dupcache *)xprt_cache;
17807c478bd9Sstevel@tonic-gate
17817c478bd9Sstevel@tonic-gate if (dc == NULL) {
17827c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dup: undefined cache");
17837c478bd9Sstevel@tonic-gate return (DUP_ERROR);
17847c478bd9Sstevel@tonic-gate }
17857c478bd9Sstevel@tonic-gate
17867c478bd9Sstevel@tonic-gate /* get the xid of the request */
17877c478bd9Sstevel@tonic-gate if (SVC_CONTROL(req->rq_xprt, SVCGET_XID, (void*)&drxid) == FALSE) {
17887c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dup: xid error");
17897c478bd9Sstevel@tonic-gate return (DUP_ERROR);
17907c478bd9Sstevel@tonic-gate }
17917c478bd9Sstevel@tonic-gate drhash = drxid % dc->dc_buckets;
17927c478bd9Sstevel@tonic-gate
17937c478bd9Sstevel@tonic-gate if ((rc = __svc_dupcache_check(req, resp_buf, resp_bufsz, dc, drxid,
179429d91154SMarcel Telka drhash)) != DUP_NEW)
17957c478bd9Sstevel@tonic-gate return (rc);
17967c478bd9Sstevel@tonic-gate
17977c478bd9Sstevel@tonic-gate if ((dr = __svc_dupcache_victim(dc, timenow)) == NULL)
17987c478bd9Sstevel@tonic-gate return (DUP_ERROR);
17997c478bd9Sstevel@tonic-gate
18007c478bd9Sstevel@tonic-gate if ((rc = __svc_dupcache_enter(req, dr, dc, drxid, drhash, timenow))
180129d91154SMarcel Telka == DUP_ERROR)
18027c478bd9Sstevel@tonic-gate return (rc);
18037c478bd9Sstevel@tonic-gate
18047c478bd9Sstevel@tonic-gate return (DUP_NEW);
18057c478bd9Sstevel@tonic-gate }
18067c478bd9Sstevel@tonic-gate
18077c478bd9Sstevel@tonic-gate
18087c478bd9Sstevel@tonic-gate
18097c478bd9Sstevel@tonic-gate /*
18107c478bd9Sstevel@tonic-gate * __svc_dupcache_check(struct svc_req *req, caddr_t *resp_buf,
18117c478bd9Sstevel@tonic-gate * uint_t *resp_bufsz,truct dupcache *dc, uint32_t drxid,
18127c478bd9Sstevel@tonic-gate * uint32_t drhash)
18137c478bd9Sstevel@tonic-gate * Checks to see whether an entry already exists in the cache. If it does
18147c478bd9Sstevel@tonic-gate * copy back into the resp_buf, if appropriate. Return the status of
18157c478bd9Sstevel@tonic-gate * the request, or DUP_NEW if the entry is not in the cache
18167c478bd9Sstevel@tonic-gate */
18177c478bd9Sstevel@tonic-gate static int
__svc_dupcache_check(struct svc_req * req,caddr_t * resp_buf,uint_t * resp_bufsz,struct dupcache * dc,uint32_t drxid,uint32_t drhash)18187c478bd9Sstevel@tonic-gate __svc_dupcache_check(struct svc_req *req, caddr_t *resp_buf, uint_t *resp_bufsz,
18192209d3c8SRichard Lowe struct dupcache *dc, uint32_t drxid, uint32_t drhash)
18207c478bd9Sstevel@tonic-gate {
18217c478bd9Sstevel@tonic-gate struct dupreq *dr = NULL;
18227c478bd9Sstevel@tonic-gate
182361961e0fSrobinson (void) rw_rdlock(&(dc->dc_lock));
18247c478bd9Sstevel@tonic-gate dr = dc->dc_hashtbl[drhash];
18257c478bd9Sstevel@tonic-gate while (dr != NULL) {
18267c478bd9Sstevel@tonic-gate if (dr->dr_xid == drxid &&
18277c478bd9Sstevel@tonic-gate dr->dr_proc == req->rq_proc &&
18287c478bd9Sstevel@tonic-gate dr->dr_prog == req->rq_prog &&
18297c478bd9Sstevel@tonic-gate dr->dr_vers == req->rq_vers &&
18307c478bd9Sstevel@tonic-gate dr->dr_addr.len == req->rq_xprt->xp_rtaddr.len &&
183129d91154SMarcel Telka memcmp(dr->dr_addr.buf, req->rq_xprt->xp_rtaddr.buf,
183229d91154SMarcel Telka dr->dr_addr.len) == 0) { /* entry found */
18337c478bd9Sstevel@tonic-gate if (dr->dr_hash != drhash) {
18347c478bd9Sstevel@tonic-gate /* sanity check */
183561961e0fSrobinson (void) rw_unlock((&dc->dc_lock));
18367c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
183729d91154SMarcel Telka "\n__svc_dupdone: hashing error");
18387c478bd9Sstevel@tonic-gate return (DUP_ERROR);
18397c478bd9Sstevel@tonic-gate }
18407c478bd9Sstevel@tonic-gate
18417c478bd9Sstevel@tonic-gate /*
18427c478bd9Sstevel@tonic-gate * return results for requests on lru list, if
18437c478bd9Sstevel@tonic-gate * appropriate requests must be DUP_DROP or DUP_DONE
18447c478bd9Sstevel@tonic-gate * to have a result. A NULL buffer in the cache
18457c478bd9Sstevel@tonic-gate * implies no results were sent during dupdone.
18467c478bd9Sstevel@tonic-gate * A NULL buffer in the call implies not interested
18477c478bd9Sstevel@tonic-gate * in results.
18487c478bd9Sstevel@tonic-gate */
18497c478bd9Sstevel@tonic-gate if (((dr->dr_status == DUP_DONE) ||
185029d91154SMarcel Telka (dr->dr_status == DUP_DROP)) &&
185129d91154SMarcel Telka resp_buf != NULL &&
185229d91154SMarcel Telka dr->dr_resp.buf != NULL) {
185361961e0fSrobinson *resp_buf = malloc(dr->dr_resp.len);
18547c478bd9Sstevel@tonic-gate if (*resp_buf == NULL) {
18557c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
18567c478bd9Sstevel@tonic-gate "__svc_dupcache_check: malloc failed");
185761961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
18587c478bd9Sstevel@tonic-gate return (DUP_ERROR);
18597c478bd9Sstevel@tonic-gate }
186061961e0fSrobinson (void) memset(*resp_buf, 0, dr->dr_resp.len);
186161961e0fSrobinson (void) memcpy(*resp_buf, dr->dr_resp.buf,
186229d91154SMarcel Telka dr->dr_resp.len);
18637c478bd9Sstevel@tonic-gate *resp_bufsz = dr->dr_resp.len;
18647c478bd9Sstevel@tonic-gate } else {
18657c478bd9Sstevel@tonic-gate /* no result */
18667c478bd9Sstevel@tonic-gate if (resp_buf)
18677c478bd9Sstevel@tonic-gate *resp_buf = NULL;
18687c478bd9Sstevel@tonic-gate if (resp_bufsz)
18697c478bd9Sstevel@tonic-gate *resp_bufsz = 0;
18707c478bd9Sstevel@tonic-gate }
187161961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
18727c478bd9Sstevel@tonic-gate return (dr->dr_status);
18737c478bd9Sstevel@tonic-gate }
18747c478bd9Sstevel@tonic-gate dr = dr->dr_chain;
18757c478bd9Sstevel@tonic-gate }
187661961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
18777c478bd9Sstevel@tonic-gate return (DUP_NEW);
18787c478bd9Sstevel@tonic-gate }
18797c478bd9Sstevel@tonic-gate
18807c478bd9Sstevel@tonic-gate /*
18817c478bd9Sstevel@tonic-gate * __svc_dupcache_victim(struct dupcache *dc, time_t timenow)
18827c478bd9Sstevel@tonic-gate * Return a victim dupreq entry to the caller, depending on cache policy.
18837c478bd9Sstevel@tonic-gate */
18847c478bd9Sstevel@tonic-gate static struct dupreq *
__svc_dupcache_victim(struct dupcache * dc,time_t timenow)18857c478bd9Sstevel@tonic-gate __svc_dupcache_victim(struct dupcache *dc, time_t timenow)
18867c478bd9Sstevel@tonic-gate {
18877c478bd9Sstevel@tonic-gate struct dupreq *dr = NULL;
18887c478bd9Sstevel@tonic-gate
18897c478bd9Sstevel@tonic-gate switch (dc->dc_basis) {
18907c478bd9Sstevel@tonic-gate case DUPCACHE_FIXEDTIME:
18917c478bd9Sstevel@tonic-gate /*
18927c478bd9Sstevel@tonic-gate * The hash policy is to free up a bit of the hash
18937c478bd9Sstevel@tonic-gate * table before allocating a new entry as the victim.
18947c478bd9Sstevel@tonic-gate * Freeing up the hash table each time should split
18957c478bd9Sstevel@tonic-gate * the cost of keeping the hash table clean among threads.
18967c478bd9Sstevel@tonic-gate * Note that only DONE or DROPPED entries are on the lru
18977c478bd9Sstevel@tonic-gate * list but we do a sanity check anyway.
18987c478bd9Sstevel@tonic-gate */
189961961e0fSrobinson (void) rw_wrlock(&(dc->dc_lock));
19007c478bd9Sstevel@tonic-gate while ((dc->dc_mru) && (dr = dc->dc_mru->dr_next) &&
190129d91154SMarcel Telka ((timenow - dr->dr_time) > dc->dc_time)) {
19027c478bd9Sstevel@tonic-gate /* clean and then free the entry */
19037c478bd9Sstevel@tonic-gate if (dr->dr_status != DUP_DONE &&
190429d91154SMarcel Telka dr->dr_status != DUP_DROP) {
19057c478bd9Sstevel@tonic-gate /*
19067c478bd9Sstevel@tonic-gate * The LRU list can't contain an
19077c478bd9Sstevel@tonic-gate * entry where the status is other than
19087c478bd9Sstevel@tonic-gate * DUP_DONE or DUP_DROP.
19097c478bd9Sstevel@tonic-gate */
19107c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
191129d91154SMarcel Telka "__svc_dupcache_victim: bad victim");
19127c478bd9Sstevel@tonic-gate #ifdef DUP_DEBUG
19137c478bd9Sstevel@tonic-gate /*
19147c478bd9Sstevel@tonic-gate * Need to hold the reader/writers lock to
19157c478bd9Sstevel@tonic-gate * print the cache info, since we already
19167c478bd9Sstevel@tonic-gate * hold the writers lock, we shall continue
19177c478bd9Sstevel@tonic-gate * calling __svc_dupcache_debug()
19187c478bd9Sstevel@tonic-gate */
19197c478bd9Sstevel@tonic-gate __svc_dupcache_debug(dc);
19207c478bd9Sstevel@tonic-gate #endif /* DUP_DEBUG */
192161961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
19227c478bd9Sstevel@tonic-gate return (NULL);
19237c478bd9Sstevel@tonic-gate }
19247c478bd9Sstevel@tonic-gate /* free buffers */
19257c478bd9Sstevel@tonic-gate if (dr->dr_resp.buf) {
192661961e0fSrobinson free(dr->dr_resp.buf);
19277c478bd9Sstevel@tonic-gate dr->dr_resp.buf = NULL;
19287c478bd9Sstevel@tonic-gate }
19297c478bd9Sstevel@tonic-gate if (dr->dr_addr.buf) {
193061961e0fSrobinson free(dr->dr_addr.buf);
19317c478bd9Sstevel@tonic-gate dr->dr_addr.buf = NULL;
19327c478bd9Sstevel@tonic-gate }
19337c478bd9Sstevel@tonic-gate
19347c478bd9Sstevel@tonic-gate /* unhash the entry */
19357c478bd9Sstevel@tonic-gate if (dr->dr_chain)
19367c478bd9Sstevel@tonic-gate dr->dr_chain->dr_prevchain = dr->dr_prevchain;
19377c478bd9Sstevel@tonic-gate if (dr->dr_prevchain)
19387c478bd9Sstevel@tonic-gate dr->dr_prevchain->dr_chain = dr->dr_chain;
19397c478bd9Sstevel@tonic-gate if (dc->dc_hashtbl[dr->dr_hash] == dr)
19407c478bd9Sstevel@tonic-gate dc->dc_hashtbl[dr->dr_hash] = dr->dr_chain;
19417c478bd9Sstevel@tonic-gate
19427c478bd9Sstevel@tonic-gate /* modify the lru pointers */
194361961e0fSrobinson if (dc->dc_mru == dr) {
19447c478bd9Sstevel@tonic-gate dc->dc_mru = NULL;
194561961e0fSrobinson } else {
19467c478bd9Sstevel@tonic-gate dc->dc_mru->dr_next = dr->dr_next;
19477c478bd9Sstevel@tonic-gate dr->dr_next->dr_prev = dc->dc_mru;
19487c478bd9Sstevel@tonic-gate }
194961961e0fSrobinson free(dr);
19507c478bd9Sstevel@tonic-gate dr = NULL;
19517c478bd9Sstevel@tonic-gate }
195261961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
19537c478bd9Sstevel@tonic-gate
19547c478bd9Sstevel@tonic-gate /*
19557c478bd9Sstevel@tonic-gate * Allocate and return new clean entry as victim
19567c478bd9Sstevel@tonic-gate */
195761961e0fSrobinson if ((dr = malloc(sizeof (*dr))) == NULL) {
19587c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
195929d91154SMarcel Telka "__svc_dupcache_victim: malloc failed");
19607c478bd9Sstevel@tonic-gate return (NULL);
19617c478bd9Sstevel@tonic-gate }
196261961e0fSrobinson (void) memset(dr, 0, sizeof (*dr));
19637c478bd9Sstevel@tonic-gate return (dr);
19647c478bd9Sstevel@tonic-gate default:
19657c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
196629d91154SMarcel Telka "__svc_dupcache_victim: undefined dup cache_basis");
19677c478bd9Sstevel@tonic-gate return (NULL);
19687c478bd9Sstevel@tonic-gate }
19697c478bd9Sstevel@tonic-gate }
19707c478bd9Sstevel@tonic-gate
19717c478bd9Sstevel@tonic-gate /*
19727c478bd9Sstevel@tonic-gate * __svc_dupcache_enter(struct svc_req *req, struct dupreq *dr,
19737c478bd9Sstevel@tonic-gate * struct dupcache *dc, uint32_t drxid, uint32_t drhash, time_t timenow)
19747c478bd9Sstevel@tonic-gate * build new duprequest entry and then insert into the cache
19757c478bd9Sstevel@tonic-gate */
19767c478bd9Sstevel@tonic-gate static int
__svc_dupcache_enter(struct svc_req * req,struct dupreq * dr,struct dupcache * dc,uint32_t drxid,uint32_t drhash,time_t timenow)19777c478bd9Sstevel@tonic-gate __svc_dupcache_enter(struct svc_req *req, struct dupreq *dr,
19782209d3c8SRichard Lowe struct dupcache *dc, uint32_t drxid, uint32_t drhash, time_t timenow)
19797c478bd9Sstevel@tonic-gate {
19807c478bd9Sstevel@tonic-gate dr->dr_xid = drxid;
19817c478bd9Sstevel@tonic-gate dr->dr_prog = req->rq_prog;
19827c478bd9Sstevel@tonic-gate dr->dr_vers = req->rq_vers;
19837c478bd9Sstevel@tonic-gate dr->dr_proc = req->rq_proc;
19847c478bd9Sstevel@tonic-gate dr->dr_addr.maxlen = req->rq_xprt->xp_rtaddr.len;
19857c478bd9Sstevel@tonic-gate dr->dr_addr.len = dr->dr_addr.maxlen;
198661961e0fSrobinson if ((dr->dr_addr.buf = malloc(dr->dr_addr.maxlen)) == NULL) {
198761961e0fSrobinson syslog(LOG_ERR, "__svc_dupcache_enter: malloc failed");
198861961e0fSrobinson free(dr);
19897c478bd9Sstevel@tonic-gate return (DUP_ERROR);
19907c478bd9Sstevel@tonic-gate }
199161961e0fSrobinson (void) memset(dr->dr_addr.buf, 0, dr->dr_addr.len);
199261961e0fSrobinson (void) memcpy(dr->dr_addr.buf, req->rq_xprt->xp_rtaddr.buf,
199329d91154SMarcel Telka dr->dr_addr.len);
19947c478bd9Sstevel@tonic-gate dr->dr_resp.buf = NULL;
19957c478bd9Sstevel@tonic-gate dr->dr_resp.maxlen = 0;
19967c478bd9Sstevel@tonic-gate dr->dr_resp.len = 0;
19977c478bd9Sstevel@tonic-gate dr->dr_status = DUP_INPROGRESS;
19987c478bd9Sstevel@tonic-gate dr->dr_time = timenow;
19997c478bd9Sstevel@tonic-gate dr->dr_hash = drhash; /* needed for efficient victim cleanup */
20007c478bd9Sstevel@tonic-gate
20017c478bd9Sstevel@tonic-gate /* place entry at head of hash table */
200261961e0fSrobinson (void) rw_wrlock(&(dc->dc_lock));
20037c478bd9Sstevel@tonic-gate dr->dr_chain = dc->dc_hashtbl[drhash];
20047c478bd9Sstevel@tonic-gate dr->dr_prevchain = NULL;
20057c478bd9Sstevel@tonic-gate if (dc->dc_hashtbl[drhash] != NULL)
20067c478bd9Sstevel@tonic-gate dc->dc_hashtbl[drhash]->dr_prevchain = dr;
20077c478bd9Sstevel@tonic-gate dc->dc_hashtbl[drhash] = dr;
200861961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
20097c478bd9Sstevel@tonic-gate return (DUP_NEW);
20107c478bd9Sstevel@tonic-gate }
20117c478bd9Sstevel@tonic-gate
20127c478bd9Sstevel@tonic-gate /*
20137c478bd9Sstevel@tonic-gate * __svc_dupdone(struct svc_req *req, caddr_t resp_buf, uint_t resp_bufsz,
20147c478bd9Sstevel@tonic-gate * int status, char *xprt_cache)
20157c478bd9Sstevel@tonic-gate * Marks the request done (DUP_DONE or DUP_DROP) and stores the response.
20167c478bd9Sstevel@tonic-gate * Only DONE and DROP requests can be marked as done. Sets the lru pointers
20177c478bd9Sstevel@tonic-gate * to make the entry the most recently used. Returns DUP_ERROR or status.
20187c478bd9Sstevel@tonic-gate */
20197c478bd9Sstevel@tonic-gate int
__svc_dupdone(struct svc_req * req,caddr_t resp_buf,uint_t resp_bufsz,int status,char * xprt_cache)20207c478bd9Sstevel@tonic-gate __svc_dupdone(struct svc_req *req, caddr_t resp_buf, uint_t resp_bufsz,
20212209d3c8SRichard Lowe int status, char *xprt_cache)
20227c478bd9Sstevel@tonic-gate {
20237c478bd9Sstevel@tonic-gate uint32_t drxid, drhash;
20247c478bd9Sstevel@tonic-gate int rc;
20257c478bd9Sstevel@tonic-gate
20267c478bd9Sstevel@tonic-gate /* LINTED pointer alignment */
20277c478bd9Sstevel@tonic-gate struct dupcache *dc = (struct dupcache *)xprt_cache;
20287c478bd9Sstevel@tonic-gate
20297c478bd9Sstevel@tonic-gate if (dc == NULL) {
20307c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dupdone: undefined cache");
20317c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20327c478bd9Sstevel@tonic-gate }
20337c478bd9Sstevel@tonic-gate
20347c478bd9Sstevel@tonic-gate if (status != DUP_DONE && status != DUP_DROP) {
20357c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dupdone: invalid dupdone status");
20367c478bd9Sstevel@tonic-gate syslog(LOG_ERR, " must be DUP_DONE or DUP_DROP");
20377c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20387c478bd9Sstevel@tonic-gate }
20397c478bd9Sstevel@tonic-gate
20407c478bd9Sstevel@tonic-gate /* find the xid of the entry in the cache */
20417c478bd9Sstevel@tonic-gate if (SVC_CONTROL(req->rq_xprt, SVCGET_XID, (void*)&drxid) == FALSE) {
20427c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dup: xid error");
20437c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20447c478bd9Sstevel@tonic-gate }
20457c478bd9Sstevel@tonic-gate drhash = drxid % dc->dc_buckets;
20467c478bd9Sstevel@tonic-gate
20477c478bd9Sstevel@tonic-gate /* update the status of the entry and result buffers, if required */
20487c478bd9Sstevel@tonic-gate if ((rc = __svc_dupcache_update(req, resp_buf, resp_bufsz, status,
204929d91154SMarcel Telka dc, drxid, drhash)) == DUP_ERROR) {
20507c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dupdone: cache entry error");
20517c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20527c478bd9Sstevel@tonic-gate }
20537c478bd9Sstevel@tonic-gate
20547c478bd9Sstevel@tonic-gate return (rc);
20557c478bd9Sstevel@tonic-gate }
20567c478bd9Sstevel@tonic-gate
20577c478bd9Sstevel@tonic-gate /*
20587c478bd9Sstevel@tonic-gate * __svc_dupcache_update(struct svc_req *req, caddr_t resp_buf,
20597c478bd9Sstevel@tonic-gate * uint_t resp_bufsz, int status, struct dupcache *dc, uint32_t drxid,
20607c478bd9Sstevel@tonic-gate * uint32_t drhash)
20617c478bd9Sstevel@tonic-gate * Check if entry exists in the dupcacache. If it does, update its status
20627c478bd9Sstevel@tonic-gate * and time and also its buffer, if appropriate. Its possible, but unlikely
20637c478bd9Sstevel@tonic-gate * for DONE requests to not exist in the cache. Return DUP_ERROR or status.
20647c478bd9Sstevel@tonic-gate */
20657c478bd9Sstevel@tonic-gate static int
__svc_dupcache_update(struct svc_req * req,caddr_t resp_buf,uint_t resp_bufsz,int status,struct dupcache * dc,uint32_t drxid,uint32_t drhash)20667c478bd9Sstevel@tonic-gate __svc_dupcache_update(struct svc_req *req, caddr_t resp_buf, uint_t resp_bufsz,
20672209d3c8SRichard Lowe int status, struct dupcache *dc, uint32_t drxid, uint32_t drhash)
20687c478bd9Sstevel@tonic-gate {
20697c478bd9Sstevel@tonic-gate struct dupreq *dr = NULL;
20707c478bd9Sstevel@tonic-gate time_t timenow = time(NULL);
20717c478bd9Sstevel@tonic-gate
207261961e0fSrobinson (void) rw_wrlock(&(dc->dc_lock));
20737c478bd9Sstevel@tonic-gate dr = dc->dc_hashtbl[drhash];
20747c478bd9Sstevel@tonic-gate while (dr != NULL) {
20757c478bd9Sstevel@tonic-gate if (dr->dr_xid == drxid &&
20767c478bd9Sstevel@tonic-gate dr->dr_proc == req->rq_proc &&
20777c478bd9Sstevel@tonic-gate dr->dr_prog == req->rq_prog &&
20787c478bd9Sstevel@tonic-gate dr->dr_vers == req->rq_vers &&
20797c478bd9Sstevel@tonic-gate dr->dr_addr.len == req->rq_xprt->xp_rtaddr.len &&
208029d91154SMarcel Telka memcmp(dr->dr_addr.buf, req->rq_xprt->xp_rtaddr.buf,
208129d91154SMarcel Telka dr->dr_addr.len) == 0) { /* entry found */
20827c478bd9Sstevel@tonic-gate if (dr->dr_hash != drhash) {
20837c478bd9Sstevel@tonic-gate /* sanity check */
208461961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
20857c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
20867c478bd9Sstevel@tonic-gate "\n__svc_dupdone: hashing error");
20877c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20887c478bd9Sstevel@tonic-gate }
20897c478bd9Sstevel@tonic-gate
20907c478bd9Sstevel@tonic-gate /* store the results if bufer is not NULL */
20917c478bd9Sstevel@tonic-gate if (resp_buf != NULL) {
209261961e0fSrobinson if ((dr->dr_resp.buf =
209329d91154SMarcel Telka malloc(resp_bufsz)) == NULL) {
209461961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
20957c478bd9Sstevel@tonic-gate syslog(LOG_ERR,
209629d91154SMarcel Telka "__svc_dupdone: malloc failed");
20977c478bd9Sstevel@tonic-gate return (DUP_ERROR);
20987c478bd9Sstevel@tonic-gate }
209961961e0fSrobinson (void) memset(dr->dr_resp.buf, 0, resp_bufsz);
210061961e0fSrobinson (void) memcpy(dr->dr_resp.buf, resp_buf,
210129d91154SMarcel Telka (uint_t)resp_bufsz);
21027c478bd9Sstevel@tonic-gate dr->dr_resp.len = resp_bufsz;
21037c478bd9Sstevel@tonic-gate }
21047c478bd9Sstevel@tonic-gate
21057c478bd9Sstevel@tonic-gate /* update status and done time */
21067c478bd9Sstevel@tonic-gate dr->dr_status = status;
21077c478bd9Sstevel@tonic-gate dr->dr_time = timenow;
21087c478bd9Sstevel@tonic-gate
21097c478bd9Sstevel@tonic-gate /* move the entry to the mru position */
21107c478bd9Sstevel@tonic-gate if (dc->dc_mru == NULL) {
21117c478bd9Sstevel@tonic-gate dr->dr_next = dr;
21127c478bd9Sstevel@tonic-gate dr->dr_prev = dr;
21137c478bd9Sstevel@tonic-gate } else {
21147c478bd9Sstevel@tonic-gate dr->dr_next = dc->dc_mru->dr_next;
21157c478bd9Sstevel@tonic-gate dc->dc_mru->dr_next->dr_prev = dr;
21167c478bd9Sstevel@tonic-gate dr->dr_prev = dc->dc_mru;
21177c478bd9Sstevel@tonic-gate dc->dc_mru->dr_next = dr;
21187c478bd9Sstevel@tonic-gate }
21197c478bd9Sstevel@tonic-gate dc->dc_mru = dr;
21207c478bd9Sstevel@tonic-gate
212161961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
21227c478bd9Sstevel@tonic-gate return (status);
21237c478bd9Sstevel@tonic-gate }
21247c478bd9Sstevel@tonic-gate dr = dr->dr_chain;
21257c478bd9Sstevel@tonic-gate }
212661961e0fSrobinson (void) rw_unlock(&(dc->dc_lock));
21277c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "__svc_dupdone: entry not in dup cache");
21287c478bd9Sstevel@tonic-gate return (DUP_ERROR);
21297c478bd9Sstevel@tonic-gate }
21307c478bd9Sstevel@tonic-gate
21317c478bd9Sstevel@tonic-gate #ifdef DUP_DEBUG
21327c478bd9Sstevel@tonic-gate /*
21337c478bd9Sstevel@tonic-gate * __svc_dupcache_debug(struct dupcache *dc)
21347c478bd9Sstevel@tonic-gate * print out the hash table stuff
21357c478bd9Sstevel@tonic-gate *
21367c478bd9Sstevel@tonic-gate * This function requires the caller to hold the reader
21377c478bd9Sstevel@tonic-gate * or writer version of the duplicate request cache lock (dc_lock).
21387c478bd9Sstevel@tonic-gate */
21397c478bd9Sstevel@tonic-gate static void
__svc_dupcache_debug(struct dupcache * dc)21407c478bd9Sstevel@tonic-gate __svc_dupcache_debug(struct dupcache *dc)
21417c478bd9Sstevel@tonic-gate {
21427c478bd9Sstevel@tonic-gate struct dupreq *dr = NULL;
21437c478bd9Sstevel@tonic-gate int i;
21447c478bd9Sstevel@tonic-gate bool_t bval;
21457c478bd9Sstevel@tonic-gate
21467c478bd9Sstevel@tonic-gate fprintf(stderr, " HASHTABLE\n");
21477c478bd9Sstevel@tonic-gate for (i = 0; i < dc->dc_buckets; i++) {
21487c478bd9Sstevel@tonic-gate bval = FALSE;
21497c478bd9Sstevel@tonic-gate dr = dc->dc_hashtbl[i];
21507c478bd9Sstevel@tonic-gate while (dr != NULL) {
21517c478bd9Sstevel@tonic-gate if (!bval) { /* ensures bucket printed only once */
21527c478bd9Sstevel@tonic-gate fprintf(stderr, " bucket : %d\n", i);
21537c478bd9Sstevel@tonic-gate bval = TRUE;
21547c478bd9Sstevel@tonic-gate }
21557c478bd9Sstevel@tonic-gate fprintf(stderr, "\txid: %u status: %d time: %ld",
215629d91154SMarcel Telka dr->dr_xid, dr->dr_status, dr->dr_time);
21577c478bd9Sstevel@tonic-gate fprintf(stderr, " dr: %x chain: %x prevchain: %x\n",
215829d91154SMarcel Telka dr, dr->dr_chain, dr->dr_prevchain);
21597c478bd9Sstevel@tonic-gate dr = dr->dr_chain;
21607c478bd9Sstevel@tonic-gate }
21617c478bd9Sstevel@tonic-gate }
21627c478bd9Sstevel@tonic-gate
21637c478bd9Sstevel@tonic-gate fprintf(stderr, " LRU\n");
21647c478bd9Sstevel@tonic-gate if (dc->dc_mru) {
21657c478bd9Sstevel@tonic-gate dr = dc->dc_mru->dr_next; /* lru */
21667c478bd9Sstevel@tonic-gate while (dr != dc->dc_mru) {
21677c478bd9Sstevel@tonic-gate fprintf(stderr, "\txid: %u status : %d time : %ld",
216829d91154SMarcel Telka dr->dr_xid, dr->dr_status, dr->dr_time);
21697c478bd9Sstevel@tonic-gate fprintf(stderr, " dr: %x next: %x prev: %x\n",
217029d91154SMarcel Telka dr, dr->dr_next, dr->dr_prev);
21717c478bd9Sstevel@tonic-gate dr = dr->dr_next;
21727c478bd9Sstevel@tonic-gate }
21737c478bd9Sstevel@tonic-gate fprintf(stderr, "\txid: %u status: %d time: %ld",
217429d91154SMarcel Telka dr->dr_xid, dr->dr_status, dr->dr_time);
217529d91154SMarcel Telka fprintf(stderr, " dr: %x next: %x prev: %x\n",
217629d91154SMarcel Telka dr, dr->dr_next, dr->dr_prev);
21777c478bd9Sstevel@tonic-gate }
21787c478bd9Sstevel@tonic-gate }
21797c478bd9Sstevel@tonic-gate #endif /* DUP_DEBUG */
2180