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