usr.sbin/rpc.lockd/test.c

   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 *
  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 *
  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 *
  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 *
  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 *
  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 *
  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 *
  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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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
 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 }