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