src/scpi/vxi_clnt.c

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