Don't set _POSIX_C_SOURCE for VXI/RPC related files.
[libsigrok.git] / 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 }