falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/lib/tt/slib/mp_rpc_implement.C

1953 lines
46 KiB
C
Raw Permalink Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
//%% (c) Copyright 1993, 1994 Hewlett-Packard Company
//%% (c) Copyright 1993, 1994 International Business Machines Corp.
//%% (c) Copyright 1993, 1994 Sun Microsystems, Inc.
//%% (c) Copyright 1993, 1994 Novell, Inc.
//%% $TOG: mp_rpc_implement.C /main/9 1999/10/14 18:42:58 mgreess $
/*
* mp_rpc_implement.C 1.40 29 Jul 1993
*
* mp_rpc_implement.cc -- implementation of RPC functions
*
* Copyright (c) 1990,1992 by Sun Microsystems, Inc.
*
* This file implements the RPC wrapper functions for each RPC
* procedure number. The responsibility of each wrapper is to decode and
* encode arguments and results and invoke the right methods
* corresponding to each activity.
*
*/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <fcntl.h>
#include <unistd.h>
#if defined(__linux__) || defined(CSRG_BASED)
/*# include <g++/minmax.h>*/
#else
# include <macros.h>
#endif
#include "tt_options.h"
#include "util/tt_xdr_version.h"
#include <rpc/rpc.h>
#include <limits.h>
#include "mp/mp_global.h"
#include "mp_s_file.h"
#include "mp_s_file_utils.h"
#include "mp/mp_mp.h"
#include "mp_s_mp.h"
#include "mp_s_message.h"
#include "mp_otype.h"
#include "mp_signature.h"
#include "mp/mp_arg.h"
#include "mp_s_msg_context.h"
#include "mp_s_pattern.h"
#include "mp_s_procid.h"
#include "mp/mp_rpc_fns.h"
#include "mp_rpc_implement.h"
#include "mp_s_session.h"
#include "mp/mp_xdr_functions.h"
#include "mp_s_xdr_functions.h"
#include "util/tt_trace.h"
#include "mp_typedb.h"
#if defined(OPT_SECURE_RPC)
static uid_t req_auth_uid;
static gid_t req_auth_gid;
static short req_auth_gidlen;
// authdes_getucred() in 4.x is declared to take int* instead of gid_t*
#if defined(OPT_BUG_SUNOS_4)
static int req_auth_gids[10];
#else
static gid_t req_auth_gids[NGROUPS_MAX];
#endif /* OPT_BUG_SUNOS_4 */
#endif /* OPT_SECURE_RPC */
#if defined(OPT_BUG_SUNOS_4)
# define RPC_ARG_T char *
#else
# define RPC_ARG_T caddr_t
#endif /* OPT_BUG_SUNOS_4 */
#if defined(OPT_BUG_SUNOS_5)
typedef void (*Hack_getucred)(const struct authdes_cred *,
uid_t *,
gid_t *,
short *,
gid_t *);
#endif /* OPT_BUG_SUNOS_5 */
void _tt_rpc_nullproc(SVCXPRT *);
void _tt_rpc_dispatch(SVCXPRT *);
void _tt_rpc_dispatch_with_context(SVCXPRT *);
void _tt_rpc_update_msg(SVCXPRT *);
void _tt_rpc_join_file(SVCXPRT *);
void _tt_rpc_quit_file(SVCXPRT *);
void _tt_rpc_join_session(SVCXPRT *);
void _tt_rpc_quit_session(SVCXPRT *);
void _tt_rpc_join_context(SVCXPRT *);
void _tt_rpc_quit_context(SVCXPRT *);
void _tt_rpc_next_message(SVCXPRT *);
void _tt_rpc_add_pattern(SVCXPRT *);
void _tt_rpc_add_pattern_with_context(SVCXPRT *);
void _tt_rpc_del_pattern(SVCXPRT *);
void _tt_rpc_declare_ptype(SVCXPRT *);
void _tt_rpc_set_fd_channel(SVCXPRT *);
void _tt_rpc_set_prop(SVCXPRT *);
void _tt_rpc_add_prop(SVCXPRT *);
void _tt_rpc_get_prop(SVCXPRT *);
void _tt_rpc_prop_count(SVCXPRT *);
void _tt_rpc_prop_name(SVCXPRT *);
void _tt_rpc_prop_names_count(SVCXPRT *);
void _tt_rpc_alloc_procid_key(SVCXPRT *);
void _tt_rpc_close_procid(SVCXPRT *);
void _tt_rpc_otype_deriveds_count(SVCXPRT *);
void _tt_rpc_otype_derived(SVCXPRT *);
void _tt_rpc_otype_base(SVCXPRT *);
void _tt_rpc_otype_is_derived(SVCXPRT *);
void _tt_rpc_otype_osig_count(SVCXPRT *);
void _tt_rpc_otype_hsig_count(SVCXPRT *);
void _tt_rpc_otype_osig_op(SVCXPRT *);
void _tt_rpc_otype_hsig_op(SVCXPRT *);
void _tt_rpc_otype_osig_args_count(SVCXPRT *);
void _tt_rpc_otype_hsig_args_count(SVCXPRT *);
void _tt_rpc_otype_osig_arg_mode(SVCXPRT *);
void _tt_rpc_otype_hsig_arg_mode(SVCXPRT *);
void _tt_rpc_otype_osig_arg_type(SVCXPRT *);
void _tt_rpc_otype_hsig_arg_type(SVCXPRT *);
void _tt_rpc_hdispatch(SVCXPRT *);
void _tt_rpc_hupdate_msg(SVCXPRT *);
void _tt_rpc_get_omap(SVCXPRT *);
void _tt_rpc_add_omap(SVCXPRT *);
void _tt_rpc_dispatch_2(SVCXPRT *);
void _tt_rpc_dispatch_2_with_context(SVCXPRT *);
void _tt_rpc_update_msg_2(SVCXPRT *);
void _tt_rpc_msgread_2(SVCXPRT *);
void _tt_rpc_vrfy_session(SVCXPRT *);
void _tt_rpc_dispatch_on_exit(SVCXPRT *);
void _tt_rpc_undeclare_ptype(SVCXPRT *);
void _tt_rpc_exists_ptype(SVCXPRT *);
void _tt_rpc_unblock_ptype(SVCXPRT *);
void _tt_rpc_load_types(SVCXPRT *);
typedef void (*_Tt_rpc_stub)(SVCXPRT *);
/*
* Dispatch table for rpc procedures. Note that the position of the
* dispatch functions must correspond to the _Tt_rpc_procedure number
* enum.
*/
const _Tt_rpc_stub _tt_rpc_dispatch_table[TT_RPC_LAST] = {
0, /* 0 - TT_RPC_NULLPROC */
_tt_rpc_dispatch, /* 1 - TT_RPC_DISPATCH */
_tt_rpc_update_msg, /* 2 - TT_RPC_UPDATE_MSG */
_tt_rpc_join_file, /* 3 - TT_RPC_JOIN_FILE */
_tt_rpc_quit_file, /* 4 - TT_RPC_QUIT_FILE */
_tt_rpc_join_session, /* 5 - TT_RPC_JOIN_SESSION */
_tt_rpc_quit_session, /* 6 - TT_RPC_QUIT_SESSION */
_tt_rpc_next_message, /* 7 - TT_RPC_NEXT_MESSAGE */
_tt_rpc_add_pattern, /* 8 - TT_RPC_ADD_PATTERN */
_tt_rpc_del_pattern, /* 9 - TT_RPC_DEL_PATTERN */
_tt_rpc_declare_ptype, /* 10 - TT_RPC_DECLARE_PTYPE */
_tt_rpc_set_fd_channel, /* 11 - TT_RPC_SET_FD_CHANNEL */
_tt_rpc_set_prop, /* 12 - TT_RPC_SET_PROP */
_tt_rpc_add_prop, /* 13 - TT_RPC_ADD_PROP */
_tt_rpc_get_prop, /* 14 - TT_RPC_GET_PROP */
_tt_rpc_prop_count, /* 15 - TT_RPC_PROP_COUNT */
_tt_rpc_prop_name, /* 16 - TT_RPC_PROP_NAME */
_tt_rpc_prop_names_count, /* 17 - TT_RPC_PROP_NAMES_COUNT */
_tt_rpc_alloc_procid_key, /* 18 - TT_RPC_ALLOC_PROCID_KEY */
_tt_rpc_close_procid, /* 19 - TT_RPC_CLOSE_PROCID */
_tt_rpc_otype_deriveds_count, /* 20 - TT_RPC_OTYPE_DERIVEDS_COUNT */
_tt_rpc_otype_derived, /* 21 - TT_RPC_OTYPE_DERIVED */
_tt_rpc_otype_base, /* 22 - TT_RPC_OTYPE_BASE */
_tt_rpc_otype_is_derived, /* 23 - TT_RPC_OTYPE_IS_DERIVED */
_tt_rpc_otype_osig_count, /* 24 - TT_RPC_OTYPE_OSIG_COUNT */
_tt_rpc_otype_hsig_count, /* 25 - TT_RPC_OTYPE_HSIG_COUNT */
_tt_rpc_otype_osig_op, /* 26 - TT_RPC_OTYPE_OSIG_OP */
_tt_rpc_otype_hsig_op, /* 27 - TT_RPC_OTYPE_HSIG_OP */
_tt_rpc_otype_osig_args_count, /* 28 - TT_RPC_OTYPE_OSIG_ARGS_COUNT */
_tt_rpc_otype_hsig_args_count, /* 29 - TT_RPC_OTYPE_HSIG_ARGS_COUNT */
_tt_rpc_otype_osig_arg_mode, /* 30 - TT_RPC_OTYPE_OSIG_ARG_MODE */
_tt_rpc_otype_hsig_arg_mode, /* 31 - TT_RPC_OTYPE_HSIG_ARG_MODE */
_tt_rpc_otype_osig_arg_type, /* 32 - TT_RPC_OTYPE_OSIG_ARG_TYPE */
_tt_rpc_otype_hsig_arg_type, /* 33 - TT_RPC_OTYPE_HSIG_ARG_TYPE */
_tt_rpc_hdispatch, /* 34 - TT_RPC_HDISPATCH */
_tt_rpc_hupdate_msg, /* 35 - TT_RPC_HUPDATE_MSG */
_tt_rpc_dispatch_2, /* 36 - TT_RPC_DISPATCH_2 */
_tt_rpc_update_msg_2, /* 37 - TT_RPC_UPDATE_MSG_2 */
_tt_rpc_msgread_2, /* 38 - TT_RPC_MSGREAD_2 */
_tt_rpc_dispatch_on_exit, /* 39 - TT_RPC_DISPATCH_ON_EXIT */
_tt_rpc_undeclare_ptype, /* 40 - TT_RPC_UNDECLARE_PTYPE */
_tt_rpc_exists_ptype, /* 41 - TT_RPC_EXISTS_PTYPE */
_tt_rpc_unblock_ptype, /* 42 - TT_RPC_UNBLOCK_PTYPE */
_tt_rpc_join_context, /* 43 - TT_RPC_JOIN_CONTEXT */
_tt_rpc_quit_context, /* 44 - TT_RPC_QUIT_CONTEXT */
_tt_rpc_dispatch_with_context, /* 45 - TT_RPC_DISPATCH_WITH_CONTEXT */
_tt_rpc_dispatch_2_with_context,/* 46 - TT_RPC_DISPATCH_2_WITH_CONTEXT */
_tt_rpc_add_pattern_with_context,/* 47 - TT_RPC_ADD_PATTERN_WITH_CONTEXT */
_tt_rpc_load_types /* 48 - TT_RPC_LOAD_TYPES */
};
/*
* Dispatch function invoked whenever an RPC request comes in.
*/
void
_tt_service_rpc(svc_req *rqstp, SVCXPRT *transp)
{
_Tt_auth_level session_auth;
#if defined(OPT_SECURE_RPC)
authdes_cred *des_cred;
#endif
// Increment the counter for the number of RPC calls
// handled during the life of this process.
_tt_global->event_counter++;
//
// authenticate request
//
session_auth = _tt_s_mp->initial_s_session->auth_level();
switch (rqstp->rq_cred.oa_flavor) {
case AUTH_UNIX:
case AUTH_SHORT:
if (session_auth == _TT_AUTH_DES ||
session_auth == _TT_AUTH_ICEAUTH) {
svcerr_auth(transp, AUTH_TOOWEAK);
return;
}
else if (session_auth == _TT_AUTH_UNIX) {
if (_tt_s_mp->unix_cred_chk_flag) {
// "authunix_parms" is now deprecated in
// favor of "authsys_parms", but
// "authsys_parms" does not exist on
// all platforms yet.
authunix_parms* sys_cred =
(authunix_parms *) rqstp->rq_clntcred;
if (sys_cred->aup_uid != geteuid()) {
svcerr_auth(transp, AUTH_BADCRED);
return;
}
}
// else, we are not doing auth checking
}
break;
#if defined(OPT_SECURE_RPC)
case AUTH_DES:
if (session_auth != _TT_AUTH_DES) {
svcerr_auth(transp, AUTH_TOOWEAK);
return;
}
des_cred = (authdes_cred *)rqstp->rq_clntcred;
#if !defined(OPT_BUG_SUNOS_5)
if (! authdes_getucred(des_cred,
&req_auth_uid,
&req_auth_gid,
&req_auth_gidlen,
req_auth_gids)) {
svcerr_auth(transp, AUTH_BADCRED);
}
#else
Hack_getucred hack_getucred_p;
hack_getucred_p = (Hack_getucred)authdes_getucred;
if (! (*hack_getucred_p)(des_cred,
&req_auth_uid,
&req_auth_gid,
&req_auth_gidlen,
req_auth_gids)) {
svcerr_auth(transp, AUTH_BADCRED);
}
#endif /* OPT_BUG_SUNOS_5 */
// Now that we have the credentials, make sure they
// are the right ones
if (req_auth_uid == geteuid() &&
req_auth_gid == getegid()) {
break; // else fall through to svcerr_weakauth
}
#endif /* OPT_SECURE_RPC */
default:
if (session_auth == _TT_AUTH_ICEAUTH) {
_Tt_string clnt_cookie;
if (!_tt_svc_getargs(transp,
(xdrproc_t) tt_xdr_string,
(char *) &clnt_cookie)) {
svcerr_auth(transp, AUTH_BADCRED);
return;
}
const _Tt_string &svr_cookie =
_tt_s_mp->initial_s_session->auth_cookie();
if (clnt_cookie != svr_cookie) {
svcerr_auth(transp, AUTH_BADCRED);
return;
}
}
}
//
// dispatch request to appropiate dispatch function
//
//
// Set and reset xdr version on entry and exit. See tt_xdr_version.h
//
_Tt_xdr_version xvers((int)rqstp->rq_vers);
switch (rqstp->rq_proc) {
case NULLPROC:
(void)svc_sendreply(transp, (xdrproc_t)xdr_void, 0);
break;
case TT_RPC_VRFY_SESSION:
_tt_rpc_vrfy_session(transp);
break;
default:
if (rqstp->rq_proc >= 1 && rqstp->rq_proc < TT_RPC_LAST) {
(*_tt_rpc_dispatch_table[rqstp->rq_proc])(transp);
} else {
svcerr_noproc(transp);
}
break;
}
}
/*
* Called when a sender sends a message to the server.
* This original version of _tt_rpc_dispatch() is a synchronous RPC
* call, and it returns a _Tt_dispatch_reply_args, which contains
* dispatch status and file-scoped queuing info. The new version,
* _tt_rpc_dispatch_2(), is asynchronous and thus faster.
*/
void
_tt_rpc_dispatch(SVCXPRT *transp)
{
_Tt_s_message_ptr msg;
_Tt_dispatch_reply_args args;
msg = new _Tt_s_message();
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_message,
(char *)&msg)) {
svcerr_decode(transp);
return;
}
args.status = TT_OK;
_Tt_msg_trace trace( *msg, TTDR_MESSAGE_SEND );
//
// XXX Turn this off until we do TT_ERR_OVERFLOW right
//
//if (_tt_s_mp->active_messages > _tt_s_mp->max_active_messages)
if (0)
{
args.status = TT_ERR_OVERFLOW;
} else {
// dispatch the message so that any information regarding
// scope, and queueing can be relayed back to the sender.
msg->dispatch( trace );
msg->qmsg_info(args.qmsg_info);
}
if (msg->scope() != TT_SESSION) {
// if no file-scope patterns exist for this file then
// return an error to allow the client to remove this
// session from the file's scope.
if (! _tt_s_mp->in_file_scope(msg->file())) {
args.status = TT_ERR_FILE;
}
}
if (!svc_sendreply(transp,
(xdrproc_t)tt_xdr_dispatch_reply_args,
(RPC_ARG_T)&args)) {
return;
}
if (args.status == TT_OK || args.status == TT_ERR_FILE) {
// now deliver the message
msg->deliver_to_observers_and_handlers( trace );
}
}
/*
* Called when a sender sends a contextful message
* to the server.
*/
void
_tt_rpc_dispatch_with_context(SVCXPRT *transp)
{
//
// In messages, xdr versioning for contexts isn't necessary,
// since a bitmask controls what fields of a _Tt_message get
// xdr'd. This separate RPC call exists only so that
// context-aware clients can tell whether a server understands
// contexts.
//
_tt_rpc_dispatch(transp);
}
/*
* High-performance version of _tt_rpc_dispatch(). No information
* is relayed back to the calling client.
*/
void
_tt_rpc_dispatch_2(SVCXPRT *transp)
{
_Tt_s_message_ptr msg;
msg = new _Tt_s_message();
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_message,
(char *)&msg)) {
svcerr_decode(transp);
return;
}
_Tt_msg_trace trace( *msg, TTDR_MESSAGE_SEND );
msg->dispatch( trace );
// XXX holtz 93/09/17 Should we really deliver() if dispatch() fails?
// Note: this applies to every dispatch() call in this file.
msg->deliver_to_observers_and_handlers( trace );
}
/*
* Called when a sender sends a contextful session-scoped message
* to the server.
*/
void
_tt_rpc_dispatch_2_with_context(SVCXPRT *transp)
{
//
// In messages, xdr versioning for contexts isn't necessary,
// since a bitmask controls what fields of a _Tt_message get
// xdr'd. This separate RPC call exists only so that
// context-aware clients can tell whether a server understands
// contexts.
//
_tt_rpc_dispatch_2(transp);
}
/*
* Called when a handler or voter updates a message in any way (ie. state change)
*/
void
_tt_update_msg(SVCXPRT *transp, int reply)
{
_Tt_s_procid_ptr proc;
Tt_status status;
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_update_args,
(char *)&(_tt_s_mp->update_args))) {
svcerr_decode(transp);
return;
}
int found = 0;
_Tt_message_ptr &msg = _tt_s_mp->update_args.message;
//
// We have to rummage around in the message to see which
// procid is talking to us.
//
if (! msg->handler().is_null()) {
//
// Assume the handler is the updater.
//
found = _tt_s_mp->find_proc(msg->handler(), proc, 0);
} else if (msg->message_class() == TT_OFFER) {
//
// Assume the last voter is the updater.
//
_Tt_procid_list_ptr proc_list;
switch (_tt_s_mp->update_args.newstate) {
case TT_REJECTED:
proc_list = msg->rejecters();
break;
case TT_ACCEPTED:
proc_list = msg->accepters();
break;
case TT_ABSTAINED:
proc_list = msg->abstainers();
break;
}
if ((! proc_list.is_null()) && (proc_list->count() > 0)) {
found = _tt_s_mp->find_proc(proc_list->bot(), proc, 0);
}
}
if (found) {
status = TT_OK;
} else {
status = TT_ERR_PROCID;
}
if (reply && (! svc_sendreply(transp, (xdrproc_t)xdr_int,
(RPC_ARG_T)&status)))
{
return;
}
if (status != TT_OK) {
return;
}
if (msg->is_observer()) {
// Clears _handler when observer replies to START_MESSAGE
// XXX _handler is used to tell us which procid is talking
// to us, because nothing in the message tells us who
// is observing it. Ugly.
msg->clr_observer_procid();
}
proc->update_message(msg, _tt_s_mp->update_args.newstate);
}
/*
* Called when a handler updates a message in any way (ie. state change)
*/
void
_tt_rpc_update_msg(SVCXPRT *transp)
{
_tt_update_msg(transp, 1);
}
/*
* Asynchronous, higher-performance version of _tt_rpc_update_msg()
*/
void
_tt_rpc_update_msg_2(SVCXPRT *transp)
{
_tt_update_msg(transp, 0);
}
/*
* Called when a process joins a file.
*/
void
_tt_rpc_join_file(SVCXPRT *transp)
{
_Tt_file_join_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
_Tt_s_file_ptr fptr;
if (! _tt_svc_getargs(transp, (xdrproc_t)tt_xdr_file_join_args,
(char *)&args)) {
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
fptr = new _Tt_s_file(args.path);
status = fptr->s_join(proc);
} else {
status = TT_ERR_PROCID;
}
(void)svc_sendreply(transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status);
}
/*
* Called when a process quits a file.
*/
void
_tt_rpc_quit_file(SVCXPRT *transp)
{
_Tt_file_join_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
_Tt_s_file_ptr fptr;
if (! _tt_svc_getargs(transp, (xdrproc_t)tt_xdr_file_join_args,
(char *)&args)) {
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
fptr = new _Tt_s_file(args.path);
status = fptr->s_quit(proc);
} else {
status = TT_ERR_PROCID;
}
(void)svc_sendreply(transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status);
}
/*
* Called when a procid joins a session.
*/
void
_tt_rpc_join_session(SVCXPRT *transp)
{
_Tt_procid_ptr cproc;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_procid,
(char *)&cproc)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(cproc, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
if (cproc->start_token().len() != 0) {
sp->set_start_token(cproc->start_token());
}
status = _tt_s_mp->initial_s_session->s_join(proc);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called when a procid quits a session.
*/
void
_tt_rpc_quit_session(SVCXPRT *transp)
{
_Tt_procid_ptr cproc;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_procid,
(char *)&cproc)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(cproc, proc, 1)) {
status = _tt_s_mp->initial_s_session->s_quit(proc);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called when a procid wants to join a context.
*/
void
_tt_rpc_join_context(SVCXPRT *transp)
{
_Tt_context_join_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs( transp, (xdrproc_t)tt_xdr_context_join_args,
(char *)&args))
{
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc( args.procid, proc, 1 )) {
status = ((_Tt_s_msg_context &)*args.context).s_join( proc );
} else {
status = TT_ERR_PROCID;
}
svc_sendreply( transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status );
}
/*
* Called when a procid wants to quit a context.
*/
void
_tt_rpc_quit_context(SVCXPRT *transp)
{
_Tt_context_join_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs( transp, (xdrproc_t)tt_xdr_context_join_args,
(char *)&args))
{
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc( args.procid, proc, 1 )) {
status = ((_Tt_s_msg_context &)*args.context).s_quit( proc );
} else {
status = TT_ERR_PROCID;
}
svc_sendreply( transp, (xdrproc_t)xdr_int, (RPC_ARG_T)&status );
}
/*
* Called when a procid wants to retrieve the next undelivered message
* for it.
*/
void
_tt_rpc_next_message(SVCXPRT *transp)
{
_Tt_procid_ptr cproc;
_Tt_next_message_args args;
_Tt_s_procid_ptr proc;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_procid,
(char *)&cproc)) {
svcerr_decode(transp);
return;
}
// default is to tell client to clear fd, that way in case of
// any errors, at least the client won't loop.
args.clear_signal = 1;
args.msgs = (_Tt_message_list *)0;
if (_tt_s_mp->find_proc(cproc, proc, 0)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
sp->next_message(args);
}
if (svc_sendreply(transp,
(xdrproc_t)tt_xdr_next_message_args,
(RPC_ARG_T)&args) == 0) {
return;
}
}
/*
* Called when a procid wants to register a new pattern.
*/
void
_tt_rpc_add_pattern(SVCXPRT *transp)
{
_Tt_s_procid_ptr proc;
_Tt_s_add_pattern_args args;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_s_xdr_add_pattern_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->add_pattern(args.pattern);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called when a procid wants to register a new context-ful pattern.
*/
void
_tt_rpc_add_pattern_with_context(SVCXPRT *transp)
{
//
// Contexts are only xdr'd in _Tt_patterns in xdr version 3 or
// later. The rpc protocol version number represents a floor
// for the xdr version number. Even though this rpc call was
// introduced into protocol version 2, it can be assumed that
// the caller is using at least xdr version 3.
//
// _Tt_xdr_version xvers( max(_tt_global->xdr_version(),
// TT_CONTEXTS_XDR_VERSION) );
if(_tt_global->xdr_version() > TT_CONTEXTS_XDR_VERSION) {
_Tt_xdr_version xvers(_tt_global->xdr_version() );
} else {
_Tt_xdr_version xvers(TT_CONTEXTS_XDR_VERSION);
}
_tt_rpc_add_pattern(transp);
}
/*
* Called when a procid wants to unregister a pattern with the server.
*/
void
_tt_rpc_del_pattern(SVCXPRT *transp)
{
_Tt_s_procid_ptr proc;
_Tt_s_del_pattern_args args;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_s_xdr_del_pattern_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->del_pattern(args.pattern_id);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to declare a ptype.
*/
void
_tt_rpc_declare_ptype(SVCXPRT *transp)
{
_Tt_declare_ptype_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_declare_ptype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->declare_ptype(args.ptid);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to undeclare a ptype.
*/
void
_tt_rpc_undeclare_ptype(SVCXPRT *transp)
{
_Tt_declare_ptype_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_declare_ptype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->undeclare_ptype(args.ptid);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to test existence of a ptype.
*/
void
_tt_rpc_exists_ptype(SVCXPRT *transp)
{
_Tt_declare_ptype_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_declare_ptype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->exists_ptype(args.ptid);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to unblock queued messages for its ptype.
*/
void
_tt_rpc_unblock_ptype(SVCXPRT *transp)
{
_Tt_declare_ptype_args args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_declare_ptype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(args.procid, proc, 1)) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
status = sp->unblock_ptype(args.ptid);
} else {
status = TT_ERR_PROCID;
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to load new types into its associated ttsession.
*/
void
_tt_rpc_load_types(SVCXPRT *transp)
{
_Tt_load_types_args args;
Tt_status status;
XDR xdrs;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_load_types_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
xdrmem_create(&xdrs,
(char *)args.xdrtypes,
(u_int)args.xdrtypes.len(),
XDR_DECODE);
int junk;
status = _Tt_typedb::merge_from(&xdrs,_tt_s_mp->tdb, junk);
if (status==TT_OK) {
_tt_s_mp->install_ptable(_tt_s_mp->tdb->ptable);
_tt_s_mp->install_otable(_tt_s_mp->tdb->otable);
}
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Called by a procid to notify the server of its fd signalling channel.
*/
void
_tt_rpc_set_fd_channel(SVCXPRT *transp)
{
_Tt_fd_args fd_args;
_Tt_s_procid_ptr proc;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_fd_args,
(char *)&fd_args)) {
svcerr_decode(transp);
return;
}
if (_tt_s_mp->find_proc(fd_args.procid, proc, 1)) {
status = TT_OK;
} else {
status = TT_ERR_PROCID;
}
//
// Note: it's important to reply immediately here because
// setting up the channel involves connecting to the socket
// on the client side so if we attempted to reply after
// the operation then we would get deadlock.
//
if (svc_sendreply(transp,
(xdrproc_t)xdr_int,
(RPC_ARG_T)&status) == 0) {
return;
}
if (status == TT_OK) {
_Tt_s_procid *sp = (_Tt_s_procid *)proc.c_pointer();
sp->set_start_token(fd_args.start_token);
sp->set_fd_channel(fd_args.fd);
}
}
/*
* Set the value of a session property
*/
void
_tt_rpc_set_prop(SVCXPRT *transp)
{
_Tt_prop_args args;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
status = _tt_s_mp->initial_s_session->s_setprop(args.prop, args.value);
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Add a value to a session property
*/
void
_tt_rpc_add_prop(SVCXPRT *transp)
{
_Tt_prop_args args;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
status = _tt_s_mp->initial_s_session->s_addprop(args.prop, args.value);
if (svc_sendreply(transp,(xdrproc_t)xdr_int,(RPC_ARG_T)&status) == 0) {
return;
}
}
/*
* Get a value from a session property
*/
void
_tt_rpc_get_prop(SVCXPRT *transp)
{
_Tt_prop_args args;
Tt_status status;
_Tt_string value;
_Tt_rpc_result result;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if ((status = _tt_s_mp->initial_s_session->s_getprop(args.prop, args.num, value))
!= TT_OK) {
result.status = status;
result.str_val = "";
result.int_val = 0;
} else {
result.status = TT_OK;
result.str_val = value;
result.int_val = 0;
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of values for a session property
*/
void
_tt_rpc_prop_count(SVCXPRT *transp)
{
_Tt_prop_args args;
int cnt;
_Tt_rpc_result result;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = _tt_s_mp->initial_s_session->s_propcount(args.prop, cnt);
result.str_val = "";
if (result.status == TT_OK) {
result.int_val = cnt;
} else {
result.int_val = 0;
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return a session property name
*/
void
_tt_rpc_prop_name(SVCXPRT *transp)
{
_Tt_prop_args args;
Tt_status status;
_Tt_string prop;
_Tt_rpc_result result;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
if ((status = _tt_s_mp->initial_s_session->s_propname(args.num, prop))
!= TT_OK) {
result.status = status;
result.str_val = "";
result.int_val = 0;
} else {
result.status = TT_OK;
result.str_val = prop;
result.int_val = 0;
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of session properties
*/
void
_tt_rpc_prop_names_count(SVCXPRT *transp)
{
_Tt_prop_args args;
int cnt;
_Tt_rpc_result result;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_prop_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = _tt_s_mp->initial_s_session->s_propnames_count(cnt);
result.str_val = "";
if (result.status == TT_OK) {
result.int_val = cnt;
} else {
result.int_val = 0;
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
void
_tt_rpc_alloc_procid_key(SVCXPRT *transp)
{
_Tt_string result;
if (! _tt_svc_getargs(transp,(xdrproc_t)xdr_void,0)) {
svcerr_decode(transp);
return;
}
result = _tt_s_mp->alloc_procid_key();
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_string,
(RPC_ARG_T)&result) == 0) {
return;
}
}
void
_tt_rpc_close_procid(SVCXPRT *transp)
{
_Tt_procid_ptr p;
_Tt_s_procid_ptr rp;
Tt_status status;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_procid,
(char *)&p)) {
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc(p, rp, 0)) {
status = _tt_s_mp->s_remove_procid(*rp);
} else {
status = TT_ERR_PROCID;
}
(void)svc_sendreply(transp,(xdrproc_t)xdr_int, (RPC_ARG_T)&status);
}
void
_tt_rpc_vrfy_session(SVCXPRT *transp)
{
_Tt_string id;
if (! _tt_svc_getargs(transp, (xdrproc_t)xdr_void, 0)) {
svcerr_decode(transp);
return;
}
if (_tt_global->xdr_version() == 1) {
id = _tt_s_mp->initial_s_session->id();
} else {
id = _tt_s_mp->initial_s_session->process_tree_id();
}
if (!svc_sendreply(transp,
(xdrproc_t)tt_xdr_string,
(RPC_ARG_T)&id)) {
svcerr_decode(transp);
}
}
/*
* Return the number of otypes derived from a base otype
*/
void
_tt_rpc_otype_deriveds_count(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr base_otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.str_val = "";
base_otype = _tt_s_mp->otable->lookup(args.base_otid);
if (base_otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
result.int_val = base_otype->children()->count();
result.status = TT_OK;
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the n'th otype derived from a base otype
*/
void
_tt_rpc_otype_derived(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_string_list_ptr children;
_Tt_otype_ptr base_otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.str_val = "";
base_otype = _tt_s_mp->otable->lookup(args.base_otid);
if (base_otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
children = base_otype->children();
if (args.num<0 || children->count()<args.num) {
result.status = TT_ERR_NUM;
result.str_val = "";
} else if (children->count()==args.num) {
result.status = TT_OK;
result.str_val = (char *)0;
} else {
result.status = TT_OK;
result.str_val = (*children)[args.num];
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the otype that is the base of a derived otype
*/
void
_tt_rpc_otype_base(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_string_list_ptr parents;
_Tt_otype_ptr derived_otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
derived_otype = _tt_s_mp->otable->lookup(args.derived_otid);
if (derived_otype.is_null()) {
result.str_val = (char *)0;
result.status = TT_ERR_OTYPE;
} else {
parents = derived_otype->parents();
if (parents.is_null() || parents->is_empty()) {
result.status = TT_OK;
result.str_val = (char *)0;
} else {
result.status = TT_OK;
result.str_val = parents->top();
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return 1 iff the derived otype derives directly or indirectly from the
* base otype.
*/
void
_tt_rpc_otype_is_derived(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_string_list_ptr parents;
_Tt_otype_ptr derived_otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
if (args.derived_otid==args.base_otid) {
result.int_val = 1;
} else {
derived_otype = _tt_s_mp->otable->lookup(args.derived_otid);
if (derived_otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
parents = derived_otype->parents();
result.int_val = 0;
_Tt_otype_ptr parent;
while (!parents->is_empty()) {
parent = _tt_s_mp->otable->
lookup(parents->top());
if (parent.is_null()) {
break;
} else if (parent->otid()==args.base_otid) {
result.int_val = 1;
break;
} else {
parents = parent->parents();
}
}
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of observer signatures for the specified otype
*/
void
_tt_rpc_otype_osig_count(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->osigs();
result.int_val = sigs->count();
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of handler signatures for the specified otype
*/
void
_tt_rpc_otype_hsig_count(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->hsigs();
result.int_val = sigs->count();
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the op for an observer signature of an otype
*/
void
_tt_rpc_otype_osig_op(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->osigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
result.str_val = sig->op();
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the op for a handler signature of an otype
*/
void
_tt_rpc_otype_hsig_op(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->hsigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
result.str_val = sig->op();
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of arguments of an observer signature of an otype
*/
void
_tt_rpc_otype_osig_args_count(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->osigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
result.int_val = sargs->count();
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the number of arguments of a handler signature of an otype
*/
void
_tt_rpc_otype_hsig_args_count(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->hsigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
result.int_val = sargs->count();
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the mode of the specified arg of an observer signature of an otype
*/
void
_tt_rpc_otype_osig_arg_mode(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->osigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
if (args.num2 < 0 || args.num2 >= sargs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_arg_ptr sarg = (*sargs)[args.num2];
result.int_val = (int)sarg->mode();
}
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the mode of the specified arg of a handler signature of an otype
*/
void
_tt_rpc_otype_hsig_arg_mode(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->hsigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
if (args.num2 < 0 || args.num2 >= sargs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_arg_ptr sarg = (*sargs)[args.num2];
result.int_val = (int)sarg->mode();
}
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the type of the specified arg of an observer signature of an otype
*/
void
_tt_rpc_otype_osig_arg_type(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->osigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
if (args.num2 < 0 || args.num2 >= sargs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_arg_ptr sarg = (*sargs)[args.num2];
result.str_val = sarg->type();
}
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
/*
* Return the type of the specified arg of a handler signature of an otype
*/
void
_tt_rpc_otype_hsig_arg_type(SVCXPRT *transp)
{
_Tt_otype_args args;
_Tt_rpc_result result;
_Tt_otype_ptr otype;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_otype_args,
(char *)&args)) {
svcerr_decode(transp);
return;
}
result.status = TT_OK;
result.str_val = "";
result.int_val = 0;
otype = _tt_s_mp->otable->lookup(args.base_otid);
if (otype.is_null()) {
result.status = TT_ERR_OTYPE;
} else {
_Tt_signature_list_ptr sigs = otype->hsigs();
if (args.num < 0 || args.num >= sigs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_signature_ptr sig = (*sigs)[args.num];
_Tt_arg_list_ptr sargs = sig->args();
if (args.num2 < 0 || args.num2 >= sargs->count()) {
result.status = TT_ERR_NUM;
} else {
_Tt_arg_ptr sarg = (*sargs)[args.num2];
result.str_val = sarg->type();
}
}
}
if (svc_sendreply(transp, (xdrproc_t)tt_xdr_rpc_result,
(RPC_ARG_T)&result) == 0) {
return;
}
}
//
// Horizontal (inter-ttsession) dispatch
//
void
_tt_rpc_hdispatch(SVCXPRT *transp)
{
_Tt_s_message_ptr msg;
_Tt_qmsg_info_ptr qm = (_Tt_qmsg_info *)0;
_Tt_dispatch_reply_args args;
msg = new _Tt_s_message();
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_message,
(char *)&msg)) {
svcerr_decode(transp);
return;
}
_Tt_msg_trace trace( *msg, TTDR_HDISPATCH );
(void)msg->dispatch( trace );
(void)msg->deliver_to_observers_and_handlers( trace );
}
//
// Horizontal (inter-ttsession) update
//
void
_tt_rpc_hupdate_msg(SVCXPRT *transp)
{
_Tt_s_procid_ptr sender;
_Tt_s_update_args args;
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_s_xdr_update_args,
(char *)&args))
{
svcerr_decode(transp);
return;
}
if (! _tt_s_mp->find_proc(args.message->sender(), sender, 0)) {
return;
}
if ( (args.newstate == TT_FAILED)
&& (args.message->status() == TT_ERR_NO_MATCH)
&& (args.message->handler().is_null()))
{
//
// No remote session could find a handler.
// Simulate a rejection, and redeliver the message.
// _tried prevents re-offers, but any new handler
// will get a crack at the request, which is nice.
// _rsessions will be empty, so if we again find no
// handler, we will perform disposition instead of
// hdispatch()ing to remote sessions.
//
args.message->set_state(TT_SENT);
args.message->set_status((int)TT_OK);
_Tt_msg_trace trace( *args.message, TTDR_HUPDATE );
if (args.message->indoctrinate( trace ) == TT_OK) {
args.message->change_state( 0, TT_REJECTED, trace );
}
} else {
args.message->set_state(args.newstate);
// Tracing occurs inside ::add_message()
sender->add_message(args.message);
}
}
void
_tt_rpc_msgread_2(SVCXPRT *transp)
{
#ifdef OPT_ADDMSG_DIRECT
_Tt_procid_ptr p;
_Tt_s_procid_ptr rp;
if (! _tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_procid,
(char *)&p)) {
svcerr_decode(transp);
}
if (_tt_s_mp->find_proc(p, rp, 0)) {
rp->msgread();
}
#else
svcerr_noproc(transp);
#endif // OPT_ADDMSG_DIRECT
}
/*
* Called when a sender sends a message to the server for delivery on exit.
*/
void
_tt_rpc_dispatch_on_exit(SVCXPRT *transp)
{
_Tt_s_message_ptr msg;
_Tt_s_procid_ptr proc;
_Tt_dispatch_reply_args args;
msg = new _Tt_s_message();
if (!_tt_svc_getargs(transp,
(xdrproc_t)tt_xdr_message,
(char *)&msg)) {
svcerr_decode(transp);
return;
}
args.status = TT_OK;
if (_tt_s_mp->find_proc(msg->sender(),proc, 0)) {
(void)proc->add_on_exit_message(msg);
} else {
args.status = TT_ERR_PROCID;
}
if (!svc_sendreply(transp,
(xdrproc_t)tt_xdr_dispatch_reply_args,
(RPC_ARG_T)&args)) {
return;
}
}
Reference in New Issue View Git Blame Copy Permalink