C++ clnt_create函数代码示例

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);
}