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