C++ clnttcp_create函数代码示例

/*
 * Get a copy of the current port maps.
 * Calls the pmap service remotely to do get the maps.
 */
struct pmaplist *
pmap_getmaps (struct sockaddr_in *address)
{
    struct pmaplist *head = (struct pmaplist *) NULL;
    int _socket = -1;
    struct timeval minutetimeout;
    CLIENT *client;

    minutetimeout.tv_sec = 60;
    minutetimeout.tv_usec = 0;
    address->sin_port = htons (PMAPPORT);

    /* Don't need a reserved port to get ports from the portmapper.  */
    client = clnttcp_create (address, PMAPPROG,
                             PMAPVERS, &_socket, 50, 500);
    if (client != (CLIENT *) NULL)
    {
        if (CLNT_CALL (client, PMAPPROC_DUMP, (xdrproc_t)xdr_void, NULL,
                       (xdrproc_t)xdr_pmaplist, (caddr_t)&head,
                       minutetimeout) != RPC_SUCCESS)
        {
            clnt_perror (client, _("pmap_getmaps rpc problem"));
        }
        CLNT_DESTROY (client);
    }
    /* (void)close(_socket); CLNT_DESTROY already closed it */
    address->sin_port = 0;
    return head;
}

/*
 * Remove the mapping between program,version and port.
 * Calls the pmap service remotely to do the un-mapping.
 */
bool_t
pmap_unset(
	unsigned long program,
	unsigned long version)
{
	struct sockaddr_in myaddress;
	int sockfd = -1;
	register CLIENT *client;
	struct pmap parms;
	bool_t rslt;

	get_myaddress(&myaddress);
	client = clnttcp_create(&myaddress, PMAPPROG, PMAPVERS,
		&sockfd, 0, 0);
	if (client == (CLIENT *)NULL)
		return (FALSE);
	parms.pm_prog = program;
	parms.pm_vers = version;
	parms.pm_port = parms.pm_prot = 0;
	if (CLNT_CALL(client, PMAPPROC_UNSET, xdr_pmap, &parms, xdr_bool, &rslt,
	    tottimeout) != RPC_SUCCESS) {
		clnt_perror(client, "pmap_unset: Cannot unregister service");
		rslt = FALSE;
	}
	CLNT_DESTROY(client);
	return (rslt);
}

/*
 * Get a copy of the current port maps.
 * Calls the pmap service remotely to do get the maps.
 */
struct pmaplist *
pmap_getmaps(struct sockaddr_in *address)
{
	struct pmaplist *head = NULL;
	int sock = -1;
	struct timeval minutetimeout;
	CLIENT *client;

	assert(address != NULL);

	minutetimeout.tv_sec = 60;
	minutetimeout.tv_usec = 0;
	address->sin_port = htons(PMAPPORT);
	client = clnttcp_create(address, PMAPPROG,
	    PMAPVERS, &sock, 50, 500);
	if (client != NULL) {
		if (CLNT_CALL(client, (rpcproc_t)PMAPPROC_DUMP,
		    (xdrproc_t)xdr_void, NULL,
		    (xdrproc_t)xdr_pmaplist, &head, minutetimeout) !=
		    RPC_SUCCESS) {
			clnt_perror(client, "pmap_getmaps rpc problem");
		}
		CLNT_DESTROY(client);
	}
	address->sin_port = 0;
	return (head);
}

/*
 * Get a copy of the current port maps.
 * Calls the pmap service remotely to do get the maps.
 */
struct pmaplist *
pmap_getmaps (struct sockaddr_in *address)
{
  struct pmaplist *head = (struct pmaplist *) NULL;
  struct timeval minutetimeout;
  CLIENT *client;
  bool closeit = false;

  minutetimeout.tv_sec = 60;
  minutetimeout.tv_usec = 0;
  address->sin_port = htons (PMAPPORT);

  /* Don't need a reserved port to get ports from the portmapper.  */
  int socket = __get_socket (address);
  if (socket != -1)
    closeit = true;

  client = clnttcp_create (address, PMAPPROG, PMAPVERS, &socket, 50, 500);
  if (client != (CLIENT *) NULL)
    {
      if (CLNT_CALL (client, PMAPPROC_DUMP, (xdrproc_t)xdr_void, NULL,
		     (xdrproc_t)xdr_pmaplist, (caddr_t)&head,
		     minutetimeout) != RPC_SUCCESS)
	{
	  clnt_perror (client, _("pmap_getmaps.c: rpc problem"));
	}
      CLNT_DESTROY (client);
    }
  /* We only need to close the socket here if we opened  it.  */
  if (closeit)
    close_not_cancel (socket);
  address->sin_port = 0;
  return head;
}

/**
 * Ensures the existence of a client-side transport on the TCP connection.
 *
 * @param[in] xprt      Server-side RPC transport.
 * @retval    true      Success.
 * @retval    false     System error. `log_start()` called.
 */
static bool
up7_ensureClientTransport(
        struct SVCXPRT* const xprt)
{
    bool status;

    if (NULL == clnt) {
        /*
         * Create a client-side RPC transport on the TCP connection.
         */
        do {
            clnt = clnttcp_create(&xprt->xp_raddr, LDMPROG, SEVEN,
                    &xprt->xp_sock, MAX_RPC_BUF_NEEDED, 0);
            /* TODO: adjust sending buffer size in above */
        } while (clnt == NULL && rpc_createerr.cf_stat == RPC_TIMEDOUT);

        if (clnt == NULL ) {
            LOG_START2("Couldn't create client-side transport to downstream LDM-7 on "
                    "%s%s", hostbyaddr(&xprt->xp_raddr), clnt_spcreateerror(""));
            status = false;
        }
        else {
            status = true;
        }
    }

    return status;
}

void
nfs4_program_4(char *host)
{
	CLIENT *clnt;
	struct sockaddr_in sa;
	int sock = RPC_ANYSOCK;

	memset(&sa, 0, sizeof(sa));
	sa.sin_family = AF_INET;
	sa.sin_port = htons(NFS_TEST_PORT);
	inet_pton(AF_INET, "127.0.0.1", &(sa.sin_addr));

	clnt = clnttcp_create (&sa, NFS4_PROGRAM, NFS_V4, &sock, 0, 0);
	if (clnt == NULL) {
		clnt_pcreateerror (host);
		exit (1);
	}

	clnt->cl_auth = authunix_create_default();

	test(clnt);

#if 0
out:
#endif
	clnt_destroy (clnt);
}

static
int rpc_host_connect(CLIENT **rpc_client, const char *host)
{
    int sock = RPC_ANYSOCK;

    struct hostent *he;
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(DEFAULT_PORT);

    if ((he = gethostbyname(host)) == NULL) {
        LOG_ERR("ERR_gethostbyname(%s): %s", host, hstrerror(h_errno));
        return -1;
    }

    memcpy(&addr.sin_addr, he->h_addr_list[0], he->h_length);

    *rpc_client = clnttcp_create(&addr,
                                 GIGA_RPC_PROG, GIGA_RPC_VERSION,
                                 &sock, 0, 0);
    if (*rpc_client == NULL) {
        LOG_ERR("ERR_rpc_conn: %s", clnt_spcreateerror((char*)host));
        return -1;
    }

    return 0;
}

void notify_1 ()
{
    for (subscriber_list_iterator it = subscriber_list_begin (RD.subscribers);
         it != 0; subscriber_list_iterator_next (&it))
    {
        if (!it->val->clnt)
        {
            struct sockaddr_in addr;
            int sock = RPC_ANYSOCK;
            CLIENT * clnt;

            addr.sin_family = AF_INET;
            addr.sin_port = htons (it->val->port);
            addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);

            clnt = clnttcp_create (&addr, S16_CONFIG_SUBSCRIBER_PROG,
                                   S16_CONFIG_SUBSCRIBER_V1, &sock, 0, 0);
            if (clnt == NULL)
            {
                clnt_pcreateerror ("localhost");
                break;
            }
            it->val->clnt = clnt;
        }
    }
}

/* returns NULL on error or no exports available */
exports get_export_list(char *hostname)
{
	struct hostent *hp;
	struct sockaddr_in server_addr;
	int msock;
	CLIENT *mclient;
	exports exportlist;
	enum clnt_stat clnt_stat;
	struct timeval total_timeout;
	struct timeval pertry_timeout;

	/* get the servers address info all squared away */
	if (inet_aton(hostname, (struct in_addr *) &server_addr.sin_addr.s_addr)) {
		server_addr.sin_family = AF_INET;
	} else {
		if ((hp = gethostbyname(hostname)) == NULL) {
			fprintf(stderr, "%s: can't get address for %s\n",
				program_name, hostname);
			return (NULL);
		}
		server_addr.sin_family = AF_INET;
		memcpy(&server_addr.sin_addr, hp->h_addr, hp->h_length);
	}

	/* create a client object.
	 * first try a UDP client. if not
	 * possible, then fall back to * using UDP*/
	server_addr.sin_port = 0;
	msock = RPC_ANYSOCK;
	if ((mclient = clnttcp_create(&server_addr,
				      MOUNTPROG, MOUNTVERS, &msock, 0, 0)) == NULL) {
		server_addr.sin_port = 0;
		msock = RPC_ANYSOCK;
		pertry_timeout.tv_sec = 3;
		pertry_timeout.tv_usec = 0;
		if ((mclient = clntudp_create(&server_addr,
					      MOUNTPROG, MOUNTVERS, pertry_timeout,
					      &msock)) == NULL) {
			clnt_pcreateerror("mount clntudp_create");
			return (NULL);
		}
	}
	mclient->cl_auth = authunix_create_default();
	total_timeout.tv_sec = 20;
	total_timeout.tv_usec = 0;

	/* Ok, get a list of exports from the server */
	memset(&exportlist, '\0', sizeof(exportlist));
	clnt_stat = clnt_call(mclient, MOUNTPROC_EXPORT,
			      (xdrproc_t) xdr_void, NULL,
			      (xdrproc_t) xdr_exports, (caddr_t) & exportlist,
			      total_timeout);
	if (clnt_stat != RPC_SUCCESS) {
		clnt_perror(mclient, "rpc mount export");
		return (NULL);
	}

	return (exportlist);
}

main(int argc, char *argv[]) {

if (argc < 2) {
printf("usage:%s <hostname>\n",argv[0]);
exit(1);
}

if (argc >2) { len=atoi(argv[2]);  }
if (len > 1024) { len=1024; }

unsigned long PROGRAM=100000;
unsigned long VERSION=2;

struct hostent *hp;
struct sockaddr_in server_addr;
int sock = RPC_ANYSOCK;
register CLIENT *client;
enum clnt_stat clnt_stat;
struct timeval timeout;
timeout.tv_sec = 40;
timeout.tv_usec = 0;


if ((hp = gethostbyname(argv[1])) == NULL) {
printf("Can't resolve %s\n",argv[1]);
exit(0);
}

gethostname(myhost,255);
bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr,hp->h_length);
server_addr.sin_family = AF_INET;
server_addr.sin_port =  0;

if ((client = clnttcp_create(&server_addr,PROGRAM,VERSION,&sock,1024,1024)) == NULL) {
clnt_pcreateerror("clnttcp_create");
exit(0);
}

client->cl_auth = authunix_create(myhost, 0, 0, 0, NULL);

char *data = (char *) malloc(1024);
memset(data,0x0,strlen(data));

char *response = (char *) malloc(1024);
memset(response,0x0,strlen(response));

for (i = 0 ; i < len ; i++) {
memcpy(data+strlen(data),"1",1);
clnt_call(client,1,(xdrproc_t) xdr_wrapstring ,(char *) &data,(xdrproc_t) xdr_wrapstring,(char *)  response,timeout);
}

clnt_call(client,4,(xdrproc_t) xdr_wrapstring ,(char *) &data,(xdrproc_t) xdr_wrapstring,(char *)  response,timeout);

clnt_destroy(client);
close(sock);
free(data);
free(response);
exit(0);
}

/*
 * Generic client creation: takes (hostname, program-number, protocol) and
 * returns client handle. Default options are set, which the user can 
 * change using the rpc equivalent of ioctl()'s.
 */
CLIENT *
clnt_create(char *hostname, u_long prog, u_long vers, char *proto)
{
	struct hostent *h;
	struct protoent *p;
	struct sockaddr_in sin;
	int sock;
	struct timeval tv;
	CLIENT *client;

	h = gethostbyname(hostname);
	if (h == NULL) {
		rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
		return (NULL);
	}
	if (h->h_addrtype != AF_INET) {
		/*
		 * Only support INET for now
		 */
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		rpc_createerr.cf_error.re_errno = EAFNOSUPPORT; 
		return (NULL);
	}
	memset(&sin, 0, sizeof(sin));
	sin.sin_len = sizeof(struct sockaddr_in);
	sin.sin_family = h->h_addrtype;
	sin.sin_port = 0;
	memcpy((char*)&sin.sin_addr, h->h_addr, h->h_length);
	p = getprotobyname(proto);
	if (p == NULL) {
		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
		rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; 
		return (NULL);
	}
	sock = RPC_ANYSOCK;
	switch (p->p_proto) {
	case IPPROTO_UDP:
		tv.tv_sec = 5;
		tv.tv_usec = 0;
		client = clntudp_create(&sin, prog, vers, tv, &sock);
		if (client == NULL) {
			return (NULL);
		}
		break;
	case IPPROTO_TCP:
		client = clnttcp_create(&sin, prog, vers, &sock, 0, 0);
		if (client == NULL) {
			return (NULL);
		}
		break;
	default:
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; 
		return (NULL);
	}
	return (client);
}

CLIENT *
shibrpc_client_create (ShibSocket sock, u_long program, u_long version)
{
  struct sockaddr_in sin;

  memset (&sin, 0, sizeof (sin));
  sin.sin_port = 1;

  return clnttcp_create (&sin, program, version, &sock, 0, 0);
}

static CLIENT*
connect_to_server (struct sockaddr_in *addr) {
    CLIENT *clnt;
    int sockp = RPC_ANYSOCK;
    clnt = clnttcp_create (addr, BAMBOO_DHT_GATEWAY_PROGRAM, 
            BAMBOO_DHT_GATEWAY_VERSION, &sockp, 0, 0);
    if (clnt == NULL) {
        clnt_pcreateerror ("create error");
        exit (1);
    }
    return clnt;
}

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 *clnt = NULL;
	struct sockaddr_in server_addr;
	struct hostent *hp = NULL;
	int sock = RPC_ANYSOCK;
	int nbCall = atoi(argc[3]);
	int nbOk = 0;
	int i;

	//Test initialization
	if ((hp = gethostbyname(argc[1])) == NULL) {
		fprintf(stderr, "can't get addr for %s\n", argc[1]);
		exit(-1);
	}

	bcopy(hp->h_addr, (caddr_t) & server_addr.sin_addr, hp->h_length);
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 0;

	//First of all, create a client
	for (i = 0; i < nbCall; i++) {
		clnt =
		    clnttcp_create(&server_addr, progNum, VERSNUM, &sock, 0, 0);
		if ((CLIENT *) clnt != NULL)
			nbOk++;
	}

	//If we are here, macro call was successful
	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);

	return test_status;
}

static CLIENT *
mkclient(struct sockaddr_in *sin, unsigned long prog, unsigned long vers,
    int tcp)
{
	static struct timeval tv = { 10, 0 };
	int fd = RPC_ANYSOCK;

	if (tcp)
		return clnttcp_create(sin, prog, vers, &fd, 0, 0);
	else
		return clntudp_create(sin, prog, vers, tv, &fd);
}