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