1 /*
2 * @(#)nlm_prot.x 1.8 87/09/21 Copyr 1987 Sun Micro
3 * @(#)nlm_prot.x 2.1 88/08/01 4.0 RPCSRC
4 * $NetBSD: test.c,v 1.2 1997/10/18 04:01:21 lukem Exp $
5 * $FreeBSD: src/usr.sbin/rpc.lockd/test.c,v 1.5 2001/03/19 12:50:09 alfred Exp $
6 * $DragonFly: src/usr.sbin/rpc.lockd/test.c,v 1.3 2005/11/25 00:32:49 swildner Exp $
7 */
8
9 #include <rpc/rpc.h>
10 #include <rpcsvc/nlm_prot.h>
11
12 /* Default timeout can be changed using clnt_control() */
13 static struct timeval TIMEOUT = { 0, 0 };
14
15 nlm_testres *
nlm_test_1(struct nlm_testargs * argp,CLIENT * clnt)16 nlm_test_1(struct nlm_testargs *argp, CLIENT *clnt)
17 {
18 static nlm_testres res;
19
20 bzero((char *)&res, sizeof(res));
21 if (clnt_call(clnt, NLM_TEST, xdr_nlm_testargs, argp, xdr_nlm_testres, &res, TIMEOUT) != RPC_SUCCESS) {
22 return (NULL);
23 }
24 return (&res);
25 }
26
27
28 nlm_res *
nlm_lock_1(struct nlm_lockargs * argp,CLIENT * clnt)29 nlm_lock_1(struct nlm_lockargs *argp, CLIENT *clnt)
30 {
31 enum clnt_stat st;
32 static nlm_res res;
33
34 bzero((char *)&res, sizeof(res));
35 if (st = clnt_call(clnt, NLM_LOCK, xdr_nlm_lockargs, argp, xdr_nlm_res, &res, TIMEOUT) != RPC_SUCCESS) {
36 printf("clnt_call returns %d\n", st);
37 clnt_perror(clnt, "humbug");
38 return (NULL);
39 }
40 return (&res);
41 }
42
43
44 nlm_res *
nlm_cancel_1(struct nlm_cancargs * argp,CLIENT * clnt)45 nlm_cancel_1(struct nlm_cancargs *argp, CLIENT *clnt)
46 {
47 static nlm_res res;
48
49 bzero((char *)&res, sizeof(res));
50 if (clnt_call(clnt, NLM_CANCEL, xdr_nlm_cancargs, argp, xdr_nlm_res, &res, TIMEOUT) != RPC_SUCCESS) {
51 return (NULL);
52 }
53 return (&res);
54 }
55
56
57 nlm_res *
nlm_unlock_1(struct nlm_unlockargs * argp,CLIENT * clnt)58 nlm_unlock_1(struct nlm_unlockargs *argp, CLIENT *clnt)
59 {
60 static nlm_res res;
61
62 bzero((char *)&res, sizeof(res));
63 if (clnt_call(clnt, NLM_UNLOCK, xdr_nlm_unlockargs, argp, xdr_nlm_res, &res, TIMEOUT) != RPC_SUCCESS) {
64 return (NULL);
65 }
66 return (&res);
67 }
68
69
70 nlm_res *
nlm_granted_1(struct nlm_testargs * argp,CLIENT * clnt)71 nlm_granted_1(struct nlm_testargs *argp, CLIENT *clnt)
72 {
73 static nlm_res res;
74
75 bzero((char *)&res, sizeof(res));
76 if (clnt_call(clnt, NLM_GRANTED, xdr_nlm_testargs, argp, xdr_nlm_res, &res, TIMEOUT) != RPC_SUCCESS) {
77 return (NULL);
78 }
79 return (&res);
80 }
81
82
83 void *
nlm_test_msg_1(struct nlm_testargs * argp,CLIENT * clnt)84 nlm_test_msg_1(struct nlm_testargs *argp, CLIENT *clnt)
85 {
86 static char res;
87
88 bzero((char *)&res, sizeof(res));
89 if (clnt_call(clnt, NLM_TEST_MSG, xdr_nlm_testargs, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
90 return (NULL);
91 }
92 return ((void *)&res);
93 }
94
95
96 void *
nlm_lock_msg_1(struct nlm_lockargs * argp,CLIENT * clnt)97 nlm_lock_msg_1(struct nlm_lockargs *argp, CLIENT *clnt)
98 {
99 static char res;
100
101 bzero((char *)&res, sizeof(res));
102 if (clnt_call(clnt, NLM_LOCK_MSG, xdr_nlm_lockargs, argp, xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) {
103 clnt_perror(clnt, "nlm_lock_msg_1");
104 return (NULL);
105 }
106 return ((void *)&res);
107 }
108
109
110 void *
nlm_cancel_msg_1(struct nlm_cancargs * argp,CLIENT * clnt)111 nlm_cancel_msg_1(struct nlm_cancargs *argp, CLIENT *clnt)
112 {
113 static char res;
114
115 bzero((char *)&res, sizeof(res));
116 if (clnt_call(clnt, NLM_CANCEL_MSG, xdr_nlm_cancargs, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
117 return (NULL);
118 }
119 return ((void *)&res);
120 }
121
122
123 void *
nlm_unlock_msg_1(struct nlm_unlockargs * argp,CLIENT * clnt)124 nlm_unlock_msg_1(struct nlm_unlockargs *argp, CLIENT *clnt)
125 {
126 static char res;
127
128 bzero((char *)&res, sizeof(res));
129 if (clnt_call(clnt, NLM_UNLOCK_MSG, xdr_nlm_unlockargs, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
130 return (NULL);
131 }
132 return ((void *)&res);
133 }
134
135
136 void *
nlm_granted_msg_1(struct nlm_testargs * argp,CLIENT * clnt)137 nlm_granted_msg_1(struct nlm_testargs *argp, CLIENT *clnt)
138 {
139 static char res;
140
141 bzero((char *)&res, sizeof(res));
142 if (clnt_call(clnt, NLM_GRANTED_MSG, xdr_nlm_testargs, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
143 return (NULL);
144 }
145 return ((void *)&res);
146 }
147
148
149 void *
nlm_test_res_1(nlm_testres * argp,CLIENT * clnt)150 nlm_test_res_1(nlm_testres *argp, CLIENT *clnt)
151 {
152 static char res;
153
154 bzero((char *)&res, sizeof(res));
155 if (clnt_call(clnt, NLM_TEST_RES, xdr_nlm_testres, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
156 return (NULL);
157 }
158 return ((void *)&res);
159 }
160
161
162 void *
nlm_lock_res_1(nlm_res * argp,CLIENT * clnt)163 nlm_lock_res_1(nlm_res *argp, CLIENT *clnt)
164 {
165 static char res;
166
167 bzero((char *)&res, sizeof(res));
168 if (clnt_call(clnt, NLM_LOCK_RES, xdr_nlm_res, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
169 return (NULL);
170 }
171 return ((void *)&res);
172 }
173
174
175 void *
nlm_cancel_res_1(nlm_res * argp,CLIENT * clnt)176 nlm_cancel_res_1(nlm_res *argp, CLIENT *clnt)
177 {
178 static char res;
179
180 bzero((char *)&res, sizeof(res));
181 if (clnt_call(clnt, NLM_CANCEL_RES, xdr_nlm_res, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
182 return (NULL);
183 }
184 return ((void *)&res);
185 }
186
187
188 void *
nlm_unlock_res_1(nlm_res * argp,CLIENT * clnt)189 nlm_unlock_res_1(nlm_res *argp, CLIENT *clnt)
190 {
191 static char res;
192
193 bzero((char *)&res, sizeof(res));
194 if (clnt_call(clnt, NLM_UNLOCK_RES, xdr_nlm_res, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
195 return (NULL);
196 }
197 return ((void *)&res);
198 }
199
200
201 void *
nlm_granted_res_1(nlm_res * argp,CLIENT * clnt)202 nlm_granted_res_1(nlm_res *argp, CLIENT *clnt)
203 {
204 static char res;
205
206 bzero((char *)&res, sizeof(res));
207 if (clnt_call(clnt, NLM_GRANTED_RES, xdr_nlm_res, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
208 return (NULL);
209 }
210 return ((void *)&res);
211 }
212
213
214 nlm_shareres *
nlm_share_3(nlm_shareargs * argp,CLIENT * clnt)215 nlm_share_3(nlm_shareargs *argp, CLIENT *clnt)
216 {
217 static nlm_shareres res;
218
219 bzero((char *)&res, sizeof(res));
220 if (clnt_call(clnt, NLM_SHARE, xdr_nlm_shareargs, argp, xdr_nlm_shareres, &res, TIMEOUT) != RPC_SUCCESS) {
221 return (NULL);
222 }
223 return (&res);
224 }
225
226
227 nlm_shareres *
nlm_unshare_3(nlm_shareargs * argp,CLIENT * clnt)228 nlm_unshare_3(nlm_shareargs *argp, CLIENT *clnt)
229 {
230 static nlm_shareres res;
231
232 bzero((char *)&res, sizeof(res));
233 if (clnt_call(clnt, NLM_UNSHARE, xdr_nlm_shareargs, argp, xdr_nlm_shareres, &res, TIMEOUT) != RPC_SUCCESS) {
234 return (NULL);
235 }
236 return (&res);
237 }
238
239
240 nlm_res *
nlm_nm_lock_3(nlm_lockargs * argp,CLIENT * clnt)241 nlm_nm_lock_3(nlm_lockargs *argp, CLIENT *clnt)
242 {
243 static nlm_res res;
244
245 bzero((char *)&res, sizeof(res));
246 if (clnt_call(clnt, NLM_NM_LOCK, xdr_nlm_lockargs, argp, xdr_nlm_res, &res, TIMEOUT) != RPC_SUCCESS) {
247 return (NULL);
248 }
249 return (&res);
250 }
251
252
253 void *
nlm_free_all_3(nlm_notify * argp,CLIENT * clnt)254 nlm_free_all_3(nlm_notify *argp, CLIENT *clnt)
255 {
256 static char res;
257
258 bzero((char *)&res, sizeof(res));
259 if (clnt_call(clnt, NLM_FREE_ALL, xdr_nlm_notify, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
260 return (NULL);
261 }
262 return ((void *)&res);
263 }
264
265
266 int
main(int argc,char ** argv)267 main(int argc, char **argv)
268 {
269 CLIENT *cli;
270 nlm_res res_block;
271 nlm_res *out;
272 nlm_lockargs arg;
273 struct timeval tim;
274
275 printf("Creating client for host %s\n", argv[1]);
276 cli = clnt_create(argv[1], NLM_PROG, NLM_VERS, "udp");
277 if (!cli) {
278 errx(1, "Failed to create client\n");
279 /* NOTREACHED */
280 }
281 clnt_control(cli, CLGET_TIMEOUT, &tim);
282 printf("Default timeout was %d.%d\n", tim.tv_sec, tim.tv_usec);
283 tim.tv_usec = -1;
284 tim.tv_sec = -1;
285 clnt_control(cli, CLSET_TIMEOUT, &tim);
286 clnt_control(cli, CLGET_TIMEOUT, &tim);
287 printf("timeout now %d.%d\n", tim.tv_sec, tim.tv_usec);
288
289
290 arg.cookie.n_len = 4;
291 arg.cookie.n_bytes = "hello";
292 arg.block = 0;
293 arg.exclusive = 0;
294 arg.reclaim = 0;
295 arg.state = 0x1234;
296 arg.alock.caller_name = "localhost";
297 arg.alock.fh.n_len = 32;
298 arg.alock.fh.n_bytes = "\x04\x04\x02\x00\x01\x00\x00\x00\x0c\x00\x00\x00\xff\xff\xff\xd0\x16\x00\x00\x5b\x7c\xff\xff\xff\xec\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x54\xef\xbf\xd7\x94";
299 arg.alock.oh.n_len = 8;
300 arg.alock.oh.n_bytes = "\x00\x00\x02\xff\xff\xff\xd3";
301 arg.alock.svid = 0x5678;
302 arg.alock.l_offset = 0;
303 arg.alock.l_len = 100;
304
305 res_block.stat.stat = nlm_granted;
306 res_block.cookie.n_bytes = "hello";
307 res_block.cookie.n_len = 5;
308
309 #if 0
310 if (nlm_lock_res_1(&res_block, cli))
311 printf("Success!\n");
312 else
313 printf("Fail\n");
314 #else
315 if (out = nlm_lock_msg_1(&arg, cli)) {
316 printf("Success!\n");
317 printf("out->stat = %d", out->stat);
318 } else {
319 printf("Fail\n");
320 }
321 #endif
322
323 return 0;
324 }
325