void *my_thread_process(void *arg)
{
int i;
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
int var_snd = 0;
int var_rec = -1;
struct timeval tv;
if (run_mode == 1) {
fprintf(stderr, "Thread %d\n", atoi(arg));
}
tv.tv_sec = 0;
tv.tv_usec = 100;
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *)NULL) {
fprintf(stderr, "err nconf\n");
printf("5\n");
exit(1);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL) {
printf("5\n");
exit(5);
}
if (!rpcb_getaddr(progNum, VERSNUM, nconf, &svcaddr, hostname)) {
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
exit(5);
}
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
if (client == NULL) {
printf("5\n");
exit(5);
}
for (i = 0; i < callNb; i++) {
clnt_call(client, PROCNUM,
(xdrproc_t) xdr_int, (char *)&var_snd,
(xdrproc_t) xdr_int, (char *)&var_rec, tv);
}
clnt_destroy(client);
pthread_exit(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]);
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
//Initialization
if (run_mode) {
printf("Before creation\n");
}
nconf = getnetconfigent("udp");
if (nconf == NULL) {
//syslog(LOG_ERR, "getnetconfigent for udp failed");
printf("err nconf\n");
exit(1);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL) {
/* if malloc() failed, print error messages and exit */
return 1;
}
//printf("svcaddr reserved (%s)\n", argc[1]);
if (!rpcb_getaddr(progNum, VERSNUM, nconf, &svcaddr, argc[1])) {
fprintf(stderr, "rpcb_getaddr failed!!\n");
exit(1);
}
//printf("svc get\n");
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
/**/ test_status = ((CLIENT *) client != 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);
clnt_destroy(client);
return test_status;
}
/*
* This has the same definition as clnt_tp_create(), except it
* takes an additional parameter - a pointer to a timeval structure.
* A NULL value for the timeout pointer indicates that the default
* value for the timeout should be used.
*/
CLIENT *
clnt_tp_create_timed(const char *hostname, rpcprog_t prog, rpcvers_t vers,
const struct netconfig *nconf, const struct timeval *tp)
{
struct netbuf *svcaddr; /* servers address */
CLIENT *cl = NULL; /* client handle */
if (nconf == NULL) {
rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
return (NULL);
}
/*
* Get the address of the server
*/
if ((svcaddr = __rpcb_findaddr_timed(prog, vers,
(struct netconfig *)nconf, (char *)hostname,
&cl, (struct timeval *)tp)) == NULL) {
/* appropriate error number is set by rpcbind libraries */
return (NULL);
}
if (cl == NULL) {
cl = clnt_tli_create(RPC_ANYFD, nconf, svcaddr,
prog, vers, 0, 0);
} else {
/* Reuse the CLIENT handle and change the appropriate fields */
if (CLNT_CONTROL(cl, CLSET_SVC_ADDR, (void *)svcaddr) == TRUE) {
if (cl->cl_netid == NULL)
cl->cl_netid = strdup(nconf->nc_netid);
if (cl->cl_tp == NULL)
cl->cl_tp = strdup(nconf->nc_device);
(void) CLNT_CONTROL(cl, CLSET_PROG, (void *)&prog);
(void) CLNT_CONTROL(cl, CLSET_VERS, (void *)&vers);
} else {
CLNT_DESTROY(cl);
cl = clnt_tli_create(RPC_ANYFD, nconf, svcaddr,
prog, vers, 0, 0);
}
}
free(svcaddr->buf);
free(svcaddr);
return (cl);
}
int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// argc[3] : Number of test call
// 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 FAILED
int i;
double *resultTbl;
struct timeval tv1,tv2;
struct timezone tz;
long long diff;
double rslt;
int progNum = atoi(argc[2]);
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
enum clnt_stat cs;
int var_snd = 0;
int var_rec = -1;
struct timeval tv;
//Test initialisation
maxIter = atoi(argc[3]);
resultTbl = (double *)malloc(maxIter * sizeof(double));
if (run_mode)
{
printf("Before creation\n");
printf("client : %d\n", client);
printf("nconf : %d\n", nconf);
}
tv.tv_sec = 0;
tv.tv_usec = 100;
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *) NULL)
{
fprintf(stderr, "err nconf\n");
printf("5\n");
exit(5);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL)
{
printf("5\n");
exit(5);
}
if (!rpcb_getaddr(progNum, VERSNUM, nconf,
&svcaddr, argc[1]))
{
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
exit(5);
}
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
if (client == NULL)
{
printf("5\n");
exit(1);
}
//Call tested function several times
for (i = 0; i < maxIter; i++)
{
//Tic
gettimeofday(&tv1, &tz);
//Call function
cs = clnt_call(client, PROCNUM,
(xdrproc_t)xdr_int, (char *)&var_snd,
(xdrproc_t)xdr_int, (char *)&var_rec,
tv);
//Toc
gettimeofday(&tv2, &tz);
//Add function execution time (toc-tic)
diff = (tv2.tv_sec-tv1.tv_sec) * 1000000L + (tv2.tv_usec-tv1.tv_usec);
rslt = (double)diff / 1000;
if (cs == RPC_SUCCESS)
{
resultTbl[i] = rslt;
}
else
{
test_status = 1;
break;
}
if (run_mode)
{
fprintf(stderr, "lf time = %lf usecn\n", resultTbl[i]);
}
}
//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);
printf("%lf %d\n", average(resultTbl), maxIter);
printf("%lf\n", mini(resultTbl));
printf("%lf\n", maxi(resultTbl));
return test_status;
}
/*
* A common clnt create routine
*/
static CLIENT *
clnt_com_create(struct sockaddr_in *raddr, rpcprog_t prog, rpcvers_t vers,
int *sockp, u_int sendsz, u_int recvsz, const char *tp)
{
CLIENT *cl;
int madefd = FALSE;
int fd;
struct netconfig *nconf;
struct netbuf bindaddr;
_DIAGASSERT(raddr != NULL);
_DIAGASSERT(sockp != NULL);
_DIAGASSERT(tp != NULL);
fd = *sockp;
mutex_lock(&rpcsoc_lock);
if ((nconf = __rpc_getconfip(tp)) == NULL) {
rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
mutex_unlock(&rpcsoc_lock);
return (NULL);
}
if (fd == RPC_ANYSOCK) {
fd = __rpc_nconf2fd(nconf);
if (fd == -1)
goto syserror;
madefd = TRUE;
}
if (raddr->sin_port == 0) {
u_int proto;
u_short sport;
mutex_unlock(&rpcsoc_lock); /* pmap_getport is recursive */
proto = strcmp(tp, "udp") == 0 ? IPPROTO_UDP : IPPROTO_TCP;
sport = pmap_getport(raddr, (u_long)prog, (u_long)vers,
proto);
if (sport == 0) {
goto err;
}
raddr->sin_port = htons(sport);
mutex_lock(&rpcsoc_lock); /* pmap_getport is recursive */
}
/* Transform sockaddr_in to netbuf */
bindaddr.maxlen = bindaddr.len = sizeof (struct sockaddr_in);
bindaddr.buf = raddr;
(void)bindresvport(fd, NULL);
cl = clnt_tli_create(fd, nconf, &bindaddr, prog, vers,
sendsz, recvsz);
if (cl) {
if (madefd == TRUE) {
/*
* The fd should be closed while destroying the handle.
*/
(void) CLNT_CONTROL(cl, CLSET_FD_CLOSE, NULL);
*sockp = fd;
}
(void) freenetconfigent(nconf);
mutex_unlock(&rpcsoc_lock);
return (cl);
}
goto err;
syserror:
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
rpc_createerr.cf_error.re_errno = errno;
err: if (madefd == TRUE)
(void) close(fd);
(void) freenetconfigent(nconf);
mutex_unlock(&rpcsoc_lock);
return (NULL);
}
CLIENT * Creer_RPCClient( char * host, unsigned int programme, unsigned int version,
unsigned short port, int sockfd )
{
struct sockaddr_in6 adresse_rpc ;
int sock = 0 ;
CLIENT * client ;
struct timeval intervalle ;
int rc ;
struct netconfig * nconf ;
struct netbuf netbuf ;
struct hostent * hp ;
if( ( hp = gethostbyname2( host, AF_INET6 ) ) == NULL )
return NULL ;
memset( &adresse_rpc, 0, (size_t)sizeof( adresse_rpc ) ) ;
memcpy( (char *)&adresse_rpc.sin6_addr, (char *)hp->h_addr, hp->h_length ) ;
adresse_rpc.sin6_port = port ;
adresse_rpc.sin6_family = AF_INET6 ;
adresse_rpc.sin6_scope_id = if_nametoindex( ifname ) ;
sock = sockfd ;
intervalle.tv_sec = TIMEOUT_SEC ;
intervalle.tv_usec = 0 ;
if( sock > 0 )
{
if( port > 0 )
{
/* En tcp, il faut que la socket soit connectee sur le service en face si on n'utilise pas RPC_ANYSOCK
* ATTENTION, ceci est une feature non documentee des RPC clientes (j'ai vu ca dans les sources) */
if( connect( sock, (struct sockaddr *)&adresse_rpc, sizeof( adresse_rpc ) ) < 0 )
fprintf( stderr, "connect impossible sur le serveur RPC\n" ) ;
}
else
{
/* Dans ce cas, on ne connait pas le port en face, donc connect impossible, on prend RPC_ANYSOCK
* mais uniquement apres avoir ferme la socket 'sock' qui ne sert a rien ici */
close( sock ) ;
sock = RPC_ANYSOCK ;
}
}
/* initialisation des structures de TI-RPC */
if( ( nconf = (struct netconfig *)getnetconfigent( "tcp6" ) ) == NULL )
{
fprintf( stderr, "Erreur de getnetconfigent\n" ) ;
exit( 1 ) ;
}
netbuf.maxlen = sizeof( adresse_rpc );
netbuf.len = sizeof( adresse_rpc );
netbuf.buf = &adresse_rpc;
/* Creation et allocation du client */
if( ( client = clnt_tli_create( sock,
nconf,
&netbuf,
programme,
version,
SEND_SIZE,
RECV_SIZE ) ) == NULL )
{
char erreur[100] ;
char entete[100] ;
return NULL ;
}
return client ;
} /* Creer_RPCClient */
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];
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
bool_t rpcb_rslt;
//Initialization
if (run_mode)
{
printf("Before creation\n");
printf("client : %d\n", client);
printf("nconf : %d\n", nconf);
}
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *) NULL)
{
//syslog(LOG_ERR, "getnetconfigent for udp failed");
fprintf(stderr, "err nconf\n");
printf("5\n");
exit(1);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL)
{
/* if malloc() failed, print error messages and exit */
return 1;
}
//printf("svcaddr reserved (%s)\n", argc[1]);
if (!rpcb_getaddr(progNum, VERSNUM, nconf,
&svcaddr, argc[1]))
{
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
exit(1);
}
//Test arguments initialization
paramList[0].bufmin = 0;
paramList[0].bufmax = 2147483647;
paramList[1].bufmin = 2147483647;
paramList[1].bufmax = 0;
paramList[2].bufmin = 2147483647;
paramList[2].bufmax = 2147483647;
//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].bufmin);
printf("%d", paramList[i].bufmax);
printf("\n");
}
//Call function
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, paramList[i].bufmin, paramList[i].bufmax);
//Check result
if (client == 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;
}
/*
* A common clnt create routine
*/
static CLIENT *
clnt_com_create(struct sockaddr_in *raddr, rpcprog_t prog, rpcvers_t vers,
int *sockp, uint_t sendsz, uint_t recvsz, char *tp)
{
CLIENT *cl;
int madefd = FALSE;
int fd = *sockp;
struct t_info tinfo;
struct netconfig *nconf;
int port;
struct netbuf bindaddr;
bool_t locked = TRUE;
(void) mutex_lock(&rpcsoc_lock);
if ((nconf = __rpc_getconfip(tp)) == NULL) {
rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
(void) mutex_unlock(&rpcsoc_lock);
return (NULL);
}
if (fd == RPC_ANYSOCK) {
fd = t_open(nconf->nc_device, O_RDWR, &tinfo);
if (fd == -1)
goto syserror;
RPC_RAISEFD(fd);
madefd = TRUE;
} else {
if (t_getinfo(fd, &tinfo) == -1)
goto syserror;
}
if (raddr->sin_port == 0) {
uint_t proto;
ushort_t sport;
/* pmap_getport is recursive */
(void) mutex_unlock(&rpcsoc_lock);
proto = strcmp(tp, "udp") == 0 ? IPPROTO_UDP : IPPROTO_TCP;
sport = pmap_getport(raddr, prog, vers, proto);
if (sport == 0) {
locked = FALSE;
goto err;
}
raddr->sin_port = htons(sport);
/* pmap_getport is recursive */
(void) mutex_lock(&rpcsoc_lock);
}
/* Transform sockaddr_in to netbuf */
bindaddr.maxlen = bindaddr.len = __rpc_get_a_size(tinfo.addr);
bindaddr.buf = (char *)raddr;
(void) __rpc_bindresvport(fd, NULL, &port, 0);
cl = clnt_tli_create(fd, nconf, &bindaddr, prog, vers,
sendsz, recvsz);
if (cl) {
if (madefd == TRUE) {
/*
* The fd should be closed while destroying the handle.
*/
(void) CLNT_CONTROL(cl, CLSET_FD_CLOSE, NULL);
*sockp = fd;
}
(void) freenetconfigent(nconf);
(void) mutex_unlock(&rpcsoc_lock);
return (cl);
}
goto err;
syserror:
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
rpc_createerr.cf_error.re_errno = errno;
rpc_createerr.cf_error.re_terrno = t_errno;
err: if (madefd == TRUE)
(void) t_close(fd);
(void) freenetconfigent(nconf);
if (locked == TRUE)
(void) mutex_unlock(&rpcsoc_lock);
return (NULL);
}
CLIENT * Creer_RPCClient( unsigned int adresse, unsigned int programme, unsigned int version,
unsigned short port, int sockfd )
{
struct sockaddr_in adresse_rpc ;
int sock = 0 ;
CLIENT * client ;
struct timeval intervalle ;
int rc ;
struct netconfig * nconf ;
struct netbuf netbuf ;
memset( &adresse_rpc, 0, (size_t)sizeof( adresse_rpc ) ) ;
adresse_rpc.sin_port = port ;
adresse_rpc.sin_family = AF_INET ;
adresse_rpc.sin_addr.s_addr = adresse ;
sock = sockfd ;
intervalle.tv_sec = TIMEOUT_SEC ;
intervalle.tv_usec = 0 ;
if( sock > 0 )
{
if( port > 0 )
{
/* En tcp, il faut que la socket soit connectee sur le service en face si on n'utilise pas RPC_ANYSOCK
* ATTENTION, ceci est une feature non documentee des RPC clientes (j'ai vu ca dans les sources) */
if( connect( sock, (struct sockaddr *)&adresse_rpc, sizeof( adresse_rpc ) ) < 0 )
fprintf( stderr, "connect impossible sur le serveur RPC\n" ) ;
}
else
{
/* Dans ce cas, on ne connait pas le port en face, donc connect impossible, on prend RPC_ANYSOCK
* mais uniquement apres avoir ferme la socket 'sock' qui ne sert a rien ici */
close( sock ) ;
sock = RPC_ANYSOCK ;
}
}
/* initialisation des structures de TI-RPC */
if( ( nconf = (struct netconfig *)getnetconfigent( "tcp" ) ) == NULL )
{
fprintf( stderr, "Erreur de getnetconfigent\n" ) ;
exit( 1 ) ;
}
netbuf.maxlen = sizeof( adresse_rpc );
netbuf.len = sizeof( adresse_rpc );
netbuf.buf = &adresse_rpc;
/* Creation et allocation du client */
if( ( client = clnt_tli_create( sock,
nconf,
&netbuf,
programme,
version,
SEND_SIZE,
RECV_SIZE ) ) == NULL )
{
char erreur[100] ;
char entete[100] ;
sprintf( entete, "Creation RPC %d|%d|0x%x:%d|%d", programme, version, adresse, port, sock ) ;
strcpy( erreur, clnt_spcreateerror( entete ) ) ;
fprintf( stderr, "%s", erreur ) ;
return NULL ;
}
return client ;
} /* Creer_RPCClient */
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 PASSED
int progNum = atoi(argc[2]);
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
enum clnt_stat cs;
struct timeval tv;
//Sent variables
int intSnd;
double dblSnd;
long lngSnd;
char *strSnd;
//Received variables
int intRec;
double dblRec;
long lngRec;
char *strRec;
//Test initialization
tv.tv_sec = 0;
tv.tv_usec = 100;
nconf = getnetconfigent("udp");
if (nconf == NULL) {
fprintf(stderr, "err nconf\n");
printf("5\n");
exit(5);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL) {
printf("5\n");
exit(5);
}
if (!rpcb_getaddr(progNum, VERSNUM, nconf, &svcaddr, argc[1])) {
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
exit(5);
}
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
if (client == NULL) {
printf("5\n");
exit(5);
}
//Call tested procedure several times
//Int test : call INTPROCNUM RPC
intSnd = -65536;
cs = clnt_call(client, INTPROCNUM,
(xdrproc_t) xdr_int, (char *)&intSnd,
(xdrproc_t) xdr_int, (char *)&intRec, tv);
if (intSnd != intRec)
test_status = 1;
if (run_mode == 1)
printf("Send (int) : %d, Received : %d\n", intSnd, intRec);
//Test positive number
intSnd = 16777216;
cs = clnt_call(client, INTPROCNUM,
(xdrproc_t) xdr_int, (char *)&intSnd,
(xdrproc_t) xdr_int, (char *)&intRec, tv);
if (intSnd != intRec)
test_status = 1;
if (run_mode == 1)
printf("Send (int) : %d, Received : %d\n", intSnd, intRec);
//Long test : call LNGPROCNUM RPC
lngSnd = -430000;
cs = clnt_call(client, LNGPROCNUM,
(xdrproc_t) xdr_long, (char *)&lngSnd,
(xdrproc_t) xdr_long, (char *)&lngRec, tv);
if (lngSnd != lngRec)
test_status = 1;
if (run_mode == 1)
printf("Send (long) : %ld, Received : %ld\n", lngSnd, lngRec);
//Double test : call DBLPROCNUM RPC
dblSnd = -1735.63000f;
cs = clnt_call(client, DBLPROCNUM,
(xdrproc_t) xdr_double, (char *)&dblSnd,
(xdrproc_t) xdr_double, (char *)&dblRec, tv);
if (dblSnd != dblRec)
test_status = 1;
if (run_mode == 1)
printf("Send (double) : %lf, Received : %lf\n", dblSnd, dblRec);
//String test : call STRPROCNUM RPC
strSnd = "text to send.";
strRec = malloc(64 * sizeof(char));
cs = clnt_call(client, STRPROCNUM,
(xdrproc_t) xdr_wrapstring, (char *)&strSnd,
(xdrproc_t) xdr_wrapstring, (char *)&strRec, tv);
if (strcmp(strSnd, strRec))
test_status = 1;
if (run_mode == 1)
printf("Send (string) : %s, Received : %s\n", strSnd, strRec);
//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 main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// argc[3] : Number of testes function calls
// 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]);
CLIENT *client = NULL;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
enum clnt_stat cs;
int var_snd = 0;
int var_rec = -1;
struct timeval tv;
int nbCall = atoi(argc[3]);
int nbOk = 0;
int i;
//Initialization
if (run_mode) {
printf("Before creation\n");
}
tv.tv_sec = 0;
tv.tv_usec = 100;
nconf = getnetconfigent("udp");
if (nconf == (struct netconfig *)NULL) {
//syslog(LOG_ERR, "getnetconfigent for udp failed");
fprintf(stderr, "err nconf\n");
printf("5\n");
exit(5);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL) {
printf("5\n");
exit(5);
}
//printf("svcaddr reserved (%s)\n", argc[1]);
if (!rpcb_getaddr(progNum, VERSNUM, nconf, &svcaddr, argc[1])) {
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
exit(5);
}
//printf("svc get\n");
client = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
/**/ for (i = 0; i < nbCall; i++) {
cs = clnt_call(client, PROCNUM,
(xdrproc_t) xdr_int, (char *)&var_snd,
(xdrproc_t) xdr_int, (char *)&var_rec, tv);
if (cs == RPC_SUCCESS)
nbOk++;
}
if (run_mode == 1) {
printf("Aimed : %d\n", nbCall);
printf("Got : %d\n", nbOk);
}
test_status = (nbOk == nbCall) ? 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);
clnt_destroy(client);
return test_status;
}
void *my_thread_process(void *arg)
{
CLIENT *clnt = NULL;
struct datas vars;
struct timeval total_timeout;
struct netconfig *nconf = NULL;
struct netbuf svcaddr;
char addrbuf[ADDRBUFSIZE];
total_timeout.tv_sec = 1;
total_timeout.tv_usec = 1;
nconf = getnetconfigent("udp");
if ((struct netconfig *)nconf == NULL) {
//Test failed
printf("5\n");
pthread_exit((void*)5l);
}
svcaddr.len = 0;
svcaddr.maxlen = ADDRBUFSIZE;
svcaddr.buf = addrbuf;
if (svcaddr.buf == NULL) {
printf("5\n");
pthread_exit((void*)5l);
}
if (!rpcb_getaddr(progNum, VERSNUM, nconf, &svcaddr, hostname)) {
fprintf(stderr, "rpcb_getaddr failed!!\n");
printf("5\n");
pthread_exit((void*)5l);
}
clnt = clnt_tli_create(RPC_ANYFD, nconf, &svcaddr,
progNum, VERSNUM, 0, 0);
if (clnt == NULL) {
printf("5\n");
pthread_exit((void*)5l);
}
if (run_mode == 1) {
fprintf(stderr, "Thread %ld\n", (long)arg);
}
vars.a = getRand();
vars.b = getRand();
vars.c = getRand();
resTbl[atoi(arg)].locRes = vars.a + (vars.b * vars.c);
clnt_call((CLIENT *) clnt, CALCTHREADPROC, (xdrproc_t) xdr_datas, (char *)&vars, // xdr_in
(xdrproc_t) xdr_double, (char *)&resTbl[atoi(arg)].svcRes, // xdr_out
total_timeout);
thread_array_result[atoi(arg)] =
(resTbl[atoi(arg)].svcRes == resTbl[atoi(arg)].locRes) ? 0 : 1;
if (run_mode == 1) {
fprintf(stderr, "Thread #%d calc : %lf, received : %lf\n",
atoi(arg), resTbl[atoi(arg)].locRes,
resTbl[atoi(arg)].svcRes);
}
pthread_exit(0);
}
