void resetearClientes(char *host)
{
	CLIENT *clnt;
	
	void  *result_3;
	char *resetearclientes_1_arg;
	
#ifndef	DEBUG
	clnt = clnt_create (host, NUMERADORCLIENTE, NUMERADORCLIENTE1, "udp");
	if (clnt == NULL) {
		clnt_pcreateerror (host);
		exit (1);
	}
#endif	/* DEBUG */

	result_3 = resetearclientes_1((void*)&resetearclientes_1_arg, clnt);
	if (result_3 == (void *) NULL) {
		clnt_perror (clnt, "call failed");
	}
	
#ifndef	DEBUG
	clnt_destroy (clnt);
#endif	 /* DEBUG */
}

int main(int argc, char **argv) {
    CGI_varlist *varlist;
    char *value;

    if ((varlist = CGI_get_all(0)) == 0) {
        fputs("Content-type: text/plain\r\n\r\n", stdout);
        printf("No CGI data received\r\n");
        return 0;
    }
    
    value = CGI_lookup(varlist, "id");


    cl = clnt_create(PAPER_ADDRESS, PAPERSERVER_PROG, PAPERSERVER_VERS, "tcp");
    if (cl == NULL) {
        perror("Error creating RPC client!");
        CGI_free_varlist(varlist);
        exit(1);
    }

    if (value != NULL) {
        fetch_article(value);
    }
    else {
        printf("Content-Type: text/plain\n\n");
        printf("id value missing\n\n");
    }

    CGI_free_varlist(varlist);  /* free variable list */


    clnt_destroy(cl);


    return 0;
}

int main (int argc, char **argv)
{
	CLIENT *cl;
	primo_in in;
	primo_out *outp;
	if (argc != 3)
	{
		printf("\n\nerror: insufficient arguments!!!\n");
		exit(-1);
	}

	cl=clnt_create(argv[1],PRIMO_PROG,PRIMO_VERS,"tcp");
	in.primo=atol(argv[2]);

	if (cl==NULL)
	{
		printf("\n\nerror: %s\n",strerror(errno));
		exit(-1);
	}

	if ((outp=primoproc_1(&in,cl))==NULL)
	{
		printf("\nerror: %s\n",clnt_sperror(cl,argv[1]));
		exit(-1);
	}
	if (outp->res == 0)
	{
		printf("\n\n Numero no es primo %i \n",outp->res);
		exit(0);
	}else
	{
		printf("\n\n Numero es primo %i \n",outp->res);
	}
	
	
}

int main(int argc, char *argv[]){
	if (argc != 4){ 
	    printf("You must enter: ./rget remote-host remote-filename local-filename \n"); 
	    exit(1); 
	}
	
	if(strlen(argv[2]) > MAXNAME  || strlen(argv[3]) > MAXNAME ){
		exit(1); 
	} 
	
	CLIENT *client;                                                 
	client = clnt_create(argv[1], FRPC_PROG, FRPC_VERS, "udp");
	
	if (client == (CLIENT *) NULL) {
		clnt_pcreateerror(argv[1]);
		exit(1);
	}
	int fileCount=rget(client,argv[2],argv[3]);
	if(fileCount>=10){
		fprintf(stderr,"Maximum Number File Opened\n");	
		exit(1);
	}
	return 0;
}

static int
callaurpc(char *host, int prognum, int versnum, int procnum,
    xdrproc_t inproc, char *in, xdrproc_t outproc, char *out)
{
	enum clnt_stat clnt_stat;
	struct timeval timeout, tottimeout;
 
	CLIENT *client = NULL;

 	client = clnt_create(host, prognum, versnum, "udp");
	if (client == NULL)
		return ((int)rpc_createerr.cf_stat);
	timeout.tv_usec = 0;
	timeout.tv_sec = 6;
	CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *)(void *)&timeout);

	client->cl_auth = authunix_create_default();
	tottimeout.tv_sec = 25;
	tottimeout.tv_usec = 0;
	clnt_stat = clnt_call(client, procnum, inproc, in,
	    outproc, out, tottimeout);
 
	return ((int) clnt_stat);
}

void
benchmark(char *server, char* protocol)
{
	CLIENT *cl;
	char	buf[256];
	struct	timeval tv;

	cl = clnt_create(server, XACT_PROG, XACT_VERS, protocol);
	if (!cl) {
		clnt_pcreateerror(server);
		exit(1);
	}
	if (strcasecmp(protocol, proto[1]) == 0) {
		tv.tv_sec = 0;
		tv.tv_usec = 2500;
		if (!clnt_control(cl, CLSET_RETRY_TIMEOUT, (char *)&tv)) {
			clnt_perror(cl, "setting timeout");
			exit(1);
		}
	}
	BENCH(doit(cl, server, protocol), MEDIUM);
	sprintf(buf, "RPC/%s latency using %s", protocol, server);
	micro(buf, get_n());
}

static
nismaplist *
nis_maplist (char *dom)
{
	nisresp_maplist *list;
	CLIENT *cl;
	char *server = NULL;
	int mapi = 0;

	while (!server && aliases[mapi].map != 0L) {
		yp_master (dom, aliases[mapi].map, &server);
		mapi++;
	}
        if (!server) {
            PyErr_SetString(NisError, "No NIS master found for any map");
            return NULL;
        }
	cl = clnt_create(server, YPPROG, YPVERS, "tcp");
	if (cl == NULL) {
		PyErr_SetString(NisError, clnt_spcreateerror(server));
		goto finally;
	}
	list = nisproc_maplist_2 (&dom, cl);
	clnt_destroy(cl);
	if (list == NULL)
		goto finally;
	if (list->stat != NIS_TRUE)
		goto finally;

	free(server);
	return list->maps;

  finally:
	free(server);
	return NULL;
}

void
rpccracker_1(char *host)
{
    CLIENT *clnt;
    enum clnt_stat retval_1;
    void *result_1;
    message  get_1_arg;

#ifndef	DEBUG
    clnt = clnt_create (host, rpcCracker, CAVERLEE4PRES, "udp");
    if (clnt == NULL) {
        clnt_pcreateerror (host);
        exit (1);
    }
#endif	/* DEBUG */

    retval_1 = get_1(&get_1_arg, &result_1, clnt);
    if (retval_1 != RPC_SUCCESS) {
        clnt_perror (clnt, "call failed");
    }
#ifndef	DEBUG
    clnt_destroy (clnt);
#endif	 /* DEBUG */
}

int main(int argc, char *argv[]) {
CLIENT *cl;
char *server;
long *lres;
if (argc != 2) {
fprintf(stderr, "usage: %s hostname\n", argv[0]);
exit(1);
}
server = argv[1];
/* create client handle */ 
if ((cl = clnt_create(server, DATEPROG, DATEVERS, "udp")) == NULL) {
/* couldn't establish connection with server */
printf("can't establish connection with host %s\n", server);
exit(2);
}
/* first call the remote procedure bindate() */
if (( lres = bindate_1(NULL, cl)) == NULL){
printf(" remote procedure bindate() failure\n");
exit(3);
}
printf("time on host %s = %ld\n", server, *lres);
clnt_destroy(cl); /* done with handle */
return 0;
}

static int
notify_one_host(char *hostname)
{
    struct timeval timeout = { 20, 0 };	/* 20 secs timeout		*/
    CLIENT *cli;
    char dummy;
    stat_chge arg;
    char our_hostname[SM_MAXSTRLEN+1];

    gethostname(our_hostname, sizeof(our_hostname));
    our_hostname[SM_MAXSTRLEN] = '\0';
    arg.mon_name = our_hostname;
    arg.state = status_info->ourState;

    if (debug) syslog (LOG_DEBUG, "Sending SM_NOTIFY to host %s from %s", hostname, our_hostname);

    cli = clnt_create(hostname, SM_PROG, SM_VERS, "udp");
    if (!cli)
    {
        syslog(LOG_ERR, "Failed to contact host %s%s", hostname,
               clnt_spcreateerror(""));
        return (FALSE);
    }

    if (clnt_call(cli, SM_NOTIFY, (xdrproc_t)xdr_stat_chge, &arg,
                  (xdrproc_t)xdr_void, &dummy, timeout)
            != RPC_SUCCESS)
    {
        syslog(LOG_ERR, "Failed to contact rpc.statd at host %s", hostname);
        clnt_destroy(cli);
        return (FALSE);
    }

    clnt_destroy(cli);
    return (TRUE);
}

short  EXrpcclntcr(
    char   *server,
    DBint   program,
    DBint   version,
    DBint  *Pclient,
    DBint  *pstat)

/*      Create client for Remote Procedure calls (RPC)
 *
 *      In:  server     = Name or ip-adress of RPC server
             program    = Program number
             version    = Program version
 *
 *      Out: *Pclient   = Handle to created client (DBint)
 *           *pstat     = Status
 *
 *      (C) 2004-04-26 Sören Larsson, Örebro University
 *
 ****************************************************************************!*/
{
#ifdef V3RAP
    CLIENT *clnt = NULL;

    clnt = clnt_create (server, program, version, "tcp");
    if (clnt == NULL) {
        *pstat=-1;
        return(0);
    }
    *Pclient=(DBint)(void*)clnt;  /* asume size of pointer == size of DBint) */
    *pstat = 0;
    return(0);

#else
    return(erpush("EX6012",""));
#endif
}

int
whoisslave_call (struct slave *peer)
{
  int err;
  CLIENT *clnt;
  struct timeval timeout;

#ifdef DEBUG
  printf ("**** [call] whoislave\n");
#endif

  clnt = clnt_create (peer -> addr, LOSH, SLAVE, "udp");
  if (clnt == NULL)
    {
      fprintf (stderr, "whoisslave_call: Peer not found.\n");
      return FALSE;
    }

  timeout.tv_sec  = 10;
  timeout.tv_usec =  0;
  err = clnt_call (clnt, WHOISSLAVE,
                   (xdrproc_t) xdr_void,  (char *) NULL,
                   (xdrproc_t) xdr_slave, (char *) peer,
                   timeout);
  if (err)
    {
      fprintf (stderr, "clnt_call: Failed.\n");
      exit (EXIT_FAILURE);
    }

  clnt_destroy (clnt);
#ifdef DEBUG
  printf ("**** [resp] whoislave\n");
#endif
  return TRUE;
}

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 FAILED
	int progNum = atoi(argc[2]);
	char proto[8] = "udp";
	CLIENT *clnt = NULL;
	struct timeval tvSet;
	struct timeval tvGet;

	//First of all, create a client
	clnt = clnt_create(argc[1], progNum, VERSNUM, proto);

	if (run_mode) {
		printf("CLIENT : %p\n", clnt);
	}

	tvSet.tv_sec = 1000;
	tvSet.tv_usec = 2000;

	clnt_control(clnt, CLSET_TIMEOUT, (char *)&tvSet);
	clnt_control(clnt, CLGET_TIMEOUT, (char *)&tvGet);

	if ((tvSet.tv_sec != tvGet.tv_sec) || (tvSet.tv_usec != tvGet.tv_usec))
		test_status = 1;

	if (run_mode) {
		printf("Time Set : %ld sec %ld usec\n",
		       (long)tvSet.tv_sec, (long)tvSet.tv_usec);
		printf("Time Get : %ld sec %ld usec\n",
		       (long)tvGet.tv_sec, (long)tvGet.tv_usec);
	}

	tvSet.tv_sec = 4000;
	tvSet.tv_usec = 8000;

	clnt_control(clnt, CLSET_RETRY_TIMEOUT, (char *)&tvSet);
	clnt_control(clnt, CLGET_RETRY_TIMEOUT, (char *)&tvGet);

	if ((tvSet.tv_sec != tvGet.tv_sec) || (tvSet.tv_usec != tvGet.tv_usec))
		test_status = 1;

	if (run_mode) {
		printf("Time Set : %ld sec %ld usec\n",
		       (long)tvSet.tv_sec, (long)tvSet.tv_usec);
		printf("Time Get : %ld sec %ld usec\n",
		       (long)tvGet.tv_sec, (long)tvGet.tv_usec);
	}
	//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 argc, char *argv[])
{
	int result;
	int opt;
	int arg = 1;
	static char *exit_cmd[] = { "exit", NULL };
	char *hist_size;

	strcpy(server, "localhost");

	cli_init("ippool");
	result = cli_add_commands(&cmds[0]);
	if (result < 0) {
		fprintf(stderr, "Application initialization error.\n");
		return result;
	}

	cl = clnt_create(server, IPPOOL_PROG, IPPOOL_VERSION, "udp");
	if (cl == NULL) {
		clnt_pcreateerror(server);
		exit(1);
	}
	atexit(cleanup);

	opterr = 0;		/* no error messages please */

	opt = getopt(argc, argv, "qR:");
	switch (opt) {
	case 'q':
		opt_quiet = 1;
		arg++;
		break;
	case 'R':
		strncpy(server, optarg, sizeof(server));
		arg += 2;
		ippool_set_prompt(server);
		break;
	default:
		break;
	}

	/* If user supplied arguments, send them to the CLI now and immediately exit.
	 */
	if (argc > arg) {
		(void) cli_execute(argc - arg, &argv[arg]);
		(void) cli_execute(1, exit_cmd);
	} else {
		/* interactive mode */
		interactive = 1;
		ippool_histfile = getenv("IPPOOL_HISTFILE");
		if (ippool_histfile == NULL) {
			ippool_histfile = "~/.ippool_history";
		}
		hist_size = getenv("IPPOOL_HISTFILESIZE");
		if (hist_size != NULL) {
			ippool_histfile_maxsize = strtoul(hist_size, NULL, 0);
		}

		cli_read_history_file(ippool_histfile);
		cli_run();
	}

	return 0;
}

int main(int argc, char *argv[])
{	
	char *svraddr = NULL;
	CLIENT *clntp = NULL;
	char *fpath = NULL;
	char *name = NULL;
	struct mkdir3args args;
	struct diropres3 res;
	/*struct fattr *fattrp = NULL;*/
	struct timeval to = {120, 0};
	enum clnt_stat st;
	int err = 0;
	int argv_len = 0;
	struct hsfs_inode *parent = NULL ;
	struct hsfs_inode *new;
	cliname = basename (argv[0]);
	if (argc < 3) {
			err = EINVAL;
			fprintf(stderr, "%s $svraddr $fpath.\n", cliname);
			goto out;
		}
	parent = (struct hsfs_inode *) malloc(sizeof(struct hsfs_inode));
	svraddr = argv[1];
	fpath = argv[2];
	name = argv[3];
	clntp = clnt_create(svraddr, 100003, NFS_V3, "tcp");
	if (NULL == clntp)
	{
		fprintf(stderr, "%s: Create handle to RPC server (%s, %u, %u) failed: (%s).\n", cliname,svraddr, NFSPROC3_MKDIR, NFS_V3, clnt_spcreateerror(cliname));
		err = ENXIO;
		goto out;
	} 
	memset (&args, 0, sizeof(args));
	memset (&res, 0, sizeof(res));
	args.where.name = fpath;
	//args.path.fpath_len = strlen(fpath);
	int st_tmp;
	size_t fh_len = 0;
	unsigned char *fh;
	st_tmp = map_path_to_nfs3fh(svraddr, fpath, &fh_len, &fh);
	args.where.dir.data.data_len  = fh_len;
	args.where.dir.data.data_val = fh;
	parent->sb = (struct hsfs_super *) malloc(sizeof(struct hsfs_super));
	if (NULL == parent->sb)
	{
		printf("No memory:parent->sb.\n");
	}
	parent->sb->clntp = clntp;
	parent->fh.data.data_len = args.where.dir.data.data_len;
	parent->fh.data.data_val = args.where.dir.data.data_val;
	st = hsi_nfs3_rmdir(parent, name);
	if (st) {
		err = EIO;
		fprintf (stderr, "%s: Call RPC Server (%s, %u, %u) failure: (%s).\n", cliname, svraddr, NFSPROC3_MKDIR, NFS_V3,clnt_sperrno(st));
		goto out;
	}
	if (0 == st){
		printf("Rm ok!\n");
	}

out:
	free(parent->sb);
	free(parent);
	if (NULL != clntp)
		clnt_destroy(clntp);
	exit(st);
}

int main(int argc, char *argv[]){
  
  char nombre[MAX_LONG];  // Nombre de esta Bomba
  char *nombre_pointer= &nombre[0]; // para poder enviarlo por RPC 
  int capMax;             // Capacidad Máxima (Litros)
  char archivo[MAX_LONG]; // Nombre de archivo "DNS"

  // Datos de los servidores
  char* nombres[MAX_SERVERS];
  char* direcciones[MAX_SERVERS];
  int tiempos[MAX_SERVERS]; //tiempos de respuesta
  CLIENT *clnts[MAX_SERVERS];

  // Validar y obtener argumentos del cliente
  argumentos_cliente(argc,argv,nombre,&inventario,&consumo,&capMax,archivo);

  obtener_lista_dns(archivo, nombres,direcciones);
 
  // creacion del archivo LOG del cliente
  char nombre_LOG[MAX_LONG];
  sprintf(nombre_LOG,"log_%s.txt",nombre);
  LOG = fopen(nombre_LOG,"w");

  fprintf(LOG,"Inventario inicial %d \n ", inventario);
  if(inventario == 0) fprintf(LOG,"Tanque vacio: 0 minutos \n");
  if(inventario == capMax) fprintf(LOG,"Tanque full: 0 minutos \n");
  
  // PEDIR TIEMPOS
  int k = 0;
  while ((direcciones[k]) != NULL){

    clnts[k]= clnt_create (direcciones[k], SERVICIOPDVSA, SERVICIOPDVSAVERS, "tcp");
    if(clnts[k] == NULL){
      clnt_pcreateerror( direcciones[k] );
      tiempos[k] = 500;
      k = k + 1;
      continue;
    }
     
    int *result = pedir_tiempo_1(NULL,clnts[k]);
    if ( result == (int *)NULL){
      clnt_perror( clnts[k], "Error al conectar con servidor");
      tiempos[k] = 500;
    }else{
      tiempos[k]= *result;
    }
    
    k = k + 1;
  }
 
  // ORDENAR EL ARREGLO DE TIEMPOS y TODOS LOS DEMAS 
  int i = 0 ;
  int minimo;
  int j;
 
  while (nombres[i]!=NULL){
   
    minimo = i;
    j = i + 1;
    while (nombres[j]!=NULL){
      if (tiempos[j] < tiempos[minimo]){
	minimo = j;
      }
      j = j +1;   
    }
  
    swap(&tiempos[i],&tiempos[minimo]);
    swapLetras(&nombres[i],&nombres[minimo]);
    swapLetras(&direcciones[i],&direcciones[minimo]);
    swapPointer(&clnts[i],&clnts[minimo]);
    i=i+1;
  }
 

  // Iniciar contador de tiempo 
  pthread_t contador_tiempo;
  int tiempo = 0;
  pthread_create(&contador_tiempo,NULL,llevar_tiempo,&tiempo);
 
  /**** INICIO DE LA SIMULACION ****/   
  int r = 0;

  while (tiempo <= 480){
    //Iterar sobre los servidores pidiendo gasolina
    
    if(direcciones[r] == NULL){
      // Si llegamos al final de la lista, reiniciar.
      r = 0;
      usleep(100000);
    }

    if ((capMax-inventario)>=38000){

      // Verificar si el servidor no respondió al pedir tiempos
      if (tiempos[r] == 500){ 
	r = r +1;
	continue;
      }

      // Pedir gasolina al servidor num r, almacenar respuesta en buffer gasolina
//.........这里部分代码省略.........

int sendIntegration(int nPoints, double uT, float duration, int chunk,
		    int ant1, int pol1, int ant2, int pol2,
		    float *lsbCross, float *usbCross, int forceTransfer)
{
  int i, antennaInArray[11];
  static CLIENT *corrSaverCl = NULL, *dataCatcherCl = NULL;

  if (!forceTransfer)
    getAntennaList(antennaInArray);
  
  if ((antennaInArray[ant1] && antennaInArray[ant2]) || forceTransfer) {
    if ((chunk != 0) && (chunk != 1)) {
      fprintf(stderr, "sendIntegration called with illegal chunk number (%d) - aborting\n", chunk);
      return(ERROR);
    }
    sWARMData.nChannels = nPoints;
    sWARMData.uT = uT;
    sWARMData.duration = duration;
    sWARMData.ant1 = ant1;
    sWARMData.pol1 = pol1;
    sWARMData.ant2 = ant2;
    sWARMData.pol2 = pol2;
    sWARMData.chunk = chunk;
    if (ant1 == ant2)
      for (i = 0; i < nPoints; i++)
	sWARMData.lSB[i] = lsbCross[2*i];
    else {
      for (i = 0; i < 2*nPoints; i++) {
	sWARMData.lSB[i] = lsbCross[i];
	sWARMData.uSB[i] = usbCross[i];
      }
    }
    
    /* Send the data to corrPlotter */
    if (corrSaverCl == NULL) {
      if (!(corrSaverCl = clnt_create("obscon", CHUNKPLOTPROG, CHUNKPLOTVERS, "tcp"))) {
	clnt_pcreateerror("obscon");
	return(ERROR);
      }
    }
    if (printResults(plot_swarm_data_1(&sWARMData, corrSaverCl))) {
      fprintf(stderr, "Error returned from corrPlotter call\n");
      clnt_destroy(corrSaverCl);
      corrSaverCl = NULL;
    }
    
    /* Send the data to dataCatcher */
    if (dataCatcherCl == NULL) {
      if (!(dataCatcherCl = clnt_create("hcn", DATACATCHERPROG, DATACATCHERVERS, "tcp"))) {
	clnt_pcreateerror("hcn");
	return(ERROR);
      }
    }
    if (printResults((statusStructure *)catch_swarm_data_1((dSWARMUVBlock *)(&sWARMData), dataCatcherCl))) {
      fprintf(stderr, "Error returned from dataCatcher call\n");
      clnt_destroy(dataCatcherCl);
      dataCatcherCl = NULL;
    }
  }
  return OK;
}

void
suggest_1(char *host, char *arg, char *user, char *collection)
{
	CLIENT *clnt;
	numbest_res *result_1;
	struct senddata args;
	char first[1024];
	char suggeston[1024];
	char **wordlist;
	int splitn;

	splitn = split(arg, " ", &wordlist);

	if (splitn == 0)
		return;

	args.word = wordlist[splitn-1];
	convert_to_lowercase(args.word);
	args.user = user;
	args.collection = (collection ? collection : "");

#ifndef	DEBUG
	clnt = clnt_create (host, SUGGEST, SUGGESTVERS, "udp");
	if (clnt == NULL) {
		clnt_pcreateerror (host);
		exit (1);
	}
#endif	/* DEBUG */

	/* XXX: set lower timeout */
	result_1 = get_best_results_2(&args, clnt);
	if (!result_1) {
#if 1
		//clnt_perror (clnt, "call failed");
#endif
	}
	else {
		if (result_1->_errno == 0) {
			namelist nl;
			int i;

			if (strlen(args.word) > 0) {
				for (nl = result_1->numbest_res_u.list;
				     nl != NULL;
				     nl = nl->next) {
					for (i = 0; i < splitn-1; i++)
						printf("%s ", wordlist[i]);
					printf("%s\n", nl->name);
				}
			} else {		
				for (i = 0; i < splitn-1; i++)
					printf("%s ", wordlist[i]);
				puts("");
			}
		}
	}

	FreeSplitList(wordlist);

#ifndef	DEBUG
	clnt_destroy (clnt);
#endif	 /* DEBUG */
}

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]);
	char nettype[16] = "visible";
	CLIENT *clnt = NULL;
	enum clnt_stat cs;
	int sndVar = 0;
    int recVar = -1;
    struct timeval total_timeout;

	//Test initialisation
    maxIter = atoi(argc[3]);
    resultTbl = (double *)malloc(maxIter * sizeof(double));

    total_timeout.tv_sec = 1;
	total_timeout.tv_usec = 1;

	clnt = clnt_create(argc[1], progNum, VERSNUM, nettype);

	if (clnt == NULL)
	{
		printf("5\n");
		return 5;
	}

	//Call tested function several times
	for (i = 0; i < maxIter; i++)
	{
		//Tic
		gettimeofday(&tv1, &tz);

		//Call function
		cs = clnt_call((CLIENT *)clnt, PROCNUM,
						(xdrproc_t)xdr_int, (char *)&sndVar, // xdr_in
                   		(xdrproc_t)xdr_int, (char *)&recVar, // xdr_out
						total_timeout);

		//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;
    		clnt_perrno(cs);
    		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;
}

static int
ypxfrd_transfer (char *host, char *map, char *domain, char *tmpname)
{
  CLIENT *clnt;
  struct ypxfr_mapname req;
  struct xfr resp;
  struct timeval timeout = {25, 0};

  if (debug_flag)
    fprintf (stderr, "Trying ypxfrd ...");

  if (!getrpcport (host, YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS,
                   IPPROTO_TCP))
    {
      if (debug_flag)
        log_msg (" not running");
      return 1;
    }

  req.xfrmap = map;
  req.xfrdomain = domain;
  req.xfrmap_filename = map;
#if defined(HAVE_LIBGDBM)
#if SIZEOF_LONG == 8
  req.xfr_db_type = XFR_DB_GNU_GDBM64;
#else
  req.xfr_db_type = XFR_DB_GNU_GDBM;
#endif
#if defined(WORDS_BIGENDIAN)
  req.xfr_byte_order = XFR_ENDIAN_BIG;
#else
  req.xfr_byte_order = XFR_ENDIAN_LITTLE;
#endif
#elif defined (HAVE_NDBM)
#if defined(__sun__) || defined (sun)
  req.xfr_db_type = XFR_DB_NDBM;
#if defined(WORDS_BIGENDIAN)
  req.xfr_byte_order = XFR_ENDIAN_BIG;
#else
  req.xfr_byte_order = XFR_ENDIAN_LITTLE;
#endif
#else
  req.xfr_db_type = XFR_DB_BSD_NDBM;
  req.xfr_byte_order = XFR_ENDIAN_ANY;
#endif
#elif defined (HAVE_LIBQDBM)
  req.xfr_db_type = XFR_DB_QDBM;
#if defined(WORDS_BIGENDIAN)
  req.xfr_byte_order = XFR_ENDIAN_BIG;
#else
  req.xfr_byte_order = XFR_ENDIAN_LITTLE;
#endif
#elif defined (HAVE_LIBTC)
  req.xfr_db_type = XFR_DB_TC;
  req.xfr_byte_order = XFR_ENDIAN_ANY;
#endif
  memset (&resp, 0, sizeof (resp));

  if ((clnt = clnt_create (host, YPXFRD_FREEBSD_PROG,
                           YPXFRD_FREEBSD_VERS, "tcp")) == NULL)
    goto error;

  if ((ypxfrd_file = open (tmpname, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
    {
      clnt_destroy (clnt);
      log_msg ("couldn't open %s: %s", tmpname, strerror (errno));
      goto error;
    }

  if (clnt_call (clnt, YPXFRD_GETMAP, (xdrproc_t) xdr_ypxfr_mapname,
                 (caddr_t) &req, (xdrproc_t) xdr_ypxfr_xfr,
                 (caddr_t) &resp, timeout) != RPC_SUCCESS)
    {
      log_msg ("%s", clnt_sperror (clnt, "call to rpc.ypxfrd failed"));
      unlink (tmpname);
      clnt_destroy (clnt);
      close (ypxfrd_file);
      goto error;
    }

  clnt_destroy (clnt);
  close (ypxfrd_file);

  if (debug_flag)
    log_msg (" success\n");

  return 0;

error:
  if (debug_flag)
    log_msg (" (failed, fallback to enumeration)\n");
  return 1;
}