xref: /freebsd/contrib/netbsd-tests/lib/libc/rpc/t_rpc.c (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
1 /*	$NetBSD: t_rpc.c,v 1.10 2016/08/27 14:36:22 christos Exp $	*/
2 
3 #include <sys/cdefs.h>
4 __RCSID("$NetBSD: t_rpc.c,v 1.10 2016/08/27 14:36:22 christos Exp $");
5 
6 #include <sys/types.h>
7 #include <sys/socket.h>
8 #include <rpc/rpc.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <err.h>
12 #include <netdb.h>
13 #include <stdio.h>
14 #include <errno.h>
15 #include <unistd.h>
16 
17 #ifndef TEST
18 #include <atf-c.h>
19 
20 #define ERRX(ev, msg, ...)	ATF_REQUIRE_MSG(0, msg, __VA_ARGS__)
21 
22 #define SKIPX(ev, msg, ...)	do {			\
23 	atf_tc_skip(msg, __VA_ARGS__);			\
24 	return ev;					\
25 } while(/*CONSTCOND*/0)
26 
27 #else
28 #define ERRX(ev, msg, ...)	errx(EXIT_FAILURE, msg, __VA_ARGS__)
29 #define SKIPX(ev, msg, ...)	errx(EXIT_FAILURE, msg, __VA_ARGS__)
30 #endif
31 
32 #ifdef DEBUG
33 #define DPRINTF(...)	printf(__VA_ARGS__)
34 #else
35 #define DPRINTF(...)
36 #endif
37 
38 
39 #define RPCBPROC_NULL 0
40 
41 static int
42 reply(caddr_t replyp, struct netbuf * raddrp, struct netconfig * nconf)
43 {
44 	char host[NI_MAXHOST];
45 	struct sockaddr *sock = raddrp->buf;
46 	int error;
47 
48 
49 	error = getnameinfo(sock, sock->sa_len, host, sizeof(host), NULL, 0, 0);
50 	if (error)
51 		warnx("Cannot resolve address (%s)", gai_strerror(error));
52 	else
53 		printf("response from: %s\n", host);
54 	return 0;
55 }
56 
57 #ifdef __FreeBSD__
58 #define	__rpc_control	rpc_control
59 #endif
60 
61 extern bool_t __rpc_control(int, void *);
62 
63 static void
64 onehost(const char *host, const char *transp)
65 {
66 	CLIENT         *clnt;
67 	struct netbuf   addr;
68 	struct timeval  tv;
69 
70 	/*
71 	 * Magic!
72 	 */
73 	tv.tv_sec = 0;
74 	tv.tv_usec = 500000;
75 #define CLCR_SET_RPCB_TIMEOUT   2
76 	__rpc_control(CLCR_SET_RPCB_TIMEOUT, &tv);
77 
78 	if ((clnt = clnt_create(host, RPCBPROG, RPCBVERS, transp)) == NULL)
79 		SKIPX(, "clnt_create (%s)", clnt_spcreateerror(""));
80 
81 	tv.tv_sec = 1;
82 	tv.tv_usec = 0;
83 #ifdef __FreeBSD__
84 	if (clnt_call(clnt, RPCBPROC_NULL, (xdrproc_t)xdr_void, NULL,
85 	    (xdrproc_t)xdr_void, NULL, tv)
86 	    != RPC_SUCCESS)
87 #else
88 	if (clnt_call(clnt, RPCBPROC_NULL, xdr_void, NULL, xdr_void, NULL, tv)
89 	    != RPC_SUCCESS)
90 #endif
91 		ERRX(, "clnt_call (%s)", clnt_sperror(clnt, ""));
92 	clnt_control(clnt, CLGET_SVC_ADDR, (char *) &addr);
93 	reply(NULL, &addr, NULL);
94 }
95 
96 #define PROGNUM 0x81
97 #define VERSNUM 0x01
98 #define PLUSONE 1
99 #define DESTROY 2
100 
101 static struct timeval 	tout = {1, 0};
102 
103 static void
104 server(struct svc_req *rqstp, SVCXPRT *transp)
105 {
106 	int num;
107 
108 	DPRINTF("Starting server\n");
109 
110 	switch (rqstp->rq_proc) {
111 	case NULLPROC:
112 		if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
113 			ERRX(, "svc_sendreply failed %d", 0);
114 		return;
115 	case PLUSONE:
116 		break;
117 	case DESTROY:
118 		if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
119 			ERRX(, "svc_sendreply failed %d", 0);
120 		svc_destroy(transp);
121 		exit(0);
122 	default:
123 		svcerr_noproc(transp);
124 		return;
125 	}
126 
127 	if (!svc_getargs(transp, (xdrproc_t)xdr_int, (void *)&num)) {
128 		svcerr_decode(transp);
129 		return;
130 	}
131 	DPRINTF("About to increment\n");
132 	num++;
133 	if (!svc_sendreply(transp, (xdrproc_t)xdr_int, (void *)&num))
134 		ERRX(, "svc_sendreply failed %d", 1);
135 	DPRINTF("Leaving server procedure.\n");
136 }
137 
138 static int
139 rawtest(const char *arg)
140 {
141 	CLIENT         *clnt;
142 	SVCXPRT        *svc;
143 	int 		num, resp;
144 	enum clnt_stat  rv;
145 
146 	if (arg)
147 		num = atoi(arg);
148 	else
149 		num = 0;
150 
151 	svc = svc_raw_create();
152 	if (svc == NULL)
153 		ERRX(EXIT_FAILURE, "Cannot create server %d", num);
154 	if (!svc_reg(svc, PROGNUM, VERSNUM, server, NULL))
155 		ERRX(EXIT_FAILURE, "Cannot register server %d", num);
156 
157 	clnt = clnt_raw_create(PROGNUM, VERSNUM);
158 	if (clnt == NULL)
159 		ERRX(EXIT_FAILURE, "%s",
160 		    clnt_spcreateerror("clnt_raw_create"));
161 	rv = clnt_call(clnt, PLUSONE, (xdrproc_t)xdr_int, (void *)&num,
162 	    (xdrproc_t)xdr_int, (void *)&resp, tout);
163 	if (rv != RPC_SUCCESS)
164 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
165 	DPRINTF("Got %d\n", resp);
166 	clnt_destroy(clnt);
167 	svc_destroy(svc);
168 	if (++num != resp)
169 		ERRX(EXIT_FAILURE, "expected %d got %d", num, resp);
170 
171 	return EXIT_SUCCESS;
172 }
173 
174 static int
175 regtest(const char *hostname, const char *transp, const char *arg, int p)
176 {
177 	CLIENT         *clnt;
178 	int 		num, resp;
179 	enum clnt_stat  rv;
180 	pid_t		pid;
181 
182 	if (arg)
183 		num = atoi(arg);
184 	else
185 		num = 0;
186 
187 #ifdef __NetBSD__
188 	svc_fdset_init(p ? SVC_FDSET_POLL : 0);
189 #endif
190 	if (!svc_create(server, PROGNUM, VERSNUM, transp))
191 	{
192 		SKIPX(EXIT_FAILURE, "Cannot create server %d", num);
193 	}
194 
195 	switch ((pid = fork())) {
196 	case 0:
197 		DPRINTF("Calling svc_run\n");
198 		svc_run();
199 		ERRX(EXIT_FAILURE, "svc_run returned %d!", num);
200 	case -1:
201 		ERRX(EXIT_FAILURE, "Fork failed (%s)", strerror(errno));
202 	default:
203 		sleep(1);
204 		break;
205 	}
206 
207 	DPRINTF("Initializing client\n");
208 	clnt = clnt_create(hostname, PROGNUM, VERSNUM, transp);
209 	if (clnt == NULL)
210 		ERRX(EXIT_FAILURE, "%s",
211 		    clnt_spcreateerror("clnt_raw_create"));
212 	rv = clnt_call(clnt, PLUSONE, (xdrproc_t)xdr_int, (void *)&num,
213 	    (xdrproc_t)xdr_int, (void *)&resp, tout);
214 	if (rv != RPC_SUCCESS)
215 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
216 	DPRINTF("Got %d\n", resp);
217 	if (++num != resp)
218 		ERRX(EXIT_FAILURE, "expected %d got %d", num, resp);
219 	rv = clnt_call(clnt, DESTROY, (xdrproc_t)xdr_void, NULL,
220 	    (xdrproc_t)xdr_void, NULL, tout);
221 	if (rv != RPC_SUCCESS)
222 		ERRX(EXIT_FAILURE, "clnt_call: %s", clnt_sperrno(rv));
223 	clnt_destroy(clnt);
224 
225 	return EXIT_SUCCESS;
226 }
227 
228 
229 #ifdef TEST
230 static void
231 allhosts(const char *transp)
232 {
233 	enum clnt_stat  clnt_stat;
234 
235 	clnt_stat = rpc_broadcast(RPCBPROG, RPCBVERS, RPCBPROC_NULL,
236 	    (xdrproc_t)xdr_void, NULL, (xdrproc_t)xdr_void,
237 	    NULL, (resultproc_t)reply, transp);
238 	if (clnt_stat != RPC_SUCCESS && clnt_stat != RPC_TIMEDOUT)
239 		ERRX(EXIT_FAILURE, "%s", clnt_sperrno(clnt_stat));
240 }
241 
242 int
243 main(int argc, char *argv[])
244 {
245 	int             ch;
246 	int		s, p;
247 	const char     *transp = "udp";
248 
249 	p = s = 0;
250 	while ((ch = getopt(argc, argv, "prstu")) != -1)
251 		switch (ch) {
252 		case 'p':
253 			p = 1;
254 			break;
255 		case 's':
256 			s = 1;
257 			break;
258 		case 't':
259 			transp = "tcp";
260 			break;
261 		case 'u':
262 			transp = "udp";
263 			break;
264 		case 'r':
265 			transp = NULL;
266 			break;
267 		default:
268 			fprintf(stderr,
269 			    "Usage: %s -[r|s|t|u] [<hostname>...]\n",
270 			    getprogname());
271 			return EXIT_FAILURE;
272 		}
273 
274 	if (argc == optind) {
275 		if  (transp)
276 			allhosts(transp);
277 		else
278 			rawtest(NULL);
279 	} else {
280 		for (; optind < argc; optind++) {
281 			if (transp)
282 				s == 0 ?
283 				    onehost(argv[optind], transp) :
284 				    regtest(argv[optind], transp, "1", p);
285 			else
286 				rawtest(argv[optind]);
287 		}
288 	}
289 
290 	return EXIT_SUCCESS;
291 }
292 
293 #else
294 
295 ATF_TC(get_svc_addr_tcp);
296 ATF_TC_HEAD(get_svc_addr_tcp, tc)
297 {
298 	atf_tc_set_md_var(tc, "descr", "Checks CLGET_SVC_ADDR for tcp");
299 
300 }
301 
302 ATF_TC_BODY(get_svc_addr_tcp, tc)
303 {
304 	onehost("localhost", "tcp");
305 
306 }
307 
308 ATF_TC(get_svc_addr_udp);
309 ATF_TC_HEAD(get_svc_addr_udp, tc)
310 {
311 	atf_tc_set_md_var(tc, "descr", "Checks CLGET_SVC_ADDR for udp");
312 }
313 
314 ATF_TC_BODY(get_svc_addr_udp, tc)
315 {
316 	onehost("localhost", "udp");
317 
318 }
319 
320 ATF_TC(raw);
321 ATF_TC_HEAD(raw, tc)
322 {
323 	atf_tc_set_md_var(tc, "descr", "Checks svc raw");
324 }
325 
326 ATF_TC_BODY(raw, tc)
327 {
328 	rawtest(NULL);
329 
330 }
331 
332 ATF_TC(tcp);
333 ATF_TC_HEAD(tcp, tc)
334 {
335 	atf_tc_set_md_var(tc, "descr", "Checks svc tcp (select)");
336 #ifdef __FreeBSD__
337 	atf_tc_set_md_var(tc, "require.user", "root");
338 #endif
339 }
340 
341 ATF_TC_BODY(tcp, tc)
342 {
343 	regtest("localhost", "tcp", "1", 0);
344 
345 }
346 
347 ATF_TC(udp);
348 ATF_TC_HEAD(udp, tc)
349 {
350 	atf_tc_set_md_var(tc, "descr", "Checks svc udp (select)");
351 #ifdef __FreeBSD__
352 	atf_tc_set_md_var(tc, "require.user", "root");
353 #endif
354 }
355 
356 ATF_TC_BODY(udp, tc)
357 {
358 	regtest("localhost", "udp", "1", 0);
359 
360 }
361 
362 ATF_TC(tcp_poll);
363 ATF_TC_HEAD(tcp_poll, tc)
364 {
365 	atf_tc_set_md_var(tc, "descr", "Checks svc tcp (poll)");
366 #ifdef __FreeBSD__
367 	atf_tc_set_md_var(tc, "require.user", "root");
368 #endif
369 }
370 
371 ATF_TC_BODY(tcp_poll, tc)
372 {
373 	regtest("localhost", "tcp", "1", 1);
374 
375 }
376 
377 ATF_TC(udp_poll);
378 ATF_TC_HEAD(udp_poll, tc)
379 {
380 	atf_tc_set_md_var(tc, "descr", "Checks svc udp (poll)");
381 #ifdef __FreeBSD__
382 	atf_tc_set_md_var(tc, "require.user", "root");
383 #endif
384 }
385 
386 ATF_TC_BODY(udp_poll, tc)
387 {
388 	regtest("localhost", "udp", "1", 1);
389 
390 }
391 
392 ATF_TP_ADD_TCS(tp)
393 {
394 	ATF_TP_ADD_TC(tp, get_svc_addr_udp);
395 	ATF_TP_ADD_TC(tp, get_svc_addr_tcp);
396 	ATF_TP_ADD_TC(tp, raw);
397 	ATF_TP_ADD_TC(tp, tcp);
398 	ATF_TP_ADD_TC(tp, udp);
399 	ATF_TP_ADD_TC(tp, tcp_poll);
400 	ATF_TP_ADD_TC(tp, udp_poll);
401 
402 	return atf_no_error();
403 }
404 
405 #endif
406