src/scpi/vxi_clnt.c

   1 /*
   2  * Please do not edit this file.
   3  * It was generated using rpcgen.
   4  */
   5
   6 #include <config.h>
   7 #include "vxi.h"
   8 #include <memory.h> /* for memset */
   9
  10 #define SR_XDRPROC_CALLBACK(f) ((xdrproc_t) (void (*)(void)) (f))
  11
  12 /* Default timeout can be changed using clnt_control() */
  13 static struct timeval TIMEOUT = { 25, 0 };
  14
  15 Device_Error *
  16 device_abort_1(Device_Link *argp, CLIENT *clnt)
  17 {
  18         static Device_Error clnt_res;
  19
  20         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  21         if (clnt_call (clnt, device_abort,
  22                 (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
  23                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
  24                 TIMEOUT) != RPC_SUCCESS) {
  25                 return (NULL);
  26         }
  27         return (&clnt_res);
  28 }
  29
  30 Create_LinkResp *
  31 create_link_1(Create_LinkParms *argp, CLIENT *clnt)
  32 {
  33         static Create_LinkResp clnt_res;
  34
  35         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  36         if (clnt_call (clnt, create_link,
  37                 (xdrproc_t) xdr_Create_LinkParms, (caddr_t) argp,
  38                 (xdrproc_t) xdr_Create_LinkResp, (caddr_t) &clnt_res,
  39                 TIMEOUT) != RPC_SUCCESS) {
  40                 return (NULL);
  41         }
  42         return (&clnt_res);
  43 }
  44
  45 Device_WriteResp *
  46 device_write_1(Device_WriteParms *argp, CLIENT *clnt)
  47 {
  48         static Device_WriteResp clnt_res;
  49
  50         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  51         if (clnt_call (clnt, device_write,
  52                 (xdrproc_t) xdr_Device_WriteParms, (caddr_t) argp,
  53                 (xdrproc_t) xdr_Device_WriteResp, (caddr_t) &clnt_res,
  54                 TIMEOUT) != RPC_SUCCESS) {
  55                 return (NULL);
  56         }
  57         return (&clnt_res);
  58 }
  59
  60 Device_ReadResp *
  61 device_read_1(Device_ReadParms *argp, CLIENT *clnt)
  62 {
  63         static Device_ReadResp clnt_res;
  64
  65         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  66         if (clnt_call (clnt, device_read,
  67                 (xdrproc_t) xdr_Device_ReadParms, (caddr_t) argp,
  68                 (xdrproc_t) xdr_Device_ReadResp, (caddr_t) &clnt_res,
  69                 TIMEOUT) != RPC_SUCCESS) {
  70                 return (NULL);
  71         }
  72         return (&clnt_res);
  73 }
  74
  75 Device_ReadStbResp *
  76 device_readstb_1(Device_GenericParms *argp, CLIENT *clnt)
  77 {
  78         static Device_ReadStbResp clnt_res;
  79
  80         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  81         if (clnt_call (clnt, device_readstb,
  82                 (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
  83                 (xdrproc_t) xdr_Device_ReadStbResp, (caddr_t) &clnt_res,
  84                 TIMEOUT) != RPC_SUCCESS) {
  85                 return (NULL);
  86         }
  87         return (&clnt_res);
  88 }
  89
  90 Device_Error *
  91 device_trigger_1(Device_GenericParms *argp, CLIENT *clnt)
  92 {
  93         static Device_Error clnt_res;
  94
  95         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  96         if (clnt_call (clnt, device_trigger,
  97                 (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
  98                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
  99                 TIMEOUT) != RPC_SUCCESS) {
 100                 return (NULL);
 101         }
 102         return (&clnt_res);
 103 }
 104
 105 Device_Error *
 106 device_clear_1(Device_GenericParms *argp, CLIENT *clnt)
 107 {
 108         static Device_Error clnt_res;
 109
 110         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 111         if (clnt_call (clnt, device_clear,
 112                 (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
 113                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 114                 TIMEOUT) != RPC_SUCCESS) {
 115                 return (NULL);
 116         }
 117         return (&clnt_res);
 118 }
 119
 120 Device_Error *
 121 device_remote_1(Device_GenericParms *argp, CLIENT *clnt)
 122 {
 123         static Device_Error clnt_res;
 124
 125         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 126         if (clnt_call (clnt, device_remote,
 127                 (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
 128                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 129                 TIMEOUT) != RPC_SUCCESS) {
 130                 return (NULL);
 131         }
 132         return (&clnt_res);
 133 }
 134
 135 Device_Error *
 136 device_local_1(Device_GenericParms *argp, CLIENT *clnt)
 137 {
 138         static Device_Error clnt_res;
 139
 140         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 141         if (clnt_call (clnt, device_local,
 142                 (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
 143                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 144                 TIMEOUT) != RPC_SUCCESS) {
 145                 return (NULL);
 146         }
 147         return (&clnt_res);
 148 }
 149
 150 Device_Error *
 151 device_lock_1(Device_LockParms *argp, CLIENT *clnt)
 152 {
 153         static Device_Error clnt_res;
 154
 155         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 156         if (clnt_call (clnt, device_lock,
 157                 (xdrproc_t) xdr_Device_LockParms, (caddr_t) argp,
 158                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 159                 TIMEOUT) != RPC_SUCCESS) {
 160                 return (NULL);
 161         }
 162         return (&clnt_res);
 163 }
 164
 165 Device_Error *
 166 device_unlock_1(Device_Link *argp, CLIENT *clnt)
 167 {
 168         static Device_Error clnt_res;
 169
 170         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 171         if (clnt_call (clnt, device_unlock,
 172                 (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
 173                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 174                 TIMEOUT) != RPC_SUCCESS) {
 175                 return (NULL);
 176         }
 177         return (&clnt_res);
 178 }
 179
 180 Device_Error *
 181 device_enable_srq_1(Device_EnableSrqParms *argp, CLIENT *clnt)
 182 {
 183         static Device_Error clnt_res;
 184
 185         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 186         if (clnt_call (clnt, device_enable_srq,
 187                 (xdrproc_t) xdr_Device_EnableSrqParms, (caddr_t) argp,
 188                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 189                 TIMEOUT) != RPC_SUCCESS) {
 190                 return (NULL);
 191         }
 192         return (&clnt_res);
 193 }
 194
 195 Device_DocmdResp *
 196 device_docmd_1(Device_DocmdParms *argp, CLIENT *clnt)
 197 {
 198         static Device_DocmdResp clnt_res;
 199
 200         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 201         if (clnt_call (clnt, device_docmd,
 202                 (xdrproc_t) xdr_Device_DocmdParms, (caddr_t) argp,
 203                 (xdrproc_t) xdr_Device_DocmdResp, (caddr_t) &clnt_res,
 204                 TIMEOUT) != RPC_SUCCESS) {
 205                 return (NULL);
 206         }
 207         return (&clnt_res);
 208 }
 209
 210 Device_Error *
 211 destroy_link_1(Device_Link *argp, CLIENT *clnt)
 212 {
 213         static Device_Error clnt_res;
 214
 215         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 216         if (clnt_call (clnt, destroy_link,
 217                 (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
 218                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 219                 TIMEOUT) != RPC_SUCCESS) {
 220                 return (NULL);
 221         }
 222         return (&clnt_res);
 223 }
 224
 225 Device_Error *
 226 create_intr_chan_1(Device_RemoteFunc *argp, CLIENT *clnt)
 227 {
 228         static Device_Error clnt_res;
 229
 230         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 231         if (clnt_call (clnt, create_intr_chan,
 232                 (xdrproc_t) xdr_Device_RemoteFunc, (caddr_t) argp,
 233                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 234                 TIMEOUT) != RPC_SUCCESS) {
 235                 return (NULL);
 236         }
 237         return (&clnt_res);
 238 }
 239
 240 Device_Error *
 241 destroy_intr_chan_1(void *argp, CLIENT *clnt)
 242 {
 243         static Device_Error clnt_res;
 244
 245         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 246         if (clnt_call (clnt, destroy_intr_chan,
 247                 SR_XDRPROC_CALLBACK(xdr_void), (caddr_t) argp,
 248                 (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
 249                 TIMEOUT) != RPC_SUCCESS) {
 250                 return (NULL);
 251         }
 252         return (&clnt_res);
 253 }
 254
 255 void *
 256 device_intr_srq_1(Device_SrqParms *argp, CLIENT *clnt)
 257 {
 258         static char clnt_res;
 259
 260         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 261         if (clnt_call (clnt, device_intr_srq,
 262                 (xdrproc_t) xdr_Device_SrqParms, (caddr_t) argp,
 263                 SR_XDRPROC_CALLBACK(xdr_void), (caddr_t) &clnt_res,
 264                 TIMEOUT) != RPC_SUCCESS) {
 265                 return (NULL);
 266         }
 267         return ((void *)&clnt_res);
 268 }