/*
* Top level client creation routine.
* Generic client creation: takes (servers name, program-number, nettype) and
* returns client handle. Default options are set, which the user can
* change using the rpc equivalent of _ioctl()'s.
*
* It tries for all the netids in that particular class of netid until
* it succeeds.
* XXX The error message in the case of failure will be the one
* pertaining to the last create error.
*
* It calls clnt_create_timed() with the default timeout.
*/
CLIENT *
clnt_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,
const char *nettype)
{
return (clnt_create_timed(hostname, prog, vers, nettype, NULL));
}
/*
* This the routine has the same definition as clnt_create_vers(),
* except it takes an additional timeout parameter - a pointer to
* a timeval structure. A NULL value for the pointer indicates
* that the default timeout value should be used.
*/
CLIENT *
clnt_create_vers_timed(const char *hostname, const rpcprog_t prog,
rpcvers_t *vers_out, const rpcvers_t vers_low_in, const rpcvers_t vers_high_in,
const char *nettype, const struct timeval *tp)
{
CLIENT *clnt;
struct timeval to;
enum clnt_stat rpc_stat;
struct rpc_err rpcerr;
rpcvers_t vers_high = vers_high_in;
rpcvers_t vers_low = vers_low_in;
clnt = clnt_create_timed(hostname, prog, vers_high, nettype, tp);
if (clnt == NULL) {
return (NULL);
}
to.tv_sec = 10;
to.tv_usec = 0;
rpc_stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void,
(char *)NULL, (xdrproc_t)xdr_void, (char *)NULL, to);
if (rpc_stat == RPC_SUCCESS) {
*vers_out = vers_high;
return (clnt);
}
while (rpc_stat == RPC_PROGVERSMISMATCH && vers_high > vers_low) {
unsigned int minvers, maxvers;
clnt_geterr(clnt, &rpcerr);
minvers = rpcerr.re_vers.low;
maxvers = rpcerr.re_vers.high;
if (maxvers < vers_high)
vers_high = maxvers;
else
vers_high--;
if (minvers > vers_low)
vers_low = minvers;
if (vers_low > vers_high) {
goto error;
}
CLNT_CONTROL(clnt, CLSET_VERS, (char *)&vers_high);
rpc_stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void,
(char *)NULL, (xdrproc_t)xdr_void,
(char *)NULL, to);
if (rpc_stat == RPC_SUCCESS) {
*vers_out = vers_high;
return (clnt);
}
}
clnt_geterr(clnt, &rpcerr);
error:
rpc_createerr.cf_stat = rpc_stat;
rpc_createerr.cf_error = rpcerr;
clnt_destroy(clnt);
return (NULL);
}
/*
* Top level client creation routine.
* Generic client creation: takes (servers name, program-number, nettype) and
* returns client handle. Default options are set, which the user can
* change using the rpc equivalent of _ioctl()'s.
*
* It tries for all the netids in that particular class of netid until
* it succeeds.
* XXX The error message in the case of failure will be the one
* pertaining to the last create error.
*
* It calls clnt_create_timed() with the default timeout.
*/
CLIENT *
clnt_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,
const char *nettype)
{
/* MODIFIED by dwyane @ 2010-12-21 */
if(!strcmp(nettype, "rdma"))
return(clnt_rdma_create(hostname, prog, vers));
/* END */
return (clnt_create_timed(hostname, prog, vers, nettype, NULL));
}
int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// other arguments depend on test case
//run_mode can switch into stand alone program or program launch by shell script
//1 : stand alone, debug mode, more screen information
//0 : launch by shell script as test case, only one printf -> result status
int run_mode = 0;
int test_status = 0; //Default test result set to PASS
int progNum = atoi(argc[2]);
int i;
params paramList[NBCASE];
char nettype[16] = "visible";
CLIENT *clnt = NULL;
struct timeval tv;
//Test initialization
paramList[0].init_tout = 1;
paramList[0].next_tout = 1;
//Call tested function using all tests cases
for (i = 0; i < NBCASE; i++) {
//Debug mode prints
if (run_mode == 1) {
printf("Test using values : %d ",
paramList[i].init_tout);
printf("%d", paramList[i].next_tout);
printf("\n");
}
//Call function
tv.tv_sec = paramList[i].init_tout;
tv.tv_usec = paramList[i].next_tout;
clnt =
clnt_create_timed(argc[1], progNum, VERSNUM, nettype, &tv);
//Check result
if (clnt == NULL) {
//test has failed
test_status = 1;
break;
}
}
//This last printf gives the result status to the tests suite
//normally should be 0: test has passed or 1: test has failed
printf("%d\n", test_status);
return test_status;
}
int
callaurpc(char *host, int prognum, int versnum, int procnum,
xdrproc_t inproc, char *in, xdrproc_t outproc, char *out)
{
static enum clnt_stat clnt_stat;
struct timeval tottimeout = {20, 0};
static CLIENT *cl = NULL;
static int oldprognum, oldversnum;
static char oldhost[MAXHOSTNAMELEN+1];
/*
* Cache the client handle in case there are lots
* of entries in the /etc/mnttab for the same
* server. If the server returns an error, don't
* make further calls.
*/
if (cl == NULL || oldprognum != prognum || oldversnum != versnum ||
strcmp(oldhost, host) != 0) {
if (cl) {
clnt_destroy(cl);
cl = NULL;
}
cl = clnt_create_timed(host, prognum, versnum, "udp",
&tottimeout);
if (cl == NULL)
return ((int)RPC_TIMEDOUT);
if ((cl->cl_auth = authunix_create_default()) == NULL) {
clnt_destroy(cl);
return (RPC_CANTSEND);
}
oldprognum = prognum;
oldversnum = versnum;
(void) strlcpy(oldhost, host, sizeof (oldhost));
clnt_stat = RPC_SUCCESS;
}
if (clnt_stat != RPC_SUCCESS)
return ((int)clnt_stat); /* don't bother retrying */
clnt_stat = clnt_call(cl, procnum, inproc, in,
outproc, out, tottimeout);
return ((int)clnt_stat);
}
static void *
do_one(void *arg)
{
char *hostname = arg;
CLIENT *clnt;
struct timeval tp;
void *vp = NULL;
#ifdef DEBUG
(void) mutex_lock(&tty);
(void) fprintf(stderr, "sending message to %s\n%s\n", hostname, path);
(void) mutex_unlock(&tty);
return (0);
#endif
tp.tv_sec = PATIENCE;
tp.tv_usec = 0;
clnt = clnt_create_timed(
hostname, WALLPROG, WALLVERS, "datagram_v", &tp);
if (clnt == NULL) {
if (!qflag) {
(void) mutex_lock(&tty);
(void) fprintf(stderr, "rwall: Can't send to %s\n",
hostname);
clnt_pcreateerror(hostname);
(void) mutex_unlock(&tty);
}
goto errout;
}
if (wallproc_wall_1(&path, vp, clnt) != RPC_SUCCESS) {
if (!qflag) {
(void) mutex_lock(&tty);
clnt_perror(clnt, hostname);
(void) mutex_unlock(&tty);
}
}
clnt_destroy(clnt);
errout:
(void) mutex_lock(&thr_mtx);
thread_count--;
(void) mutex_unlock(&thr_mtx);
free(hostname);
return (0);
}
int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// other arguments depend on test case
//run_mode can switch into stand alone program or program launch by shell script
//1 : stand alone, debug mode, more screen information
//0 : launch by shell script as test case, only one printf -> result status
int run_mode = 0;
int test_status = 1; //Default test result set to FAILED
int progNum = atoi(argc[2]);
char nettype[16] = "visible";
CLIENT *clnt = NULL;
struct timeval tv;
if (run_mode == 1)
{
printf("Server : %s\n", argc[1]);
printf("Server # %d\n", progNum);
printf("Net : %s\n", nettype);
printf("Client : %d\n", (CLIENT *)clnt);
}
tv.tv_sec = 1;
tv.tv_usec = 1;
clnt = clnt_create_timed(argc[1], progNum, VERSNUM, nettype, &tv);
if (run_mode == 1)
{
printf("Client after creation : %d\n", (CLIENT *)clnt);
}
test_status = ((CLIENT *)clnt != NULL) ? 0 : 1;
//This last printf gives the result status to the tests suite
//normally should be 0: test has passed or 1: test has failed
printf("%d\n", test_status);
return test_status;
}
int
get_handle(int nodeid, int diskid, int mapid, fhandle3 *filehandle)
{
CLIENT *clnt = NULL;
int error = 0;
char nodeAddr[32];
char *diskPath = NULL;
diskPath = (char*)malloc(MNTPATHLEN);
if (!diskPath) {
return(1);
}
snprintf(nodeAddr, sizeof(nodeAddr), "%s.%d", INTERNAL_SUBNET, nodeid + NODEBASEID);
encode_path(diskid, mapid, diskPath, MNTPATHLEN);
clnt = clnt_create_timed(nodeAddr, MOUNT_PROGRAM, MOUNT_V3, "udp", &HCRPC_TIMEOUT);
if (!clnt) {
free(diskPath);
log_error("clnt_create failed(%d, %d)", nodeid, diskid);
return(1);
}
error = single_mount(clnt, diskPath, filehandle);
if (clnt) {
clnt_destroy(clnt);
clnt = NULL;
}
if (diskPath) {
free(diskPath);
diskPath = NULL;
}
return(error);
}
/* get the best possible NFS version for a host and transport */
static CLIENT *
amu_clnt_create_best_vers(const char *hostname, u_long program, u_long *out_version, u_long low_version, u_long high_version, const char *nettype)
{
CLIENT *clnt;
enum clnt_stat rpc_stat;
struct rpc_err rpcerr;
struct timeval tv;
u_long lo, hi;
/* 3 seconds is more than enough for a LAN */
tv.tv_sec = 3;
tv.tv_usec = 0;
#ifdef HAVE_CLNT_CREATE_TIMED
clnt = clnt_create_timed(hostname, program, high_version, nettype, &tv);
if (!clnt) {
plog(XLOG_INFO, "failed to create RPC client to \"%s\" after %d seconds",
hostname, (int) tv.tv_sec);
return NULL;
}
#else /* not HAVE_CLNT_CREATE_TIMED */
/* Solaris 2.3 and earlier didn't have clnt_create_timed() */
clnt = clnt_create(hostname, program, high_version, nettype);
if (!clnt) {
plog(XLOG_INFO, "failed to create RPC client to \"%s\"", hostname);
return NULL;
}
#endif /* not HAVE_CLNT_CREATE_TIMED */
rpc_stat = clnt_call(clnt,
NULLPROC,
(XDRPROC_T_TYPE) xdr_void,
NULL,
(XDRPROC_T_TYPE) xdr_void,
NULL,
tv);
if (rpc_stat == RPC_SUCCESS) {
*out_version = high_version;
return clnt;
}
while (low_version < high_version) {
if (rpc_stat != RPC_PROGVERSMISMATCH)
break;
clnt_geterr(clnt, &rpcerr);
lo = rpcerr.re_vers.low;
hi = rpcerr.re_vers.high;
if (hi < high_version)
high_version = hi;
else
high_version--;
if (lo > low_version)
low_version = lo;
if (low_version > high_version)
goto out;
CLNT_CONTROL(clnt, CLSET_VERS, (char *)&high_version);
rpc_stat = clnt_call(clnt,
NULLPROC,
(XDRPROC_T_TYPE) xdr_void,
NULL,
(XDRPROC_T_TYPE) xdr_void,
NULL,
tv);
if (rpc_stat == RPC_SUCCESS) {
*out_version = high_version;
return clnt;
}
}
clnt_geterr(clnt, &rpcerr);
out:
rpc_createerr.cf_stat = rpc_stat;
rpc_createerr.cf_error = rpcerr;
clnt_destroy(clnt);
return NULL;
}
_Tt_db_results _Tt_db_client::connectToDB (const _Tt_string &hostname)
{
_tt_auth_level_results *auth_level_results = (_tt_auth_level_results *)NULL;
int _socket;
_socket = -1;
dbHostname = hostname;
// Connect to the dbserver on the specified host.
// If we don't have TI_RPC we cannot depend on CLGET_FD, so
// we have to use clnttcp_create so that we get the socket FD back
// in order to set close_on_exec.
#if defined(OPT_TLI)
#ifdef OPT_HAS_CLNT_CREATE_TIMED
struct timeval tv = { OPT_CLNT_CREATE_TIMEOUT, 0};
dbServer = clnt_create_timed((char *)dbHostname,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
(char *)TT_DB_RPC_PROTO,
&tv);
#else
dbServer = clnt_create((char *)dbHostname,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
(char *)TT_DB_RPC_PROTO);
#endif
if (dbServer) {
clnt_control(dbServer, CLGET_FD, (char *)&_socket);
}
#else
struct sockaddr_in server_addr;
struct hostent *host_ret;
_Xgethostbynameparams host_buf;
memset((char*) &host_buf, 0, sizeof(_Xgethostbynameparams));
if ((host_ret = _XGethostbyname((char *)dbHostname, host_buf)) != NULL) {
_socket = RPC_ANYSOCK;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(0);
memcpy(&server_addr.sin_addr.s_addr,
*(host_ret->h_addr_list),
sizeof(server_addr.sin_addr.s_addr));
dbServer = clnttcp_create(&server_addr,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
&_socket,
0, 0);
} else {
// gethostbyname failed, fake RPC error
dbServer = 0;
rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
}
#endif
// Connection failed.
if (!dbServer) {
_tt_syslog(0, LOG_ERR, catgets(_ttcatd, 1, 3,
"clnt_create for rpc.ttdbserverd on %s failed%s"),
(char *)dbHostname, clnt_spcreateerror(""));
// Set dbConnectionResults data member...
SetError(rpc_createerr.cf_stat);
return dbConnectionResults;
}
// Connection succeeded.
clnt_control(dbServer, CLSET_TIMEOUT, (char *)&TT_DB_RPC_QUICK_TIMEOUT);
dbConnectionResults = TT_DB_ERR_DB_CONNECTION_FAILED; // Default value.
for (;dbVersion > 0; dbVersion--) {
if (dbVersion > 1) {
auth_level_results =
_tt_get_min_auth_level_1 ((void *)NULL, dbServer);
} else {
// If dbVersion == 1, then we are talking to an old DB server
static _tt_auth_level_results results;
char *path = "";
clnt_stat rpc_status;
int *result = (int *)NULL;
result = _tt_min_auth_level_1(&path, dbServer, &rpc_status);
if (result) {
results.results = TT_DB_OK;
results.auth_level = *result;
auth_level_results = &results;
}
}
if ((auth_level_results) && (auth_level_results->results == TT_DB_OK)) {
clnt_control(dbServer, CLSET_TIMEOUT,
(char *)&TT_DB_RPC_NORMAL_TIMEOUT);
dbAuthLevel = auth_level_results->auth_level;
dbConnectionResults = TT_DB_OK; // Default return value.
switch (dbAuthLevel) {
case AUTH_NONE:
case AUTH_UNIX:
dbServer->cl_auth = authunix_create_default();
break;
#ifdef OPT_SECURE_RPC
case AUTH_DES: {
char server_net_name [MAXNETNAMELEN+1];
struct hostent *host_ret;
_Xgethostbynameparams host_buf;
if (host2netname(server_net_name, dbHostname, 0) &&
((host_ret = _XGethostbyname((char *)dbHostname, host_buf)) != NULL)) {
#ifdef OPT_TLI
dbServerNetName = server_net_name;
#else
memcpy((caddr_t) &dbSocket.sin_addr,
host_ret->h_addr,
host_ret->h_length);
dbSocket.sin_family = AF_INET;
dbSocket.sin_port = 0;
#endif
} else {
dbConnectionResults =
TT_DB_ERR_DB_CONNECTION_FAILED;
}
}
break;
#endif // OPT_SECURE_RPC
default:
dbConnectionResults =
TT_DB_ERR_DB_CONNECTION_FAILED;
break;
}
break;
} else {
// If _tt_get_min_auth_level_1 is not available, then we are talking
// to an old DB server.
if (_tt_get_rpc_result() != RPC_AUTHERROR) {
_tt_syslog(0, LOG_ERR,
catgets(_ttcatd, 1, 4, "Error: rpc.ttdbserverd on %s is not running"),
(char *)dbHostname);
SetError(_tt_get_rpc_result());
break; // Give up and return error code.
}
}
} // end -for()-
//
// Cleanup if failure.
//
if (dbConnectionResults != TT_DB_OK) {
if (dbServer) {
clnt_destroy(dbServer);
dbServer = (CLIENT *)NULL;
}
}
// Set close-on-exec bit so a libtt client which forks and execs won't
// be short some fd's in the child.
if (-1 != _socket && -1 == fcntl(_socket, F_SETFD, 1)) {
_tt_syslog( 0, LOG_ERR, "_Tt_db_client::connectToDb(): "
"fcntl(F_SETFD): %m");
}
return dbConnectionResults;
}
static void
ping_local_ispd( void )
{
CLIENT * cl;
char buffer[512];
char description[255];
char * error;
struct timeval timeOut;
struct rpcent rentry;
struct rpcent* rptr;
int rc;
struct timeval timeout = { 3, 0 };
// Set default timeout for client handle, cl, to 4 seconds
memset( &timeOut, (int) 0, sizeof( struct timeval ) );
timeOut.tv_sec = 4;
if ( (rptr = nx_getrpcbyname_r( "ispd",
&rentry,
buffer,
512 )) == (struct rpcent*) 0 )
{
NETERROR( MISPD,
("RPC : ispd rpc service not found\n" ));
return;
}
//
// Create client "handle" used for calling
// MESSAGEPROG on the serverdesignated on
// command line. We tell RPC package
// to use the "tcp" protocol when contacting
// the server.
//
if ( ( cl = clnt_create_timed( "localhost",
rptr->r_number,
1,
"tcp",
&timeOut ) ) == NULL )
{
// Couldn't establish connection with the server
if ( NetLogStatus[ MISPD ] & NETLOG_DEBUG2 )
{
error = clnt_spcreateerror( "localhost" );
NETERROR( MISPD,
("RPC : Client : %s\n", error ));
}
return;
}
if ( NetLogStatus[ MISPD ] & NETLOG_DEBUG2 )
{
sprintf( description,
"Registered with RPC Server, \"%s\"",
"localhost" );
NETERROR( MISPD,
("RPC : Client : %s\n", description ));
}
if ( clnt_control( cl, CLSET_TIMEOUT, (char*) &timeOut ) == FALSE )
{
sprintf( description,
"can't set timeout value to 4 seconds\n" );
NETERROR( MISPD,
("RPC : Client : %s\n", description ));
}
// Call the remote procedure on the server
if ( (rc = (int) clnt_call( cl,
NULLPROC,
(xdrproc_t) xdr_void,
(caddr_t) NULL,
(xdrproc_t) xdr_void,
(caddr_t) NULL,
timeout )) != RPC_SUCCESS )
{
NETERROR( MISPD,
("RPCE : failed nullproc to \"%s\" - rc %d\n",
"localhost",
rc ));
}
if ( cl != ( CLIENT* ) NULL )
clnt_destroy( cl );
return;
}
