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,struct netbuf * raddrp,struct netconfig * nconf)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
onehost(const char * host,const char * transp)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
server(struct svc_req * rqstp,SVCXPRT * transp)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
rawtest(const char * arg)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
regtest(const char * hostname,const char * transp,const char * arg,int p)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
allhosts(const char * transp)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
main(int argc,char * argv[])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);
ATF_TC_HEAD(get_svc_addr_tcp,tc)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
ATF_TC_BODY(get_svc_addr_tcp,tc)302 ATF_TC_BODY(get_svc_addr_tcp, tc)
303 {
304 onehost("localhost", "tcp");
305
306 }
307
308 ATF_TC(get_svc_addr_udp);
ATF_TC_HEAD(get_svc_addr_udp,tc)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
ATF_TC_BODY(get_svc_addr_udp,tc)314 ATF_TC_BODY(get_svc_addr_udp, tc)
315 {
316 onehost("localhost", "udp");
317
318 }
319
320 ATF_TC(raw);
ATF_TC_HEAD(raw,tc)321 ATF_TC_HEAD(raw, tc)
322 {
323 atf_tc_set_md_var(tc, "descr", "Checks svc raw");
324 }
325
ATF_TC_BODY(raw,tc)326 ATF_TC_BODY(raw, tc)
327 {
328 rawtest(NULL);
329
330 }
331
332 ATF_TC(tcp);
ATF_TC_HEAD(tcp,tc)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
ATF_TC_BODY(tcp,tc)341 ATF_TC_BODY(tcp, tc)
342 {
343 regtest("localhost", "tcp", "1", 0);
344
345 }
346
347 ATF_TC(udp);
ATF_TC_HEAD(udp,tc)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
ATF_TC_BODY(udp,tc)356 ATF_TC_BODY(udp, tc)
357 {
358 regtest("localhost", "udp", "1", 0);
359
360 }
361
362 ATF_TC(tcp_poll);
ATF_TC_HEAD(tcp_poll,tc)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
ATF_TC_BODY(tcp_poll,tc)371 ATF_TC_BODY(tcp_poll, tc)
372 {
373 regtest("localhost", "tcp", "1", 1);
374
375 }
376
377 ATF_TC(udp_poll);
ATF_TC_HEAD(udp_poll,tc)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
ATF_TC_BODY(udp_poll,tc)386 ATF_TC_BODY(udp_poll, tc)
387 {
388 regtest("localhost", "udp", "1", 1);
389
390 }
391
ATF_TP_ADD_TCS(tp)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