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