OpenSolaris_b135/lib/libnsl/rpc/svc_door.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* svc_door.c, Server side for doors IPC based RPC.
*/
#include "mt.h"
#include "rpc_mt.h"
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <errno.h>
#include <syslog.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <door.h>
#include <alloca.h>
#include <dlfcn.h>
#include <limits.h>
#include <rpc/svc_mt.h>
static void svc_door_destroy_pvt();
static int return_xprt_copy();
int __rpc_default_door_buf_size = 16000;
int __rpc_min_door_buf_size = 1000;
static struct xp_ops *svc_door_ops();
mutex_t svc_door_mutex = DEFAULTMUTEX;
cond_t svc_door_waitcv = DEFAULTCV;
int svc_ndoorfds = 0;
/*
* Dispatch information for door calls.
*/
typedef struct {
rpcprog_t prognum;
rpcvers_t versnum;
void (*dispatch)();
} call_info_t;
/*
* kept in xprt->xp_p2
*/
struct svc_door_data {
uint_t su_iosz; /* size of send/recv buffer */
uint32_t su_xid; /* transaction id */
XDR su_xdrs; /* XDR handle */
char su_verfbody[MAX_AUTH_BYTES]; /* verifier body */
call_info_t call_info; /* dispatch info */
char *argbuf; /* argument buffer */
size_t arglen; /* argument length */
char *buf; /* result buffer */
int len; /* result length */
};
#define su_data(xprt) ((struct svc_door_data *)(xprt->xp_p2))
static SVCXPRT *get_xprt_copy();
static bool_t svc_door_recv();
static void svc_door_destroy();
static SVCXPRT_LIST *dxlist; /* list of door based service handles */
/*
* List management routines.
*/
bool_t
__svc_add_to_xlist(SVCXPRT_LIST **list, SVCXPRT *xprt, mutex_t *lockp)
{
SVCXPRT_LIST *l;
if ((l = malloc(sizeof (*l))) == NULL)
return (FALSE);
l->xprt = xprt;
if (lockp != NULL)
(void) mutex_lock(lockp);
l->next = *list;
*list = l;
if (lockp != NULL)
(void) mutex_unlock(lockp);
return (TRUE);
}
void
__svc_rm_from_xlist(SVCXPRT_LIST **list, SVCXPRT *xprt, mutex_t *lockp)
{
SVCXPRT_LIST **l, *tmp;
if (lockp != NULL)
(void) mutex_lock(lockp);
for (l = list; *l != NULL; l = &(*l)->next) {
if ((*l)->xprt == xprt) {
tmp = (*l)->next;
free(*l);
*l = tmp;
break;
}
}
if (lockp != NULL)
(void) mutex_unlock(lockp);
}
void
__svc_free_xlist(SVCXPRT_LIST **list, mutex_t *lockp)
{
SVCXPRT_LIST *tmp;
if (lockp != NULL)
(void) mutex_lock(lockp);
while (*list != NULL) {
tmp = (*list)->next;
free(*list);
*list = tmp;
}
if (lockp != NULL)
(void) mutex_unlock(lockp);
}
/*
* Destroy all door based service handles.
*/
void
__svc_cleanup_door_xprts(void)
{
SVCXPRT_LIST *l, *tmp = NULL;
(void) mutex_lock(&svc_door_mutex);
for (l = dxlist; l != NULL; l = tmp) {
tmp = l->next;
svc_door_destroy_pvt(l->xprt);
}
(void) mutex_unlock(&svc_door_mutex);
}
static bool_t
make_tmp_dir(void)
{
struct stat statbuf;
if (stat(RPC_DOOR_DIR, &statbuf) < 0) {
(void) mkdir(RPC_DOOR_DIR, (mode_t)0755);
(void) chmod(RPC_DOOR_DIR, (mode_t)01777);
if (stat(RPC_DOOR_DIR, &statbuf) < 0)
return (FALSE);
}
return ((statbuf.st_mode & S_IFMT) == S_IFDIR &&
(statbuf.st_mode & 01777) == 01777);
}
static void
svc_door_dispatch(SVCXPRT *xprt, struct rpc_msg *msg, struct svc_req *r)
{
enum auth_stat why;
/* LINTED pointer alignment */
struct svc_door_data *su = su_data(xprt);
bool_t nd;
r->rq_xprt = xprt;
r->rq_prog = msg->rm_call.cb_prog;
r->rq_vers = msg->rm_call.cb_vers;
r->rq_proc = msg->rm_call.cb_proc;
r->rq_cred = msg->rm_call.cb_cred;
if (msg->rm_call.cb_cred.oa_flavor == AUTH_NULL) {
r->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
r->rq_xprt->xp_verf.oa_length = 0;
} else if ((why = __gss_authenticate(r, msg, &nd)) != AUTH_OK) {
svcerr_auth(xprt, why);
return;
}
if (su->call_info.prognum == r->rq_prog && su->call_info.versnum ==
r->rq_vers) {
(*su->call_info.dispatch)(r, xprt);
return;
}
/*
* if we got here, the program or version
* is not served ...
*/
if (su->call_info.prognum == r->rq_prog)
svcerr_progvers(xprt, su->call_info.versnum,
su->call_info.versnum);
else
svcerr_noprog(xprt);
}
/*
* This is the door server procedure.
*/
/* ARGSUSED */
static void
door_server(void *cookie, char *argp, size_t arg_size,
door_desc_t *dp, uint_t n_did)
{
SVCXPRT *parent = (SVCXPRT *)cookie;
SVCXPRT *xprt;
struct rpc_msg *msg;
struct svc_req *r;
char *cred_area;
char *result_buf;
int len;
struct svc_door_data *su;
/*
* allocate result buffer
*/
/* LINTED pointer alignment */
result_buf = alloca(su_data(parent)->su_iosz);
if (result_buf == NULL) {
(void) syslog(LOG_ERR, "door_server: alloca failed");
(void) door_return(NULL, 0, NULL, 0);
/*NOTREACHED*/
}
(void) mutex_lock(&svc_door_mutex);
if ((xprt = get_xprt_copy(parent, result_buf)) == NULL) {
(void) syslog(LOG_ERR,
"door_server: memory allocation failure");
(void) mutex_unlock(&svc_door_mutex);
(void) door_return(NULL, 0, NULL, 0);
/*NOTREACHED*/
}
(void) mutex_unlock(&svc_door_mutex);
/* LINTED pointer alignment */
msg = SVCEXT(xprt)->msg;
/* LINTED pointer alignment */
r = SVCEXT(xprt)->req;
/* LINTED pointer alignment */
cred_area = SVCEXT(xprt)->cred_area;
msg->rm_call.cb_cred.oa_base = cred_area;
msg->rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
r->rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);
/* LINTED pointer alignment */
su = su_data(xprt);
su->argbuf = argp;
su->arglen = arg_size;
if (svc_door_recv(xprt, msg))
svc_door_dispatch(xprt, msg, r);
if ((len = return_xprt_copy(xprt)) > 0) {
(void) door_return(result_buf, (size_t)len, NULL, 0);
/*NOTREACHED*/
} else {
(void) door_return(NULL, 0, NULL, 0);
/*NOTREACHED*/
}
}
/*
* Usage:
* xprt = svc_door_create(dispatch, prognum, versnum, sendsize);
* Once *xprt is initialized, it is registered.
* see (svc.h, xprt_register). If recvsize or sendsize are 0 suitable
* system defaults are chosen.
* The routines returns NULL if a problem occurred.
*/
void
svc_door_xprtfree(SVCXPRT *xprt)
{
/* LINTED pointer alignment */
struct svc_door_data *su = xprt ? su_data(xprt) : NULL;
if (xprt == NULL)
return;
if (xprt->xp_netid)
free(xprt->xp_netid);
if (xprt->xp_tp)
free(xprt->xp_tp);
if (su != NULL)
free(su);
svc_xprt_free(xprt);
}
SVCXPRT *
svc_door_create(void (*dispatch)(), const rpcprog_t prognum,
const rpcvers_t versnum, const uint_t sendsize)
{
SVCXPRT *xprt;
struct svc_door_data *su = NULL;
char rendezvous[128] = "";
int fd;
int did = -1;
mode_t mask;
uint_t ssize;
(void) mutex_lock(&svc_door_mutex);
if (!make_tmp_dir()) {
(void) syslog(LOG_ERR, "svc_door_create: cannot open %s",
RPC_DOOR_DIR);
(void) mutex_unlock(&svc_door_mutex);
return (NULL);
}
if ((xprt = svc_xprt_alloc()) == NULL) {
(void) syslog(LOG_ERR, "svc_door_create: out of memory");
goto freedata;
}
/* LINTED pointer alignment */
svc_flags(xprt) |= SVC_DOOR;
(void) sprintf(rendezvous, RPC_DOOR_RENDEZVOUS, (int)prognum,
(int)versnum);
mask = umask(0);
fd = open(rendezvous, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0644);
(void) umask(mask);
if (fd < 0) {
if (errno == EEXIST) {
if (unlink(rendezvous) < 0) {
(void) syslog(LOG_ERR,
"svc_door_create: %s %s:%m", rendezvous,
"exists and could not be removed");
goto freedata;
}
mask = umask(0);
fd = open(rendezvous, O_WRONLY|O_CREAT|O_EXCL|
O_TRUNC, 0644);
(void) umask(mask);
if (fd < 0) {
(void) syslog(LOG_ERR,
"svc_door_create: %s %s:%m",
"could not create", rendezvous);
goto freedata;
}
} else {
(void) syslog(LOG_ERR,
"svc_door_create: could not create %s:%m",
rendezvous);
goto freedata;
}
}
(void) close(fd);
did = door_create(door_server, (void *)xprt, DOOR_REFUSE_DESC);
if (did < 0) {
(void) syslog(LOG_ERR,
"svc_door_create: door_create failed: %m");
goto freedata;
}
if (fattach(did, rendezvous) < 0) {
if (errno != EBUSY || fdetach(rendezvous) < 0 ||
fattach(did, rendezvous) < 0) {
(void) syslog(LOG_ERR,
"svc_door_create: fattach failed: %m");
goto freedata;
}
}
/*
* Determine send size
*/
if (sendsize < __rpc_min_door_buf_size)
ssize = __rpc_default_door_buf_size;
else
ssize = RNDUP(sendsize);
su = malloc(sizeof (*su));
if (su == NULL) {
(void) syslog(LOG_ERR, "svc_door_create: out of memory");
goto freedata;
}
su->su_iosz = ssize;
su->call_info.prognum = prognum;
su->call_info.versnum = versnum;
su->call_info.dispatch = dispatch;
xprt->xp_p2 = (caddr_t)su;
xprt->xp_verf.oa_base = su->su_verfbody;
xprt->xp_ops = svc_door_ops();
xprt->xp_netid = strdup("door");
if (xprt->xp_netid == NULL) {
syslog(LOG_ERR, "svc_door_create: strdup failed");
goto freedata;
}
xprt->xp_tp = strdup(rendezvous);
if (xprt->xp_tp == NULL) {
syslog(LOG_ERR, "svc_door_create: strdup failed");
goto freedata;
}
xprt->xp_fd = did;
svc_ndoorfds++;
if (!__svc_add_to_xlist(&dxlist, xprt, NULL)) {
(void) syslog(LOG_ERR, "svc_door_create: out of memory");
goto freedata;
}
(void) mutex_unlock(&svc_door_mutex);
return (xprt);
freedata:
(void) fdetach(rendezvous);
(void) unlink(rendezvous);
if (did >= 0)
(void) door_revoke(did);
if (xprt)
svc_door_xprtfree(xprt);
(void) mutex_unlock(&svc_door_mutex);
return (NULL);
}
static SVCXPRT *
svc_door_xprtcopy(SVCXPRT *parent)
{
SVCXPRT *xprt;
struct svc_door_data *su;
if ((xprt = svc_xprt_alloc()) == NULL)
return (NULL);
/* LINTED pointer alignment */
SVCEXT(xprt)->parent = parent;
/* LINTED pointer alignment */
SVCEXT(xprt)->flags = SVCEXT(parent)->flags;
xprt->xp_fd = parent->xp_fd;
xprt->xp_port = parent->xp_port;
xprt->xp_ops = svc_door_ops();
if (parent->xp_tp) {
xprt->xp_tp = (char *)strdup(parent->xp_tp);
if (xprt->xp_tp == NULL) {
syslog(LOG_ERR, "svc_door_xprtcopy: strdup failed");
svc_door_xprtfree(xprt);
return (NULL);
}
}
if (parent->xp_netid) {
xprt->xp_netid = (char *)strdup(parent->xp_netid);
if (xprt->xp_netid == NULL) {
syslog(LOG_ERR, "svc_door_xprtcopy: strdup failed");
if (parent->xp_tp)
free(parent->xp_tp);
svc_door_xprtfree(xprt);
return (NULL);
}
}
xprt->xp_type = parent->xp_type;
if ((su = malloc(sizeof (struct svc_door_data))) == NULL) {
svc_door_xprtfree(xprt);
return (NULL);
}
/* LINTED pointer alignment */
su->su_iosz = su_data(parent)->su_iosz;
/* LINTED pointer alignment */
su->call_info = su_data(parent)->call_info;
xprt->xp_p2 = (caddr_t)su; /* su_data(xprt) = su */
xprt->xp_verf.oa_base = su->su_verfbody;
return (xprt);
}
static SVCXPRT *
get_xprt_copy(SVCXPRT *parent, char *buf)
{
/* LINTED pointer alignment */
SVCXPRT_LIST *xlist = SVCEXT(parent)->my_xlist;
SVCXPRT_LIST *xret;
SVCXPRT *xprt;
struct svc_door_data *su;
xret = xlist->next;
if (xret) {
xlist->next = xret->next;
xret->next = NULL;
xprt = xret->xprt;
/* LINTED pointer alignment */
svc_flags(xprt) = svc_flags(parent);
} else
xprt = svc_door_xprtcopy(parent);
if (xprt) {
/* LINTED pointer alignment */
SVCEXT(parent)->refcnt++;
/* LINTED pointer alignment */
su = su_data(xprt);
su->buf = buf;
su->len = 0;
}
return (xprt);
}
int
return_xprt_copy(SVCXPRT *xprt)
{
SVCXPRT *parent;
SVCXPRT_LIST *xhead, *xlist;
/* LINTED pointer alignment */
int len = su_data(xprt)->len;
(void) mutex_lock(&svc_door_mutex);
/* LINTED pointer alignment */
if ((parent = SVCEXT(xprt)->parent) == NULL) {
(void) mutex_unlock(&svc_door_mutex);
return (0);
}
/* LINTED pointer alignment */
xhead = SVCEXT(parent)->my_xlist;
/* LINTED pointer alignment */
xlist = SVCEXT(xprt)->my_xlist;
xlist->next = xhead->next;
xhead->next = xlist;
/* LINTED pointer alignment */
SVCEXT(parent)->refcnt--;
/*
* Propagate any error flags. This is done in both directions to
* ensure that if one child gets an error, everyone will see it
* (even if there are multiple outstanding children) and the
* door will get closed.
*/
/* LINTED pointer alignment */
svc_flags(xprt) |= svc_flags(parent);
/* LINTED pointer alignment */
if (svc_defunct(xprt)) {
/* LINTED pointer alignment */
svc_flags(parent) |= SVC_DEFUNCT;
/* LINTED pointer cast */
if (SVCEXT(parent)->refcnt == 0)
svc_door_destroy(xprt);
}
(void) mutex_unlock(&svc_door_mutex);
return (len);
}
/* ARGSUSED */
static enum xprt_stat
svc_door_stat(SVCXPRT *xprt)
{
return (XPRT_IDLE);
}
static bool_t
svc_door_recv(SVCXPRT *xprt, struct rpc_msg *msg)
{
/* LINTED pointer alignment */
struct svc_door_data *su = su_data(xprt);
XDR *xdrs = &(su->su_xdrs);
xdrmem_create(xdrs, su->argbuf, su->arglen, XDR_DECODE);
if (!xdr_callmsg(xdrs, msg))
return (FALSE);
su->su_xid = msg->rm_xid;
return (TRUE);
}
static bool_t
svc_door_reply(SVCXPRT *xprt, struct rpc_msg *msg)
{
/* LINTED pointer alignment */
struct svc_door_data *su = su_data(xprt);
XDR *xdrs = &(su->su_xdrs);
xdrmem_create(xdrs, su->buf, su->su_iosz, XDR_ENCODE);
msg->rm_xid = su->su_xid;
if (xdr_replymsg(xdrs, msg)) {
su->len = (int)XDR_GETPOS(xdrs);
return (TRUE);
}
return (FALSE);
}
static bool_t
svc_door_getargs(SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
{
/* LINTED pointer alignment */
return ((*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr));
}
static bool_t
svc_door_freeargs(SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
{
/* LINTED pointer alignment */
XDR *xdrs = &(su_data(xprt)->su_xdrs);
xdrs->x_op = XDR_FREE;
return ((*xdr_args)(xdrs, args_ptr));
}
static void
svc_door_destroy(SVCXPRT *xprt)
{
(void) mutex_lock(&svc_door_mutex);
svc_door_destroy_pvt(xprt);
(void) mutex_unlock(&svc_door_mutex);
}
static void
svc_door_destroy_pvt(SVCXPRT *xprt)
{
/* LINTED pointer alignment */
if (SVCEXT(xprt)->parent)
/* LINTED pointer alignment */
xprt = SVCEXT(xprt)->parent;
/* LINTED pointer alignment */
svc_flags(xprt) |= SVC_DEFUNCT;
/* LINTED pointer alignment */
if (SVCEXT(xprt)->refcnt > 0)
return;
__svc_rm_from_xlist(&dxlist, xprt, NULL);
if (xprt->xp_tp) {
(void) fdetach(xprt->xp_tp);
(void) unlink(xprt->xp_tp);
}
(void) door_revoke(xprt->xp_fd);
svc_xprt_destroy(xprt);
if (--svc_ndoorfds == 0)
/* wake up door dispatching */
(void) cond_signal(&svc_door_waitcv);
}
/* ARGSUSED */
static bool_t
svc_door_control(SVCXPRT *xprt, const uint_t rq, void *in)
{
extern int __rpc_legal_connmaxrec(int);
size_t door_param;
int tmp;
switch (rq) {
case SVCSET_CONNMAXREC:
tmp = __rpc_legal_connmaxrec(*(int *)in);
if (tmp >= 0) {
door_param = (tmp == 0)? SIZE_MAX :
(size_t)(ssize_t)tmp;
if (door_setparam(xprt->xp_fd, DOOR_PARAM_DATA_MAX,
door_param) == 0)
return (TRUE);
return (FALSE);
}
return (FALSE);
case SVCGET_CONNMAXREC:
if (door_getparam(xprt->xp_fd, DOOR_PARAM_DATA_MAX,
&door_param) == 0) {
if (door_param == SIZE_MAX)
tmp = 0;
else if (door_param > INT_MAX)
tmp = INT_MAX;
else if (door_param > 0)
tmp = (int)door_param;
else
return (FALSE);
*(int *)in = tmp;
return (TRUE);
}
return (FALSE);
}
return (FALSE);
}
static struct xp_ops *
svc_door_ops(void)
{
static struct xp_ops ops;
extern mutex_t ops_lock;
(void) mutex_lock(&ops_lock);
if (ops.xp_recv == NULL) {
ops.xp_recv = svc_door_recv;
ops.xp_stat = svc_door_stat;
ops.xp_getargs = svc_door_getargs;
ops.xp_reply = svc_door_reply;
ops.xp_freeargs = svc_door_freeargs;
ops.xp_destroy = svc_door_destroy;
ops.xp_control = svc_door_control;
}
(void) mutex_unlock(&ops_lock);
return (&ops);
}
/*
* Return door credentials.
*/
/* ARGSUSED */
bool_t
__svc_get_door_cred(SVCXPRT *xprt, svc_local_cred_t *lcred)
{
door_cred_t dc;
if (door_cred(&dc) < 0)
return (FALSE);
lcred->euid = dc.dc_euid;
lcred->egid = dc.dc_egid;
lcred->ruid = dc.dc_ruid;
lcred->rgid = dc.dc_rgid;
lcred->pid = dc.dc_pid;
return (TRUE);
}
/* ARGSUSED */
bool_t
__svc_get_door_ucred(const SVCXPRT *xprt, ucred_t *ucp)
{
return (door_ucred(&ucp) == 0);
}