usr.sbin/rpc.lockd/test.c

   1 /*      $NetBSD: test.c,v 1.3 2002/07/20 08:40:20 grant 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.3 2002/07/20 08:40:20 grant 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 }