 @@ -1,380 +1,378 @@
-/*	$NetBSD: t_rpc.c,v 1.6 2015/11/08 19:38:04 christos Exp $	*/
+/*	$NetBSD: t_rpc.c,v 1.7 2015/11/08 19:40:06 christos Exp $	*/
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_rpc.c,v 1.6 2015/11/08 19:38:04 christos Exp $");
+__RCSID("$NetBSD: t_rpc.c,v 1.7 2015/11/08 19:40:06 christos Exp $");
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <rpc/rpc.h>
 #include <stdlib.h>
 #include <string.h>
 #include <err.h>
 #include <netdb.h>
 #include <stdio.h>
 #include <errno.h>
 #include <unistd.h>
 #define DEBUG
 #define TEST
 #ifndef TEST
 #include <atf-c.h>
 #define ERRX(ev, msg, ...)	ATF_REQUIRE_MSG(0, msg, __VA_ARGS__)
 #define SKIPX(ev, msg, ...)	do {			\
 	atf_tc_skip(msg, __VA_ARGS__);			\
 	return;						\
 } while(/*CONSTCOND*/0)
 #else
 #define ERRX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
 #define SKIPX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
 #endif
 #ifdef DEBUG
 #define DPRINTF(...)	printf(__VA_ARGS__)
 #else
 #define DPRINTF(...)
 #endif
 #define RPCBPROC_NULL 0
 static int
 reply(caddr_t replyp, struct netbuf * raddrp, struct netconfig * nconf)
+{
 	char host[NI_MAXHOST];
 	struct sockaddr *sock = raddrp->buf;
 	int error;
 	error = getnameinfo(sock, sock->sa_len, host, sizeof(host), NULL, 0, 0);
 	if (error)
 		warnx("Cannot resolve address (%s)", gai_strerror(error));
 	else
 		printf("response from: %s\n", host);
 	return 0;
+}
 extern bool_t __rpc_control(int, void *);
 static void
 onehost(const char *host, const char *transp)
+{
 	CLIENT         *clnt;
 	struct netbuf   addr;
 	struct timeval  tv;
 	/*
 	 * Magic!
 	 */
 	tv.tv_sec = 0;
 	tv.tv_usec = 500000;
 #define CLCR_SET_RPCB_TIMEOUT   2
 	__rpc_control(CLCR_SET_RPCB_TIMEOUT, &tv);
 	if ((clnt = clnt_create(host, RPCBPROG, RPCBVERS, transp)) == NULL)
 		SKIPX(EXIT_FAILURE, "clnt_create (%s)", clnt_spcreateerror(""));
 	tv.tv_sec = 1;
 	tv.tv_usec = 0;
 	if (clnt_call(clnt, RPCBPROC_NULL, xdr_void, NULL, xdr_void, NULL, tv)
 	    != RPC_SUCCESS)
 		ERRX(EXIT_FAILURE, "clnt_call (%s)", clnt_sperror(clnt, ""));
 	clnt_control(clnt, CLGET_SVC_ADDR, (char *) &addr);
 	reply(NULL, &addr, NULL);
+}
 #define PROGNUM 0x81
 #define VERSNUM 0x01
 #define PLUSONE 1
 #define DESTROY 2
 static struct timeval 	tout = {1, 0};
 static void
 server(struct svc_req *rqstp, SVCXPRT *transp)
+{
 	int num;
 	DPRINTF("Starting server\n");
 	switch (rqstp->rq_proc) {
 	case NULLPROC:
 		if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
 			ERRX(EXIT_FAILURE, "svc_sendreply failed %d", 0);
 		return;
 	case PLUSONE:
 		break;
 	case DESTROY:
 		if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
 			ERRX(EXIT_FAILURE, "svc_sendreply failed %d", 0);
 		svc_destroy(transp);
 		exit(0);
 	default:
 		svcerr_noproc(transp);
 		return;
+	}
 	if (!svc_getargs(transp, (xdrproc_t)xdr_int, (void *)&num)) {
 		svcerr_decode(transp);
 		return;
+	}
 	DPRINTF("About to increment\n");
 	num++;
 	if (!svc_sendreply(transp, (xdrproc_t)xdr_int, (void *)&num))
 		ERRX(EXIT_FAILURE, "svc_sendreply failed %d", 1);
 	DPRINTF("Leaving server procedure.\n");
+}
 static int
 rawtest(const char *arg)
+{
 	CLIENT         *clnt;
 	SVCXPRT        *svc;
 	int 		num, resp;
 	enum clnt_stat  rv;
 	if (arg)
 		num = atoi(arg);
 	else
 		num = 0;
 	svc = svc_raw_create();
 	if (svc == NULL)
 		ERRX(EXIT_FAILURE, "Can't not create server %d", num);
 	if (!svc_reg(svc, PROGNUM, VERSNUM, server, NULL))
 		ERRX(EXIT_FAILURE, "Can't not register server %d", num);
 	clnt = clnt_raw_create(PROGNUM, VERSNUM);
 	if (clnt == NULL)
 		ERRX(EXIT_FAILURE, "%s",
 		    clnt_spcreateerror("clnt_raw_create"));
 	rv = clnt_call(clnt, PLUSONE, (xdrproc_t)xdr_int, (void *)&num,
 	    (xdrproc_t)xdr_int, (void *)&resp, tout);
 	if (rv != RPC_SUCCESS)
 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
 	DPRINTF("Got %d\n", resp);
 	clnt_destroy(clnt);
 	svc_destroy(svc);
 	if (++num != resp)
 		ERRX(EXIT_FAILURE, "expected %d got %d", num, resp);
 	return EXIT_SUCCESS;
+}
 static int
 regtest(const char *hostname, const char *transp, const char *arg, int p)
+{
 	CLIENT         *clnt;
 	int 		num, resp;
 	enum clnt_stat  rv;
 	pid_t		pid;
 	if (arg)
 		num = atoi(arg);
 	else
 		num = 0;
 	svc_fdset_init(p ? SVC_FDSET_POLL : 0);
 	if (!svc_create(server, PROGNUM, VERSNUM, transp))
 		ERRX(EXIT_FAILURE, "Can't not create server %d", num);
 	switch ((pid = fork())) {
 	case 0:
 		DPRINTF("Calling svc_run\n");
 		svc_run();
 	case -1:
 		ERRX(EXIT_FAILURE, "Fork failed (%s)", strerror(errno));
 	default:
 		sleep(1);
 		break;
+	}
 	DPRINTF("Initializing client\n");
 	clnt = clnt_create(hostname, PROGNUM, VERSNUM, transp);
 	if (clnt == NULL)
 		ERRX(EXIT_FAILURE, "%s",
 		    clnt_spcreateerror("clnt_raw_create"));
 	rv = clnt_call(clnt, PLUSONE, (xdrproc_t)xdr_int, (void *)&num,
 	    (xdrproc_t)xdr_int, (void *)&resp, tout);
 	if (rv != RPC_SUCCESS)
 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
 	DPRINTF("Got %d\n", resp);
 	if (++num != resp)
 		ERRX(EXIT_FAILURE, "expected %d got %d", num, resp);
 	rv = clnt_call(clnt, DESTROY, (xdrproc_t)xdr_void, NULL,
 	    (xdrproc_t)xdr_void, NULL, tout);
 	if (rv != RPC_SUCCESS)
 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
 	clnt_destroy(clnt);
 	return EXIT_SUCCESS;
+}
 #ifdef TEST
 static void
 allhosts(const char *transp)
+{
 	enum clnt_stat  clnt_stat;
 	clnt_stat = rpc_broadcast(RPCBPROG, RPCBVERS, RPCBPROC_NULL,
 	    (xdrproc_t)xdr_void, NULL, (xdrproc_t)xdr_void,
 	    NULL, (resultproc_t)reply, transp);
 	if (clnt_stat != RPC_SUCCESS && clnt_stat != RPC_TIMEDOUT)
 		ERRX(EXIT_FAILURE, "%s", clnt_sperrno(clnt_stat));
+}
 int
 main(int argc, char *argv[])
+{
 	int             ch;
 	int		s, p;
 	const char     *transp = "udp";
 	p = s = 0;
 	while ((ch = getopt(argc, argv, "prstu")) != -1)
 		switch (ch) {
 		case 'p':
 			p = 1;
 			break;
 		case 's':
 			s = 1;
 			break;
 		case 't':
 			transp = "tcp";
 			break;
 		case 'u':
 			transp = "udp";
 			break;
 		case 'r':
 			transp = NULL;
 			break;
 		default:
 			fprintf(stderr,
 			    "Usage: %s -[r|s|t|u] [<hostname>...]\n",
 			    getprogname());
 			return EXIT_FAILURE;
+		}
 	if (argc == optind) {
 		if  (transp)
 			allhosts(transp);
 		else
 			rawtest(NULL);
 	} else {
 		for (; optind < argc; optind++) {
 			if (transp)
 				s == 0 ?
 				    onehost(argv[optind], transp) :
 				    regtest(argv[optind], transp, "1", p);
 			else
 				rawtest(argv[optind]);
+		}
+	}
 	return EXIT_SUCCESS;
+}
 #else
 ATF_TC(get_svc_addr_tcp);
 ATF_TC_HEAD(get_svc_addr_tcp, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks CLGET_SVC_ADDR for tcp");
+}
 ATF_TC_BODY(get_svc_addr_tcp, tc)
+{
 	onehost("localhost", "tcp");
+}
 ATF_TC(get_svc_addr_udp);
 ATF_TC_HEAD(get_svc_addr_udp, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks CLGET_SVC_ADDR for udp");
+}
 ATF_TC_BODY(get_svc_addr_udp, tc)
+{
 	onehost("localhost", "udp");
+}
 ATF_TC(raw);
 ATF_TC_HEAD(raw, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks svc raw");
+}
 ATF_TC_BODY(raw, tc)
+{
 	rawtest(NULL);
+}
 ATF_TC(tcp);
 ATF_TC_HEAD(tcp, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks svc tcp (select)");
+}
 ATF_TC_BODY(tcp, tc)
+{
-	regtest("localhost", "tcp", 1, 0);
+	regtest("localhost", "tcp", "1", 0);
+}
 ATF_TC(udp);
 ATF_TC_HEAD(udp, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks svc udp (select)");
+}
 ATF_TC_BODY(udp, tc)
+{
-	regtest("localhost", "udp", 1, 0);
+	regtest("localhost", "udp", "1", 0);
+}
 ATF_TC(tcp_poll);
 ATF_TC_HEAD(tcp_poll, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks svc tcp (poll)");
+}
 ATF_TC_BODY(tcp_poll, tc)
+{
-	regtest("localhost", "tcp", 1, 1);
+	regtest("localhost", "tcp", "1", 1);
+}
 ATF_TC(udp_poll);
 ATF_TC_HEAD(udp_poll, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks svc udp (poll)");
+}
 ATF_TC_BODY(udp_poll, tc)
+{
-	regtest("localhost", "udp", 1, 1);
+	regtest("localhost", "udp", "1", 1);
+}
 ATF_TP_ADD_TCS(tp)
+{
 	ATF_TP_ADD_TC(tp, get_svc_addr_udp);
 	ATF_TP_ADD_TC(tp, get_svc_addr_tcp);
 	ATF_TP_ADD_TC(tp, raw);
 	ATF_TP_ADD_TC(tp, tcp);
 	ATF_TP_ADD_TC(tp, udp);
 	ATF_TP_ADD_TC(tp, tcp_poll);
 	ATF_TP_ADD_TC(tp, udp_poll);
 	return atf_no_error();
+}
 #endif