?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add a string parameter to server ==> client notification, add a new InfoShutdown...
[jack2.git] / macosx / RPC / JackRPCEngineUser.c
blob7841c0370b17f73d6aa09d6d2ccf0b5d3d2c40dd
1 /*
2 * IDENTIFICATION:
3 * stub generated Tue Oct 20 12:13:26 2009
4 * with a MiG generated Mon May 18 09:59:33 PDT 2009 by root@sulitlana.apple.com
5 * OPTIONS:
6 */
7 #define __MIG_check__Reply__JackRPCEngine_subsystem__ 1
8 #define __NDR_convert__Reply__JackRPCEngine_subsystem__ 1
9 #define __NDR_convert__mig_reply_error_subsystem__ 1
10
11 #include "JackRPCEngine.h"
12
13
14 #ifndef mig_internal
15 #define mig_internal static __inline__
16 #endif /* mig_internal */
17
18 #ifndef mig_external
19 #define mig_external
20 #endif /* mig_external */
21
22 #if !defined(__MigTypeCheck) && defined(TypeCheck)
23 #define __MigTypeCheck TypeCheck /* Legacy setting */
24 #endif /* !defined(__MigTypeCheck) */
25
26 #if !defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
27 #define __MigKernelSpecificCode _MIG_KERNEL_SPECIFIC_CODE_ /* Legacy setting */
28 #endif /* !defined(__MigKernelSpecificCode) */
29
30 #ifndef LimitCheck
31 #define LimitCheck 0
32 #endif /* LimitCheck */
33
34 #ifndef min
35 #define min(a,b) ( ((a) < (b))? (a): (b) )
36 #endif /* min */
37
38 #if !defined(_WALIGN_)
39 #define _WALIGN_(x) (((x) + 3) & ~3)
40 #endif /* !defined(_WALIGN_) */
41
42 #if !defined(_WALIGNSZ_)
43 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
44 #endif /* !defined(_WALIGNSZ_) */
45
46 #ifndef UseStaticTemplates
47 #define UseStaticTemplates 0
48 #endif /* UseStaticTemplates */
49
50 #ifndef __MachMsgErrorWithTimeout
51 #define __MachMsgErrorWithTimeout(_R_) { \
52 switch (_R_) { \
53 case MACH_SEND_INVALID_DATA: \
54 case MACH_SEND_INVALID_DEST: \
55 case MACH_SEND_INVALID_HEADER: \
56 mig_put_reply_port(InP->Head.msgh_reply_port); \
57 break; \
58 case MACH_SEND_TIMED_OUT: \
59 case MACH_RCV_TIMED_OUT: \
60 default: \
61 mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
62 } \
63 }
64 #endif /* __MachMsgErrorWithTimeout */
65
66 #ifndef __MachMsgErrorWithoutTimeout
67 #define __MachMsgErrorWithoutTimeout(_R_) { \
68 switch (_R_) { \
69 case MACH_SEND_INVALID_DATA: \
70 case MACH_SEND_INVALID_DEST: \
71 case MACH_SEND_INVALID_HEADER: \
72 mig_put_reply_port(InP->Head.msgh_reply_port); \
73 break; \
74 default: \
75 mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
76 } \
77 }
78 #endif /* __MachMsgErrorWithoutTimeout */
79
80 #ifndef __DeclareSendRpc
81 #define __DeclareSendRpc(_NUM_, _NAME_)
82 #endif /* __DeclareSendRpc */
83
84 #ifndef __BeforeSendRpc
85 #define __BeforeSendRpc(_NUM_, _NAME_)
86 #endif /* __BeforeSendRpc */
87
88 #ifndef __AfterSendRpc
89 #define __AfterSendRpc(_NUM_, _NAME_)
90 #endif /* __AfterSendRpc */
91
92 #ifndef __DeclareSendSimple
93 #define __DeclareSendSimple(_NUM_, _NAME_)
94 #endif /* __DeclareSendSimple */
95
96 #ifndef __BeforeSendSimple
97 #define __BeforeSendSimple(_NUM_, _NAME_)
98 #endif /* __BeforeSendSimple */
99
100 #ifndef __AfterSendSimple
101 #define __AfterSendSimple(_NUM_, _NAME_)
102 #endif /* __AfterSendSimple */
103
104 #define msgh_request_port msgh_remote_port
105 #define msgh_reply_port msgh_local_port
106
107
108
109 #if ( __MigTypeCheck || __NDR_convert__ )
110 #if __MIG_check__Reply__JackRPCEngine_subsystem__
111 #if !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
112 #define __MIG_check__Reply__rpc_jack_client_open_t__defined
113 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
114 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
115 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
116 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
117 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
118 #elif defined(__NDR_convert__int_rep__int__defined)
119 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
120 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
121 __NDR_convert__int_rep__int((int *)(a), f)
122 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
123 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
124 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
125 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
126 #elif defined(__NDR_convert__int_rep__int32_t__defined)
127 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
128 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
129 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
130 #endif /* defined(__NDR_convert__*__defined) */
131 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
132
133
134 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
135 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
136 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
137 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
138 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
139 #elif defined(__NDR_convert__int_rep__int__defined)
140 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
141 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
142 __NDR_convert__int_rep__int((int *)(a), f)
143 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
144 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
145 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
146 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
147 #elif defined(__NDR_convert__int_rep__int32_t__defined)
148 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined
149 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
150 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
151 #endif /* defined(__NDR_convert__*__defined) */
152 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
153
154
155 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
156 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
157 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
158 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
159 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
160 #elif defined(__NDR_convert__int_rep__int__defined)
161 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
162 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
163 __NDR_convert__int_rep__int((int *)(a), f)
164 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
165 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
166 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
167 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
168 #elif defined(__NDR_convert__int_rep__int32_t__defined)
169 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
170 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
171 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
172 #endif /* defined(__NDR_convert__*__defined) */
173 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
174
175
176 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
177 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
178 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
179 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
180 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
181 #elif defined(__NDR_convert__int_rep__int__defined)
182 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
183 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
184 __NDR_convert__int_rep__int((int *)(a), f)
185 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
186 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
187 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
188 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
189 #elif defined(__NDR_convert__int_rep__int32_t__defined)
190 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined
191 #define __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \
192 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
193 #endif /* defined(__NDR_convert__*__defined) */
194 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
195
196
197 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
198 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
199 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
200 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
201 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
202 #elif defined(__NDR_convert__char_rep__int__defined)
203 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
204 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
205 __NDR_convert__char_rep__int((int *)(a), f)
206 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
207 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
208 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
209 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
210 #elif defined(__NDR_convert__char_rep__int32_t__defined)
211 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
212 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
213 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
214 #endif /* defined(__NDR_convert__*__defined) */
215 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
216
217
218 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
219 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
220 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
221 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
222 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
223 #elif defined(__NDR_convert__char_rep__int__defined)
224 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
225 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
226 __NDR_convert__char_rep__int((int *)(a), f)
227 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
228 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
229 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
230 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
231 #elif defined(__NDR_convert__char_rep__int32_t__defined)
232 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined
233 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
234 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
235 #endif /* defined(__NDR_convert__*__defined) */
236 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
237
238
239 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
240 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
241 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
242 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
243 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
244 #elif defined(__NDR_convert__char_rep__int__defined)
245 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
246 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
247 __NDR_convert__char_rep__int((int *)(a), f)
248 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
249 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
250 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
251 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
252 #elif defined(__NDR_convert__char_rep__int32_t__defined)
253 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
254 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
255 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
256 #endif /* defined(__NDR_convert__*__defined) */
257 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
258
259
260 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
261 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
262 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
263 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
264 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
265 #elif defined(__NDR_convert__char_rep__int__defined)
266 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
267 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
268 __NDR_convert__char_rep__int((int *)(a), f)
269 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
270 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
271 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
272 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
273 #elif defined(__NDR_convert__char_rep__int32_t__defined)
274 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined
275 #define __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \
276 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
277 #endif /* defined(__NDR_convert__*__defined) */
278 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
279
280
281 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
282 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
283 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
284 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
285 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
286 #elif defined(__NDR_convert__float_rep__int__defined)
287 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
288 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
289 __NDR_convert__float_rep__int((int *)(a), f)
290 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
291 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
292 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
293 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
294 #elif defined(__NDR_convert__float_rep__int32_t__defined)
295 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined
296 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \
297 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
298 #endif /* defined(__NDR_convert__*__defined) */
299 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
300
301
302 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
303 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
304 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
305 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
306 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
307 #elif defined(__NDR_convert__float_rep__int__defined)
308 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
309 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
310 __NDR_convert__float_rep__int((int *)(a), f)
311 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
312 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
313 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
314 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
315 #elif defined(__NDR_convert__float_rep__int32_t__defined)
316 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined
317 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \
318 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
319 #endif /* defined(__NDR_convert__*__defined) */
320 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
321
322
323 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
324 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
325 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
326 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
327 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
328 #elif defined(__NDR_convert__float_rep__int__defined)
329 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
330 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
331 __NDR_convert__float_rep__int((int *)(a), f)
332 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
333 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
334 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
335 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
336 #elif defined(__NDR_convert__float_rep__int32_t__defined)
337 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined
338 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \
339 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
340 #endif /* defined(__NDR_convert__*__defined) */
341 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
342
343
344 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
345 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
346 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
347 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
348 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
349 #elif defined(__NDR_convert__float_rep__int__defined)
350 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
351 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
352 __NDR_convert__float_rep__int((int *)(a), f)
353 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
354 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
355 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
356 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
357 #elif defined(__NDR_convert__float_rep__int32_t__defined)
358 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined
359 #define __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \
360 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
361 #endif /* defined(__NDR_convert__*__defined) */
362 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
363
364
365
366 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_open_t(__Reply__rpc_jack_client_open_t *Out0P)
367 {
368
369 typedef __Reply__rpc_jack_client_open_t __Reply;
370 boolean_t msgh_simple;
371 #if __MigTypeCheck
372 unsigned int msgh_size;
373 #endif /* __MigTypeCheck */
374 if (Out0P->Head.msgh_id != 1100) {
375 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
376 { return MIG_SERVER_DIED; }
377 else
378 { return MIG_REPLY_MISMATCH; }
379 }
380
381 msgh_simple = !(Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);
382 #if __MigTypeCheck
383 msgh_size = Out0P->Head.msgh_size;
384
385 if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||
386 msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
387 (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
388 ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))
389 { return MIG_TYPE_ERROR ; }
390 #endif /* __MigTypeCheck */
391
392 if (msgh_simple) {
393 #ifdef __NDR_convert__mig_reply_error_t__defined
394 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
395 #endif /* __NDR_convert__mig_reply_error_t__defined */
396 return ((mig_reply_error_t *)Out0P)->RetCode;
397 }
398
399 #if __MigTypeCheck
400 if (Out0P->private_port.type != MACH_MSG_PORT_DESCRIPTOR ||
401 Out0P->private_port.disposition != 17) {
402 return MIG_TYPE_ERROR;
403 }
404 #endif /* __MigTypeCheck */
405
406 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
407 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
408 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
409 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
410 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
411 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
412 __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.int_rep);
413 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
414 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
415 __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.int_rep);
416 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
417 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
418 __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.int_rep);
419 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
420 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined)
421 __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.int_rep);
422 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */
423 }
424 #endif /* defined(__NDR_convert__int_rep...) */
425
426 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
427 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
428 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
429 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
430 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
431 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
432 __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.char_rep);
433 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
434 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
435 __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.char_rep);
436 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
437 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
438 __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.char_rep);
439 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
440 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined)
441 __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.char_rep);
442 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */
443 }
444 #endif /* defined(__NDR_convert__char_rep...) */
445
446 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined) || \
447 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined) || \
448 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined) || \
449 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
450 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
451 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined)
452 __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(&Out0P->shared_engine, Out0P->NDR.float_rep);
453 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */
454 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined)
455 __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(&Out0P->shared_client, Out0P->NDR.float_rep);
456 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */
457 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined)
458 __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(&Out0P->shared_graph, Out0P->NDR.float_rep);
459 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */
460 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined)
461 __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(&Out0P->result, Out0P->NDR.float_rep);
462 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */
463 }
464 #endif /* defined(__NDR_convert__float_rep...) */
465
466 return MACH_MSG_SUCCESS;
467 }
468 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
469 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
470 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
471
472
473 /* Routine rpc_jack_client_open */
474 mig_external kern_return_t rpc_jack_client_open
475 (
476 mach_port_t server_port,
477 client_name_t client_name,
478 int pid,
479 mach_port_t *private_port,
480 int *shared_engine,
481 int *shared_client,
482 int *shared_graph,
483 int *result
484 )
485 {
486
487 #ifdef __MigPackStructs
488 #pragma pack(4)
489 #endif
490 typedef struct {
491 mach_msg_header_t Head;
492 NDR_record_t NDR;
493 client_name_t client_name;
494 int pid;
495 } Request;
496 #ifdef __MigPackStructs
497 #pragma pack()
498 #endif
499
500 #ifdef __MigPackStructs
501 #pragma pack(4)
502 #endif
503 typedef struct {
504 mach_msg_header_t Head;
505 /* start of the kernel processed data */
506 mach_msg_body_t msgh_body;
507 mach_msg_port_descriptor_t private_port;
508 /* end of the kernel processed data */
509 NDR_record_t NDR;
510 int shared_engine;
511 int shared_client;
512 int shared_graph;
513 int result;
514 mach_msg_trailer_t trailer;
515 } Reply;
516 #ifdef __MigPackStructs
517 #pragma pack()
518 #endif
519
520 #ifdef __MigPackStructs
521 #pragma pack(4)
522 #endif
523 typedef struct {
524 mach_msg_header_t Head;
525 /* start of the kernel processed data */
526 mach_msg_body_t msgh_body;
527 mach_msg_port_descriptor_t private_port;
528 /* end of the kernel processed data */
529 NDR_record_t NDR;
530 int shared_engine;
531 int shared_client;
532 int shared_graph;
533 int result;
534 } __Reply;
535 #ifdef __MigPackStructs
536 #pragma pack()
537 #endif
538 /*
539 * typedef struct {
540 * mach_msg_header_t Head;
541 * NDR_record_t NDR;
542 * kern_return_t RetCode;
543 * } mig_reply_error_t;
544 */
545
546 union {
547 Request In;
548 Reply Out;
549 } Mess;
550
551 Request *InP = &Mess.In;
552 Reply *Out0P = &Mess.Out;
553
554 mach_msg_return_t msg_result;
555
556 #ifdef __MIG_check__Reply__rpc_jack_client_open_t__defined
557 kern_return_t check_result;
558 #endif /* __MIG_check__Reply__rpc_jack_client_open_t__defined */
559
560 __DeclareSendRpc(1000, "rpc_jack_client_open")
561
562 InP->NDR = NDR_record;
563
564 (void) mig_strncpy(InP->client_name, client_name, 128);
565
566 InP->pid = pid;
567
568 InP->Head.msgh_bits =
569 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
570 /* msgh_size passed as argument */
571 InP->Head.msgh_request_port = server_port;
572 InP->Head.msgh_reply_port = mig_get_reply_port();
573 InP->Head.msgh_id = 1000;
574
575 __BeforeSendRpc(1000, "rpc_jack_client_open")
576 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
577 __AfterSendRpc(1000, "rpc_jack_client_open")
578 if (msg_result != MACH_MSG_SUCCESS) {
579 __MachMsgErrorWithoutTimeout(msg_result);
580 { return msg_result; }
581 }
582
583
584 #if defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)
585 check_result = __MIG_check__Reply__rpc_jack_client_open_t((__Reply__rpc_jack_client_open_t *)Out0P);
586 if (check_result != MACH_MSG_SUCCESS)
587 { return check_result; }
588 #endif /* defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */
589
590 *private_port = Out0P->private_port.name;
591 *shared_engine = Out0P->shared_engine;
592
593 *shared_client = Out0P->shared_client;
594
595 *shared_graph = Out0P->shared_graph;
596
597 *result = Out0P->result;
598
599 return KERN_SUCCESS;
600 }
601
602 #if ( __MigTypeCheck || __NDR_convert__ )
603 #if __MIG_check__Reply__JackRPCEngine_subsystem__
604 #if !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
605 #define __MIG_check__Reply__rpc_jack_client_check_t__defined
606 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
607 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
608 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
609 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
610 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
611 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
612 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined
613 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(a, f) \
614 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
615 #endif /* defined(__NDR_convert__*__defined) */
616 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
617
618
619 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
620 #if defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
621 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
622 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
623 __NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
624 #elif defined(__NDR_convert__int_rep__client_name_t__defined)
625 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
626 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
627 __NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
628 #elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
629 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
630 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
631 __NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
632 #elif defined(__NDR_convert__int_rep__string__defined)
633 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
634 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
635 __NDR_convert__int_rep__string(a, f, 128)
636 #endif /* defined(__NDR_convert__*__defined) */
637 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
638
639
640 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
641 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
642 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
643 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
644 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
645 #elif defined(__NDR_convert__int_rep__int__defined)
646 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
647 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
648 __NDR_convert__int_rep__int((int *)(a), f)
649 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
650 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
651 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
652 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
653 #elif defined(__NDR_convert__int_rep__int32_t__defined)
654 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined
655 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \
656 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
657 #endif /* defined(__NDR_convert__*__defined) */
658 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
659
660
661 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
662 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
663 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
664 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
665 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
666 #elif defined(__NDR_convert__int_rep__int__defined)
667 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
668 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
669 __NDR_convert__int_rep__int((int *)(a), f)
670 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
671 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
672 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
673 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
674 #elif defined(__NDR_convert__int_rep__int32_t__defined)
675 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined
676 #define __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \
677 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
678 #endif /* defined(__NDR_convert__*__defined) */
679 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
680
681
682
683 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
684 #if defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
685 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
686 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
687 __NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
688 #elif defined(__NDR_convert__char_rep__client_name_t__defined)
689 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
690 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
691 __NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
692 #elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
693 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
694 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
695 __NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
696 #elif defined(__NDR_convert__char_rep__string__defined)
697 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
698 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
699 __NDR_convert__char_rep__string(a, f, 128)
700 #endif /* defined(__NDR_convert__*__defined) */
701 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
702
703
704 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
705 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
706 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
707 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
708 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
709 #elif defined(__NDR_convert__char_rep__int__defined)
710 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
711 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
712 __NDR_convert__char_rep__int((int *)(a), f)
713 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
714 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
715 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
716 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
717 #elif defined(__NDR_convert__char_rep__int32_t__defined)
718 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined
719 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \
720 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
721 #endif /* defined(__NDR_convert__*__defined) */
722 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
723
724
725 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
726 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
727 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
728 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
729 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
730 #elif defined(__NDR_convert__char_rep__int__defined)
731 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
732 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
733 __NDR_convert__char_rep__int((int *)(a), f)
734 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
735 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
736 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
737 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
738 #elif defined(__NDR_convert__char_rep__int32_t__defined)
739 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined
740 #define __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \
741 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
742 #endif /* defined(__NDR_convert__*__defined) */
743 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
744
745
746
747 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
748 #if defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
749 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
750 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
751 __NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
752 #elif defined(__NDR_convert__float_rep__client_name_t__defined)
753 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
754 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
755 __NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
756 #elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
757 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
758 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
759 __NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
760 #elif defined(__NDR_convert__float_rep__string__defined)
761 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined
762 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \
763 __NDR_convert__float_rep__string(a, f, 128)
764 #endif /* defined(__NDR_convert__*__defined) */
765 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
766
767
768 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
769 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
770 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
771 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
772 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
773 #elif defined(__NDR_convert__float_rep__int__defined)
774 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
775 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
776 __NDR_convert__float_rep__int((int *)(a), f)
777 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
778 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
779 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
780 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
781 #elif defined(__NDR_convert__float_rep__int32_t__defined)
782 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined
783 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \
784 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
785 #endif /* defined(__NDR_convert__*__defined) */
786 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
787
788
789 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
790 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
791 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
792 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
793 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
794 #elif defined(__NDR_convert__float_rep__int__defined)
795 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
796 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
797 __NDR_convert__float_rep__int((int *)(a), f)
798 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
799 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
800 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
801 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
802 #elif defined(__NDR_convert__float_rep__int32_t__defined)
803 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined
804 #define __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \
805 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
806 #endif /* defined(__NDR_convert__*__defined) */
807 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
808
809
810
811 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_check_t(__Reply__rpc_jack_client_check_t *Out0P)
812 {
813
814 typedef __Reply__rpc_jack_client_check_t __Reply;
815 #if __MigTypeCheck
816 unsigned int msgh_size;
817 #endif /* __MigTypeCheck */
818 if (Out0P->Head.msgh_id != 1101) {
819 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
820 { return MIG_SERVER_DIED; }
821 else
822 { return MIG_REPLY_MISMATCH; }
823 }
824
825 #if __MigTypeCheck
826 msgh_size = Out0P->Head.msgh_size;
827
828 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
829 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
830 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
831 Out0P->RetCode == KERN_SUCCESS)))
832 { return MIG_TYPE_ERROR ; }
833 #endif /* __MigTypeCheck */
834
835 if (Out0P->RetCode != KERN_SUCCESS) {
836 #ifdef __NDR_convert__mig_reply_error_t__defined
837 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
838 #endif /* __NDR_convert__mig_reply_error_t__defined */
839 return ((mig_reply_error_t *)Out0P)->RetCode;
840 }
841
842 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined) || \
843 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
844 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined) || \
845 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
846 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
847 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined)
848 __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
849 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */
850 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
851 __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);
852 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
853 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined)
854 __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.int_rep);
855 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */
856 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)
857 __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.int_rep);
858 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */
859 }
860 #endif /* defined(__NDR_convert__int_rep...) */
861
862 #if 0 || \
863 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
864 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined) || \
865 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
866 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
867 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
868 __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);
869 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
870 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined)
871 __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.char_rep);
872 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */
873 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)
874 __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.char_rep);
875 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */
876 }
877 #endif /* defined(__NDR_convert__char_rep...) */
878
879 #if 0 || \
880 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \
881 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined) || \
882 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
883 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
884 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)
885 __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);
886 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */
887 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined)
888 __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.float_rep);
889 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */
890 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)
891 __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.float_rep);
892 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */
893 }
894 #endif /* defined(__NDR_convert__float_rep...) */
895
896 return MACH_MSG_SUCCESS;
897 }
898 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
899 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
900 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
901
902
903 /* Routine rpc_jack_client_check */
904 mig_external kern_return_t rpc_jack_client_check
905 (
906 mach_port_t server_port,
907 client_name_t client_name,
908 client_name_t client_name_res,
909 int protocol,
910 int options,
911 int *status,
912 int *result
913 )
914 {
915
916 #ifdef __MigPackStructs
917 #pragma pack(4)
918 #endif
919 typedef struct {
920 mach_msg_header_t Head;
921 NDR_record_t NDR;
922 client_name_t client_name;
923 int protocol;
924 int options;
925 } Request;
926 #ifdef __MigPackStructs
927 #pragma pack()
928 #endif
929
930 #ifdef __MigPackStructs
931 #pragma pack(4)
932 #endif
933 typedef struct {
934 mach_msg_header_t Head;
935 NDR_record_t NDR;
936 kern_return_t RetCode;
937 client_name_t client_name_res;
938 int status;
939 int result;
940 mach_msg_trailer_t trailer;
941 } Reply;
942 #ifdef __MigPackStructs
943 #pragma pack()
944 #endif
945
946 #ifdef __MigPackStructs
947 #pragma pack(4)
948 #endif
949 typedef struct {
950 mach_msg_header_t Head;
951 NDR_record_t NDR;
952 kern_return_t RetCode;
953 client_name_t client_name_res;
954 int status;
955 int result;
956 } __Reply;
957 #ifdef __MigPackStructs
958 #pragma pack()
959 #endif
960 /*
961 * typedef struct {
962 * mach_msg_header_t Head;
963 * NDR_record_t NDR;
964 * kern_return_t RetCode;
965 * } mig_reply_error_t;
966 */
967
968 union {
969 Request In;
970 Reply Out;
971 } Mess;
972
973 Request *InP = &Mess.In;
974 Reply *Out0P = &Mess.Out;
975
976 mach_msg_return_t msg_result;
977
978 #ifdef __MIG_check__Reply__rpc_jack_client_check_t__defined
979 kern_return_t check_result;
980 #endif /* __MIG_check__Reply__rpc_jack_client_check_t__defined */
981
982 __DeclareSendRpc(1001, "rpc_jack_client_check")
983
984 InP->NDR = NDR_record;
985
986 (void) mig_strncpy(InP->client_name, client_name, 128);
987
988 InP->protocol = protocol;
989
990 InP->options = options;
991
992 InP->Head.msgh_bits =
993 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
994 /* msgh_size passed as argument */
995 InP->Head.msgh_request_port = server_port;
996 InP->Head.msgh_reply_port = mig_get_reply_port();
997 InP->Head.msgh_id = 1001;
998
999 __BeforeSendRpc(1001, "rpc_jack_client_check")
1000 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1001 __AfterSendRpc(1001, "rpc_jack_client_check")
1002 if (msg_result != MACH_MSG_SUCCESS) {
1003 __MachMsgErrorWithoutTimeout(msg_result);
1004 { return msg_result; }
1005 }
1006
1007
1008 #if defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)
1009 check_result = __MIG_check__Reply__rpc_jack_client_check_t((__Reply__rpc_jack_client_check_t *)Out0P);
1010 if (check_result != MACH_MSG_SUCCESS)
1011 { return check_result; }
1012 #endif /* defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */
1013
1014 (void) mig_strncpy(client_name_res, Out0P->client_name_res, 128);
1015
1016 *status = Out0P->status;
1017
1018 *result = Out0P->result;
1019
1020 return KERN_SUCCESS;
1021 }
1022
1023 #if ( __MigTypeCheck || __NDR_convert__ )
1024 #if __MIG_check__Reply__JackRPCEngine_subsystem__
1025 #if !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)
1026 #define __MIG_check__Reply__rpc_jack_client_close_t__defined
1027 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
1028 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
1029 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
1030 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \
1031 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
1032 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
1033 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined
1034 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \
1035 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
1036 #endif /* defined(__NDR_convert__*__defined) */
1037 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */
1038
1039
1040 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
1041 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
1042 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
1043 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1044 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
1045 #elif defined(__NDR_convert__int_rep__int__defined)
1046 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
1047 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1048 __NDR_convert__int_rep__int((int *)(a), f)
1049 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
1050 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
1051 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1052 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1053 #elif defined(__NDR_convert__int_rep__int32_t__defined)
1054 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined
1055 #define __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1056 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
1057 #endif /* defined(__NDR_convert__*__defined) */
1058 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */
1059
1060
1061
1062 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
1063 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
1064 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
1065 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1066 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
1067 #elif defined(__NDR_convert__char_rep__int__defined)
1068 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
1069 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1070 __NDR_convert__char_rep__int((int *)(a), f)
1071 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
1072 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
1073 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1074 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1075 #elif defined(__NDR_convert__char_rep__int32_t__defined)
1076 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined
1077 #define __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1078 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
1079 #endif /* defined(__NDR_convert__*__defined) */
1080 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */
1081
1082
1083
1084 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
1085 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
1086 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
1087 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1088 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
1089 #elif defined(__NDR_convert__float_rep__int__defined)
1090 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
1091 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1092 __NDR_convert__float_rep__int((int *)(a), f)
1093 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
1094 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
1095 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1096 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1097 #elif defined(__NDR_convert__float_rep__int32_t__defined)
1098 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined
1099 #define __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \
1100 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
1101 #endif /* defined(__NDR_convert__*__defined) */
1102 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */
1103
1104
1105
1106 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_close_t(__Reply__rpc_jack_client_close_t *Out0P)
1107 {
1108
1109 typedef __Reply__rpc_jack_client_close_t __Reply;
1110 #if __MigTypeCheck
1111 unsigned int msgh_size;
1112 #endif /* __MigTypeCheck */
1113 if (Out0P->Head.msgh_id != 1102) {
1114 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
1115 { return MIG_SERVER_DIED; }
1116 else
1117 { return MIG_REPLY_MISMATCH; }
1118 }
1119
1120 #if __MigTypeCheck
1121 msgh_size = Out0P->Head.msgh_size;
1122
1123 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1124 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
1125 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
1126 Out0P->RetCode == KERN_SUCCESS)))
1127 { return MIG_TYPE_ERROR ; }
1128 #endif /* __MigTypeCheck */
1129
1130 if (Out0P->RetCode != KERN_SUCCESS) {
1131 #ifdef __NDR_convert__mig_reply_error_t__defined
1132 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
1133 #endif /* __NDR_convert__mig_reply_error_t__defined */
1134 return ((mig_reply_error_t *)Out0P)->RetCode;
1135 }
1136
1137 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined) || \
1138 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)
1139 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
1140 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined)
1141 __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
1142 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */
1143 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)
1144 __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.int_rep);
1145 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */
1146 }
1147 #endif /* defined(__NDR_convert__int_rep...) */
1148
1149 #if 0 || \
1150 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)
1151 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
1152 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)
1153 __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.char_rep);
1154 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */
1155 }
1156 #endif /* defined(__NDR_convert__char_rep...) */
1157
1158 #if 0 || \
1159 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)
1160 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
1161 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)
1162 __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.float_rep);
1163 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */
1164 }
1165 #endif /* defined(__NDR_convert__float_rep...) */
1166
1167 return MACH_MSG_SUCCESS;
1168 }
1169 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */
1170 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
1171 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
1172
1173
1174 /* Routine rpc_jack_client_close */
1175 mig_external kern_return_t rpc_jack_client_close
1176 (
1177 mach_port_t server_port,
1178 int refnum,
1179 int *result
1180 )
1181 {
1182
1183 #ifdef __MigPackStructs
1184 #pragma pack(4)
1185 #endif
1186 typedef struct {
1187 mach_msg_header_t Head;
1188 NDR_record_t NDR;
1189 int refnum;
1190 } Request;
1191 #ifdef __MigPackStructs
1192 #pragma pack()
1193 #endif
1194
1195 #ifdef __MigPackStructs
1196 #pragma pack(4)
1197 #endif
1198 typedef struct {
1199 mach_msg_header_t Head;
1200 NDR_record_t NDR;
1201 kern_return_t RetCode;
1202 int result;
1203 mach_msg_trailer_t trailer;
1204 } Reply;
1205 #ifdef __MigPackStructs
1206 #pragma pack()
1207 #endif
1208
1209 #ifdef __MigPackStructs
1210 #pragma pack(4)
1211 #endif
1212 typedef struct {
1213 mach_msg_header_t Head;
1214 NDR_record_t NDR;
1215 kern_return_t RetCode;
1216 int result;
1217 } __Reply;
1218 #ifdef __MigPackStructs
1219 #pragma pack()
1220 #endif
1221 /*
1222 * typedef struct {
1223 * mach_msg_header_t Head;
1224 * NDR_record_t NDR;
1225 * kern_return_t RetCode;
1226 * } mig_reply_error_t;
1227 */
1228
1229 union {
1230 Request In;
1231 Reply Out;
1232 } Mess;
1233
1234 Request *InP = &Mess.In;
1235 Reply *Out0P = &Mess.Out;
1236
1237 mach_msg_return_t msg_result;
1238
1239 #ifdef __MIG_check__Reply__rpc_jack_client_close_t__defined
1240 kern_return_t check_result;
1241 #endif /* __MIG_check__Reply__rpc_jack_client_close_t__defined */
1242
1243 __DeclareSendRpc(1002, "rpc_jack_client_close")
1244
1245 InP->NDR = NDR_record;
1246
1247 InP->refnum = refnum;
1248
1249 InP->Head.msgh_bits =
1250 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
1251 /* msgh_size passed as argument */
1252 InP->Head.msgh_request_port = server_port;
1253 InP->Head.msgh_reply_port = mig_get_reply_port();
1254 InP->Head.msgh_id = 1002;
1255
1256 __BeforeSendRpc(1002, "rpc_jack_client_close")
1257 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1258 __AfterSendRpc(1002, "rpc_jack_client_close")
1259 if (msg_result != MACH_MSG_SUCCESS) {
1260 __MachMsgErrorWithoutTimeout(msg_result);
1261 { return msg_result; }
1262 }
1263
1264
1265 #if defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)
1266 check_result = __MIG_check__Reply__rpc_jack_client_close_t((__Reply__rpc_jack_client_close_t *)Out0P);
1267 if (check_result != MACH_MSG_SUCCESS)
1268 { return check_result; }
1269 #endif /* defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */
1270
1271 *result = Out0P->result;
1272
1273 return KERN_SUCCESS;
1274 }
1275
1276 #if ( __MigTypeCheck || __NDR_convert__ )
1277 #if __MIG_check__Reply__JackRPCEngine_subsystem__
1278 #if !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)
1279 #define __MIG_check__Reply__rpc_jack_client_activate_t__defined
1280 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
1281 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
1282 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
1283 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \
1284 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
1285 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
1286 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined
1287 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \
1288 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
1289 #endif /* defined(__NDR_convert__*__defined) */
1290 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */
1291
1292
1293 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
1294 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
1295 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
1296 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1297 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
1298 #elif defined(__NDR_convert__int_rep__int__defined)
1299 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
1300 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1301 __NDR_convert__int_rep__int((int *)(a), f)
1302 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
1303 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
1304 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1305 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1306 #elif defined(__NDR_convert__int_rep__int32_t__defined)
1307 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined
1308 #define __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1309 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
1310 #endif /* defined(__NDR_convert__*__defined) */
1311 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */
1312
1313
1314
1315 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
1316 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
1317 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
1318 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1319 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
1320 #elif defined(__NDR_convert__char_rep__int__defined)
1321 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
1322 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1323 __NDR_convert__char_rep__int((int *)(a), f)
1324 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
1325 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
1326 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1327 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1328 #elif defined(__NDR_convert__char_rep__int32_t__defined)
1329 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined
1330 #define __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1331 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
1332 #endif /* defined(__NDR_convert__*__defined) */
1333 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */
1334
1335
1336
1337 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
1338 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
1339 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
1340 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1341 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
1342 #elif defined(__NDR_convert__float_rep__int__defined)
1343 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
1344 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1345 __NDR_convert__float_rep__int((int *)(a), f)
1346 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
1347 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
1348 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1349 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1350 #elif defined(__NDR_convert__float_rep__int32_t__defined)
1351 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined
1352 #define __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \
1353 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
1354 #endif /* defined(__NDR_convert__*__defined) */
1355 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */
1356
1357
1358
1359 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_activate_t(__Reply__rpc_jack_client_activate_t *Out0P)
1360 {
1361
1362 typedef __Reply__rpc_jack_client_activate_t __Reply;
1363 #if __MigTypeCheck
1364 unsigned int msgh_size;
1365 #endif /* __MigTypeCheck */
1366 if (Out0P->Head.msgh_id != 1103) {
1367 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
1368 { return MIG_SERVER_DIED; }
1369 else
1370 { return MIG_REPLY_MISMATCH; }
1371 }
1372
1373 #if __MigTypeCheck
1374 msgh_size = Out0P->Head.msgh_size;
1375
1376 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1377 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
1378 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
1379 Out0P->RetCode == KERN_SUCCESS)))
1380 { return MIG_TYPE_ERROR ; }
1381 #endif /* __MigTypeCheck */
1382
1383 if (Out0P->RetCode != KERN_SUCCESS) {
1384 #ifdef __NDR_convert__mig_reply_error_t__defined
1385 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
1386 #endif /* __NDR_convert__mig_reply_error_t__defined */
1387 return ((mig_reply_error_t *)Out0P)->RetCode;
1388 }
1389
1390 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined) || \
1391 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)
1392 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
1393 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined)
1394 __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
1395 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */
1396 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)
1397 __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.int_rep);
1398 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */
1399 }
1400 #endif /* defined(__NDR_convert__int_rep...) */
1401
1402 #if 0 || \
1403 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)
1404 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
1405 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)
1406 __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.char_rep);
1407 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */
1408 }
1409 #endif /* defined(__NDR_convert__char_rep...) */
1410
1411 #if 0 || \
1412 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)
1413 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
1414 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)
1415 __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.float_rep);
1416 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */
1417 }
1418 #endif /* defined(__NDR_convert__float_rep...) */
1419
1420 return MACH_MSG_SUCCESS;
1421 }
1422 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */
1423 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
1424 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
1425
1426
1427 /* Routine rpc_jack_client_activate */
1428 mig_external kern_return_t rpc_jack_client_activate
1429 (
1430 mach_port_t server_port,
1431 int refnum,
1432 int state,
1433 int *result
1434 )
1435 {
1436
1437 #ifdef __MigPackStructs
1438 #pragma pack(4)
1439 #endif
1440 typedef struct {
1441 mach_msg_header_t Head;
1442 NDR_record_t NDR;
1443 int refnum;
1444 int state;
1445 } Request;
1446 #ifdef __MigPackStructs
1447 #pragma pack()
1448 #endif
1449
1450 #ifdef __MigPackStructs
1451 #pragma pack(4)
1452 #endif
1453 typedef struct {
1454 mach_msg_header_t Head;
1455 NDR_record_t NDR;
1456 kern_return_t RetCode;
1457 int result;
1458 mach_msg_trailer_t trailer;
1459 } Reply;
1460 #ifdef __MigPackStructs
1461 #pragma pack()
1462 #endif
1463
1464 #ifdef __MigPackStructs
1465 #pragma pack(4)
1466 #endif
1467 typedef struct {
1468 mach_msg_header_t Head;
1469 NDR_record_t NDR;
1470 kern_return_t RetCode;
1471 int result;
1472 } __Reply;
1473 #ifdef __MigPackStructs
1474 #pragma pack()
1475 #endif
1476 /*
1477 * typedef struct {
1478 * mach_msg_header_t Head;
1479 * NDR_record_t NDR;
1480 * kern_return_t RetCode;
1481 * } mig_reply_error_t;
1482 */
1483
1484 union {
1485 Request In;
1486 Reply Out;
1487 } Mess;
1488
1489 Request *InP = &Mess.In;
1490 Reply *Out0P = &Mess.Out;
1491
1492 mach_msg_return_t msg_result;
1493
1494 #ifdef __MIG_check__Reply__rpc_jack_client_activate_t__defined
1495 kern_return_t check_result;
1496 #endif /* __MIG_check__Reply__rpc_jack_client_activate_t__defined */
1497
1498 __DeclareSendRpc(1003, "rpc_jack_client_activate")
1499
1500 InP->NDR = NDR_record;
1501
1502 InP->refnum = refnum;
1503
1504 InP->state = state;
1505
1506 InP->Head.msgh_bits =
1507 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
1508 /* msgh_size passed as argument */
1509 InP->Head.msgh_request_port = server_port;
1510 InP->Head.msgh_reply_port = mig_get_reply_port();
1511 InP->Head.msgh_id = 1003;
1512
1513 __BeforeSendRpc(1003, "rpc_jack_client_activate")
1514 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1515 __AfterSendRpc(1003, "rpc_jack_client_activate")
1516 if (msg_result != MACH_MSG_SUCCESS) {
1517 __MachMsgErrorWithoutTimeout(msg_result);
1518 { return msg_result; }
1519 }
1520
1521
1522 #if defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)
1523 check_result = __MIG_check__Reply__rpc_jack_client_activate_t((__Reply__rpc_jack_client_activate_t *)Out0P);
1524 if (check_result != MACH_MSG_SUCCESS)
1525 { return check_result; }
1526 #endif /* defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */
1527
1528 *result = Out0P->result;
1529
1530 return KERN_SUCCESS;
1531 }
1532
1533 #if ( __MigTypeCheck || __NDR_convert__ )
1534 #if __MIG_check__Reply__JackRPCEngine_subsystem__
1535 #if !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)
1536 #define __MIG_check__Reply__rpc_jack_client_deactivate_t__defined
1537 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
1538 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
1539 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
1540 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \
1541 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
1542 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
1543 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined
1544 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \
1545 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
1546 #endif /* defined(__NDR_convert__*__defined) */
1547 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */
1548
1549
1550 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1551 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
1552 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1553 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1554 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
1555 #elif defined(__NDR_convert__int_rep__int__defined)
1556 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1557 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1558 __NDR_convert__int_rep__int((int *)(a), f)
1559 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
1560 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1561 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1562 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1563 #elif defined(__NDR_convert__int_rep__int32_t__defined)
1564 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1565 #define __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1566 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
1567 #endif /* defined(__NDR_convert__*__defined) */
1568 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1569
1570
1571
1572 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1573 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
1574 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1575 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1576 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
1577 #elif defined(__NDR_convert__char_rep__int__defined)
1578 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1579 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1580 __NDR_convert__char_rep__int((int *)(a), f)
1581 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
1582 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1583 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1584 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1585 #elif defined(__NDR_convert__char_rep__int32_t__defined)
1586 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1587 #define __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1588 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
1589 #endif /* defined(__NDR_convert__*__defined) */
1590 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1591
1592
1593
1594 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1595 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
1596 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1597 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1598 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
1599 #elif defined(__NDR_convert__float_rep__int__defined)
1600 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1601 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1602 __NDR_convert__float_rep__int((int *)(a), f)
1603 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
1604 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1605 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1606 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1607 #elif defined(__NDR_convert__float_rep__int32_t__defined)
1608 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined
1609 #define __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \
1610 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
1611 #endif /* defined(__NDR_convert__*__defined) */
1612 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1613
1614
1615
1616 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_deactivate_t(__Reply__rpc_jack_client_deactivate_t *Out0P)
1617 {
1618
1619 typedef __Reply__rpc_jack_client_deactivate_t __Reply;
1620 #if __MigTypeCheck
1621 unsigned int msgh_size;
1622 #endif /* __MigTypeCheck */
1623 if (Out0P->Head.msgh_id != 1104) {
1624 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
1625 { return MIG_SERVER_DIED; }
1626 else
1627 { return MIG_REPLY_MISMATCH; }
1628 }
1629
1630 #if __MigTypeCheck
1631 msgh_size = Out0P->Head.msgh_size;
1632
1633 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1634 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
1635 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
1636 Out0P->RetCode == KERN_SUCCESS)))
1637 { return MIG_TYPE_ERROR ; }
1638 #endif /* __MigTypeCheck */
1639
1640 if (Out0P->RetCode != KERN_SUCCESS) {
1641 #ifdef __NDR_convert__mig_reply_error_t__defined
1642 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
1643 #endif /* __NDR_convert__mig_reply_error_t__defined */
1644 return ((mig_reply_error_t *)Out0P)->RetCode;
1645 }
1646
1647 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined) || \
1648 defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1649 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
1650 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined)
1651 __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
1652 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */
1653 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1654 __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.int_rep);
1655 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1656 }
1657 #endif /* defined(__NDR_convert__int_rep...) */
1658
1659 #if 0 || \
1660 defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1661 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
1662 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1663 __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.char_rep);
1664 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1665 }
1666 #endif /* defined(__NDR_convert__char_rep...) */
1667
1668 #if 0 || \
1669 defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1670 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
1671 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)
1672 __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.float_rep);
1673 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */
1674 }
1675 #endif /* defined(__NDR_convert__float_rep...) */
1676
1677 return MACH_MSG_SUCCESS;
1678 }
1679 #endif /* !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */
1680 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
1681 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
1682
1683
1684 /* Routine rpc_jack_client_deactivate */
1685 mig_external kern_return_t rpc_jack_client_deactivate
1686 (
1687 mach_port_t server_port,
1688 int refnum,
1689 int *result
1690 )
1691 {
1692
1693 #ifdef __MigPackStructs
1694 #pragma pack(4)
1695 #endif
1696 typedef struct {
1697 mach_msg_header_t Head;
1698 NDR_record_t NDR;
1699 int refnum;
1700 } Request;
1701 #ifdef __MigPackStructs
1702 #pragma pack()
1703 #endif
1704
1705 #ifdef __MigPackStructs
1706 #pragma pack(4)
1707 #endif
1708 typedef struct {
1709 mach_msg_header_t Head;
1710 NDR_record_t NDR;
1711 kern_return_t RetCode;
1712 int result;
1713 mach_msg_trailer_t trailer;
1714 } Reply;
1715 #ifdef __MigPackStructs
1716 #pragma pack()
1717 #endif
1718
1719 #ifdef __MigPackStructs
1720 #pragma pack(4)
1721 #endif
1722 typedef struct {
1723 mach_msg_header_t Head;
1724 NDR_record_t NDR;
1725 kern_return_t RetCode;
1726 int result;
1727 } __Reply;
1728 #ifdef __MigPackStructs
1729 #pragma pack()
1730 #endif
1731 /*
1732 * typedef struct {
1733 * mach_msg_header_t Head;
1734 * NDR_record_t NDR;
1735 * kern_return_t RetCode;
1736 * } mig_reply_error_t;
1737 */
1738
1739 union {
1740 Request In;
1741 Reply Out;
1742 } Mess;
1743
1744 Request *InP = &Mess.In;
1745 Reply *Out0P = &Mess.Out;
1746
1747 mach_msg_return_t msg_result;
1748
1749 #ifdef __MIG_check__Reply__rpc_jack_client_deactivate_t__defined
1750 kern_return_t check_result;
1751 #endif /* __MIG_check__Reply__rpc_jack_client_deactivate_t__defined */
1752
1753 __DeclareSendRpc(1004, "rpc_jack_client_deactivate")
1754
1755 InP->NDR = NDR_record;
1756
1757 InP->refnum = refnum;
1758
1759 InP->Head.msgh_bits =
1760 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
1761 /* msgh_size passed as argument */
1762 InP->Head.msgh_request_port = server_port;
1763 InP->Head.msgh_reply_port = mig_get_reply_port();
1764 InP->Head.msgh_id = 1004;
1765
1766 __BeforeSendRpc(1004, "rpc_jack_client_deactivate")
1767 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1768 __AfterSendRpc(1004, "rpc_jack_client_deactivate")
1769 if (msg_result != MACH_MSG_SUCCESS) {
1770 __MachMsgErrorWithoutTimeout(msg_result);
1771 { return msg_result; }
1772 }
1773
1774
1775 #if defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)
1776 check_result = __MIG_check__Reply__rpc_jack_client_deactivate_t((__Reply__rpc_jack_client_deactivate_t *)Out0P);
1777 if (check_result != MACH_MSG_SUCCESS)
1778 { return check_result; }
1779 #endif /* defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */
1780
1781 *result = Out0P->result;
1782
1783 return KERN_SUCCESS;
1784 }
1785
1786 #if ( __MigTypeCheck || __NDR_convert__ )
1787 #if __MIG_check__Reply__JackRPCEngine_subsystem__
1788 #if !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)
1789 #define __MIG_check__Reply__rpc_jack_port_register_t__defined
1790 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
1791 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
1792 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
1793 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \
1794 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
1795 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
1796 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined
1797 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \
1798 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
1799 #endif /* defined(__NDR_convert__*__defined) */
1800 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */
1801
1802
1803 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
1804 #if defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)
1805 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
1806 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1807 __NDR_convert__int_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
1808 #elif defined(__NDR_convert__int_rep__unsigned__defined)
1809 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
1810 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1811 __NDR_convert__int_rep__unsigned((unsigned *)(a), f)
1812 #elif defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)
1813 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
1814 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1815 __NDR_convert__int_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
1816 #elif defined(__NDR_convert__int_rep__uint32_t__defined)
1817 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined
1818 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1819 __NDR_convert__int_rep__uint32_t((uint32_t *)(a), f)
1820 #endif /* defined(__NDR_convert__*__defined) */
1821 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1822
1823
1824 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
1825 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
1826 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
1827 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1828 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
1829 #elif defined(__NDR_convert__int_rep__int__defined)
1830 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
1831 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1832 __NDR_convert__int_rep__int((int *)(a), f)
1833 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
1834 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
1835 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1836 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1837 #elif defined(__NDR_convert__int_rep__int32_t__defined)
1838 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined
1839 #define __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1840 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
1841 #endif /* defined(__NDR_convert__*__defined) */
1842 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */
1843
1844
1845
1846 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
1847 #if defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)
1848 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
1849 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1850 __NDR_convert__char_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
1851 #elif defined(__NDR_convert__char_rep__unsigned__defined)
1852 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
1853 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1854 __NDR_convert__char_rep__unsigned((unsigned *)(a), f)
1855 #elif defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)
1856 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
1857 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1858 __NDR_convert__char_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
1859 #elif defined(__NDR_convert__char_rep__uint32_t__defined)
1860 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined
1861 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1862 __NDR_convert__char_rep__uint32_t((uint32_t *)(a), f)
1863 #endif /* defined(__NDR_convert__*__defined) */
1864 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1865
1866
1867 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
1868 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
1869 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
1870 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1871 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
1872 #elif defined(__NDR_convert__char_rep__int__defined)
1873 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
1874 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1875 __NDR_convert__char_rep__int((int *)(a), f)
1876 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
1877 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
1878 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1879 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1880 #elif defined(__NDR_convert__char_rep__int32_t__defined)
1881 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined
1882 #define __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1883 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
1884 #endif /* defined(__NDR_convert__*__defined) */
1885 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */
1886
1887
1888
1889 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
1890 #if defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)
1891 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
1892 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1893 __NDR_convert__float_rep__JackRPCEngine__unsigned((unsigned *)(a), f)
1894 #elif defined(__NDR_convert__float_rep__unsigned__defined)
1895 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
1896 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1897 __NDR_convert__float_rep__unsigned((unsigned *)(a), f)
1898 #elif defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)
1899 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
1900 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1901 __NDR_convert__float_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)
1902 #elif defined(__NDR_convert__float_rep__uint32_t__defined)
1903 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined
1904 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \
1905 __NDR_convert__float_rep__uint32_t((uint32_t *)(a), f)
1906 #endif /* defined(__NDR_convert__*__defined) */
1907 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1908
1909
1910 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
1911 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
1912 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
1913 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1914 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
1915 #elif defined(__NDR_convert__float_rep__int__defined)
1916 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
1917 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1918 __NDR_convert__float_rep__int((int *)(a), f)
1919 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
1920 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
1921 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1922 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
1923 #elif defined(__NDR_convert__float_rep__int32_t__defined)
1924 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined
1925 #define __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \
1926 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
1927 #endif /* defined(__NDR_convert__*__defined) */
1928 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */
1929
1930
1931
1932 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_register_t(__Reply__rpc_jack_port_register_t *Out0P)
1933 {
1934
1935 typedef __Reply__rpc_jack_port_register_t __Reply;
1936 #if __MigTypeCheck
1937 unsigned int msgh_size;
1938 #endif /* __MigTypeCheck */
1939 if (Out0P->Head.msgh_id != 1105) {
1940 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
1941 { return MIG_SERVER_DIED; }
1942 else
1943 { return MIG_REPLY_MISMATCH; }
1944 }
1945
1946 #if __MigTypeCheck
1947 msgh_size = Out0P->Head.msgh_size;
1948
1949 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1950 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
1951 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
1952 Out0P->RetCode == KERN_SUCCESS)))
1953 { return MIG_TYPE_ERROR ; }
1954 #endif /* __MigTypeCheck */
1955
1956 if (Out0P->RetCode != KERN_SUCCESS) {
1957 #ifdef __NDR_convert__mig_reply_error_t__defined
1958 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
1959 #endif /* __NDR_convert__mig_reply_error_t__defined */
1960 return ((mig_reply_error_t *)Out0P)->RetCode;
1961 }
1962
1963 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined) || \
1964 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
1965 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)
1966 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
1967 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined)
1968 __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
1969 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */
1970 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined)
1971 __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.int_rep);
1972 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1973 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)
1974 __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.int_rep);
1975 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */
1976 }
1977 #endif /* defined(__NDR_convert__int_rep...) */
1978
1979 #if 0 || \
1980 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
1981 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)
1982 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
1983 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined)
1984 __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.char_rep);
1985 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1986 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)
1987 __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.char_rep);
1988 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */
1989 }
1990 #endif /* defined(__NDR_convert__char_rep...) */
1991
1992 #if 0 || \
1993 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \
1994 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)
1995 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
1996 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined)
1997 __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.float_rep);
1998 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */
1999 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)
2000 __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.float_rep);
2001 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */
2002 }
2003 #endif /* defined(__NDR_convert__float_rep...) */
2004
2005 return MACH_MSG_SUCCESS;
2006 }
2007 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */
2008 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
2009 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
2010
2011
2012 /* Routine rpc_jack_port_register */
2013 mig_external kern_return_t rpc_jack_port_register
2014 (
2015 mach_port_t server_port,
2016 int refnum,
2017 client_port_name_t name,
2018 client_port_type_t port_type,
2019 unsigned flags,
2020 unsigned buffer_size,
2021 unsigned *port_index,
2022 int *result
2023 )
2024 {
2025
2026 #ifdef __MigPackStructs
2027 #pragma pack(4)
2028 #endif
2029 typedef struct {
2030 mach_msg_header_t Head;
2031 NDR_record_t NDR;
2032 int refnum;
2033 client_port_name_t name;
2034 client_port_type_t port_type;
2035 unsigned flags;
2036 unsigned buffer_size;
2037 } Request;
2038 #ifdef __MigPackStructs
2039 #pragma pack()
2040 #endif
2041
2042 #ifdef __MigPackStructs
2043 #pragma pack(4)
2044 #endif
2045 typedef struct {
2046 mach_msg_header_t Head;
2047 NDR_record_t NDR;
2048 kern_return_t RetCode;
2049 unsigned port_index;
2050 int result;
2051 mach_msg_trailer_t trailer;
2052 } Reply;
2053 #ifdef __MigPackStructs
2054 #pragma pack()
2055 #endif
2056
2057 #ifdef __MigPackStructs
2058 #pragma pack(4)
2059 #endif
2060 typedef struct {
2061 mach_msg_header_t Head;
2062 NDR_record_t NDR;
2063 kern_return_t RetCode;
2064 unsigned port_index;
2065 int result;
2066 } __Reply;
2067 #ifdef __MigPackStructs
2068 #pragma pack()
2069 #endif
2070 /*
2071 * typedef struct {
2072 * mach_msg_header_t Head;
2073 * NDR_record_t NDR;
2074 * kern_return_t RetCode;
2075 * } mig_reply_error_t;
2076 */
2077
2078 union {
2079 Request In;
2080 Reply Out;
2081 } Mess;
2082
2083 Request *InP = &Mess.In;
2084 Reply *Out0P = &Mess.Out;
2085
2086 mach_msg_return_t msg_result;
2087
2088 #ifdef __MIG_check__Reply__rpc_jack_port_register_t__defined
2089 kern_return_t check_result;
2090 #endif /* __MIG_check__Reply__rpc_jack_port_register_t__defined */
2091
2092 __DeclareSendRpc(1005, "rpc_jack_port_register")
2093
2094 InP->NDR = NDR_record;
2095
2096 InP->refnum = refnum;
2097
2098 (void) mig_strncpy(InP->name, name, 128);
2099
2100 (void) mig_strncpy(InP->port_type, port_type, 128);
2101
2102 InP->flags = flags;
2103
2104 InP->buffer_size = buffer_size;
2105
2106 InP->Head.msgh_bits =
2107 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
2108 /* msgh_size passed as argument */
2109 InP->Head.msgh_request_port = server_port;
2110 InP->Head.msgh_reply_port = mig_get_reply_port();
2111 InP->Head.msgh_id = 1005;
2112
2113 __BeforeSendRpc(1005, "rpc_jack_port_register")
2114 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
2115 __AfterSendRpc(1005, "rpc_jack_port_register")
2116 if (msg_result != MACH_MSG_SUCCESS) {
2117 __MachMsgErrorWithoutTimeout(msg_result);
2118 { return msg_result; }
2119 }
2120
2121
2122 #if defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)
2123 check_result = __MIG_check__Reply__rpc_jack_port_register_t((__Reply__rpc_jack_port_register_t *)Out0P);
2124 if (check_result != MACH_MSG_SUCCESS)
2125 { return check_result; }
2126 #endif /* defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */
2127
2128 *port_index = Out0P->port_index;
2129
2130 *result = Out0P->result;
2131
2132 return KERN_SUCCESS;
2133 }
2134
2135 #if ( __MigTypeCheck || __NDR_convert__ )
2136 #if __MIG_check__Reply__JackRPCEngine_subsystem__
2137 #if !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)
2138 #define __MIG_check__Reply__rpc_jack_port_unregister_t__defined
2139 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
2140 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
2141 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
2142 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \
2143 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
2144 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
2145 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined
2146 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \
2147 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
2148 #endif /* defined(__NDR_convert__*__defined) */
2149 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */
2150
2151
2152 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
2153 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
2154 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
2155 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2156 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
2157 #elif defined(__NDR_convert__int_rep__int__defined)
2158 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
2159 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2160 __NDR_convert__int_rep__int((int *)(a), f)
2161 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
2162 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
2163 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2164 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2165 #elif defined(__NDR_convert__int_rep__int32_t__defined)
2166 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined
2167 #define __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2168 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
2169 #endif /* defined(__NDR_convert__*__defined) */
2170 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2171
2172
2173
2174 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
2175 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
2176 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
2177 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2178 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
2179 #elif defined(__NDR_convert__char_rep__int__defined)
2180 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
2181 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2182 __NDR_convert__char_rep__int((int *)(a), f)
2183 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
2184 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
2185 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2186 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2187 #elif defined(__NDR_convert__char_rep__int32_t__defined)
2188 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined
2189 #define __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2190 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
2191 #endif /* defined(__NDR_convert__*__defined) */
2192 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2193
2194
2195
2196 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
2197 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
2198 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
2199 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2200 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
2201 #elif defined(__NDR_convert__float_rep__int__defined)
2202 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
2203 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2204 __NDR_convert__float_rep__int((int *)(a), f)
2205 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
2206 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
2207 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2208 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2209 #elif defined(__NDR_convert__float_rep__int32_t__defined)
2210 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined
2211 #define __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \
2212 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
2213 #endif /* defined(__NDR_convert__*__defined) */
2214 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2215
2216
2217
2218 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_unregister_t(__Reply__rpc_jack_port_unregister_t *Out0P)
2219 {
2220
2221 typedef __Reply__rpc_jack_port_unregister_t __Reply;
2222 #if __MigTypeCheck
2223 unsigned int msgh_size;
2224 #endif /* __MigTypeCheck */
2225 if (Out0P->Head.msgh_id != 1106) {
2226 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
2227 { return MIG_SERVER_DIED; }
2228 else
2229 { return MIG_REPLY_MISMATCH; }
2230 }
2231
2232 #if __MigTypeCheck
2233 msgh_size = Out0P->Head.msgh_size;
2234
2235 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2236 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
2237 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
2238 Out0P->RetCode == KERN_SUCCESS)))
2239 { return MIG_TYPE_ERROR ; }
2240 #endif /* __MigTypeCheck */
2241
2242 if (Out0P->RetCode != KERN_SUCCESS) {
2243 #ifdef __NDR_convert__mig_reply_error_t__defined
2244 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
2245 #endif /* __NDR_convert__mig_reply_error_t__defined */
2246 return ((mig_reply_error_t *)Out0P)->RetCode;
2247 }
2248
2249 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined) || \
2250 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2251 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
2252 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined)
2253 __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
2254 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */
2255 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2256 __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.int_rep);
2257 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2258 }
2259 #endif /* defined(__NDR_convert__int_rep...) */
2260
2261 #if 0 || \
2262 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2263 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
2264 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2265 __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.char_rep);
2266 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2267 }
2268 #endif /* defined(__NDR_convert__char_rep...) */
2269
2270 #if 0 || \
2271 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2272 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
2273 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)
2274 __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.float_rep);
2275 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */
2276 }
2277 #endif /* defined(__NDR_convert__float_rep...) */
2278
2279 return MACH_MSG_SUCCESS;
2280 }
2281 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */
2282 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
2283 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
2284
2285
2286 /* Routine rpc_jack_port_unregister */
2287 mig_external kern_return_t rpc_jack_port_unregister
2288 (
2289 mach_port_t server_port,
2290 int refnum,
2291 int port,
2292 int *result
2293 )
2294 {
2295
2296 #ifdef __MigPackStructs
2297 #pragma pack(4)
2298 #endif
2299 typedef struct {
2300 mach_msg_header_t Head;
2301 NDR_record_t NDR;
2302 int refnum;
2303 int port;
2304 } Request;
2305 #ifdef __MigPackStructs
2306 #pragma pack()
2307 #endif
2308
2309 #ifdef __MigPackStructs
2310 #pragma pack(4)
2311 #endif
2312 typedef struct {
2313 mach_msg_header_t Head;
2314 NDR_record_t NDR;
2315 kern_return_t RetCode;
2316 int result;
2317 mach_msg_trailer_t trailer;
2318 } Reply;
2319 #ifdef __MigPackStructs
2320 #pragma pack()
2321 #endif
2322
2323 #ifdef __MigPackStructs
2324 #pragma pack(4)
2325 #endif
2326 typedef struct {
2327 mach_msg_header_t Head;
2328 NDR_record_t NDR;
2329 kern_return_t RetCode;
2330 int result;
2331 } __Reply;
2332 #ifdef __MigPackStructs
2333 #pragma pack()
2334 #endif
2335 /*
2336 * typedef struct {
2337 * mach_msg_header_t Head;
2338 * NDR_record_t NDR;
2339 * kern_return_t RetCode;
2340 * } mig_reply_error_t;
2341 */
2342
2343 union {
2344 Request In;
2345 Reply Out;
2346 } Mess;
2347
2348 Request *InP = &Mess.In;
2349 Reply *Out0P = &Mess.Out;
2350
2351 mach_msg_return_t msg_result;
2352
2353 #ifdef __MIG_check__Reply__rpc_jack_port_unregister_t__defined
2354 kern_return_t check_result;
2355 #endif /* __MIG_check__Reply__rpc_jack_port_unregister_t__defined */
2356
2357 __DeclareSendRpc(1006, "rpc_jack_port_unregister")
2358
2359 InP->NDR = NDR_record;
2360
2361 InP->refnum = refnum;
2362
2363 InP->port = port;
2364
2365 InP->Head.msgh_bits =
2366 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
2367 /* msgh_size passed as argument */
2368 InP->Head.msgh_request_port = server_port;
2369 InP->Head.msgh_reply_port = mig_get_reply_port();
2370 InP->Head.msgh_id = 1006;
2371
2372 __BeforeSendRpc(1006, "rpc_jack_port_unregister")
2373 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
2374 __AfterSendRpc(1006, "rpc_jack_port_unregister")
2375 if (msg_result != MACH_MSG_SUCCESS) {
2376 __MachMsgErrorWithoutTimeout(msg_result);
2377 { return msg_result; }
2378 }
2379
2380
2381 #if defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)
2382 check_result = __MIG_check__Reply__rpc_jack_port_unregister_t((__Reply__rpc_jack_port_unregister_t *)Out0P);
2383 if (check_result != MACH_MSG_SUCCESS)
2384 { return check_result; }
2385 #endif /* defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */
2386
2387 *result = Out0P->result;
2388
2389 return KERN_SUCCESS;
2390 }
2391
2392 #if ( __MigTypeCheck || __NDR_convert__ )
2393 #if __MIG_check__Reply__JackRPCEngine_subsystem__
2394 #if !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)
2395 #define __MIG_check__Reply__rpc_jack_port_connect_t__defined
2396 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
2397 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
2398 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
2399 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \
2400 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
2401 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
2402 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined
2403 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \
2404 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
2405 #endif /* defined(__NDR_convert__*__defined) */
2406 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */
2407
2408
2409 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
2410 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
2411 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
2412 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2413 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
2414 #elif defined(__NDR_convert__int_rep__int__defined)
2415 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
2416 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2417 __NDR_convert__int_rep__int((int *)(a), f)
2418 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
2419 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
2420 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2421 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2422 #elif defined(__NDR_convert__int_rep__int32_t__defined)
2423 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined
2424 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2425 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
2426 #endif /* defined(__NDR_convert__*__defined) */
2427 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */
2428
2429
2430
2431 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
2432 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
2433 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
2434 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2435 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
2436 #elif defined(__NDR_convert__char_rep__int__defined)
2437 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
2438 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2439 __NDR_convert__char_rep__int((int *)(a), f)
2440 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
2441 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
2442 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2443 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2444 #elif defined(__NDR_convert__char_rep__int32_t__defined)
2445 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined
2446 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2447 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
2448 #endif /* defined(__NDR_convert__*__defined) */
2449 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */
2450
2451
2452
2453 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
2454 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
2455 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
2456 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2457 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
2458 #elif defined(__NDR_convert__float_rep__int__defined)
2459 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
2460 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2461 __NDR_convert__float_rep__int((int *)(a), f)
2462 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
2463 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
2464 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2465 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2466 #elif defined(__NDR_convert__float_rep__int32_t__defined)
2467 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined
2468 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \
2469 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
2470 #endif /* defined(__NDR_convert__*__defined) */
2471 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */
2472
2473
2474
2475 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_t(__Reply__rpc_jack_port_connect_t *Out0P)
2476 {
2477
2478 typedef __Reply__rpc_jack_port_connect_t __Reply;
2479 #if __MigTypeCheck
2480 unsigned int msgh_size;
2481 #endif /* __MigTypeCheck */
2482 if (Out0P->Head.msgh_id != 1107) {
2483 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
2484 { return MIG_SERVER_DIED; }
2485 else
2486 { return MIG_REPLY_MISMATCH; }
2487 }
2488
2489 #if __MigTypeCheck
2490 msgh_size = Out0P->Head.msgh_size;
2491
2492 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2493 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
2494 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
2495 Out0P->RetCode == KERN_SUCCESS)))
2496 { return MIG_TYPE_ERROR ; }
2497 #endif /* __MigTypeCheck */
2498
2499 if (Out0P->RetCode != KERN_SUCCESS) {
2500 #ifdef __NDR_convert__mig_reply_error_t__defined
2501 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
2502 #endif /* __NDR_convert__mig_reply_error_t__defined */
2503 return ((mig_reply_error_t *)Out0P)->RetCode;
2504 }
2505
2506 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined) || \
2507 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)
2508 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
2509 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined)
2510 __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
2511 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */
2512 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)
2513 __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.int_rep);
2514 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */
2515 }
2516 #endif /* defined(__NDR_convert__int_rep...) */
2517
2518 #if 0 || \
2519 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)
2520 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
2521 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)
2522 __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.char_rep);
2523 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */
2524 }
2525 #endif /* defined(__NDR_convert__char_rep...) */
2526
2527 #if 0 || \
2528 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)
2529 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
2530 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)
2531 __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.float_rep);
2532 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */
2533 }
2534 #endif /* defined(__NDR_convert__float_rep...) */
2535
2536 return MACH_MSG_SUCCESS;
2537 }
2538 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */
2539 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
2540 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
2541
2542
2543 /* Routine rpc_jack_port_connect */
2544 mig_external kern_return_t rpc_jack_port_connect
2545 (
2546 mach_port_t server_port,
2547 int refnum,
2548 int src,
2549 int dst,
2550 int *result
2551 )
2552 {
2553
2554 #ifdef __MigPackStructs
2555 #pragma pack(4)
2556 #endif
2557 typedef struct {
2558 mach_msg_header_t Head;
2559 NDR_record_t NDR;
2560 int refnum;
2561 int src;
2562 int dst;
2563 } Request;
2564 #ifdef __MigPackStructs
2565 #pragma pack()
2566 #endif
2567
2568 #ifdef __MigPackStructs
2569 #pragma pack(4)
2570 #endif
2571 typedef struct {
2572 mach_msg_header_t Head;
2573 NDR_record_t NDR;
2574 kern_return_t RetCode;
2575 int result;
2576 mach_msg_trailer_t trailer;
2577 } Reply;
2578 #ifdef __MigPackStructs
2579 #pragma pack()
2580 #endif
2581
2582 #ifdef __MigPackStructs
2583 #pragma pack(4)
2584 #endif
2585 typedef struct {
2586 mach_msg_header_t Head;
2587 NDR_record_t NDR;
2588 kern_return_t RetCode;
2589 int result;
2590 } __Reply;
2591 #ifdef __MigPackStructs
2592 #pragma pack()
2593 #endif
2594 /*
2595 * typedef struct {
2596 * mach_msg_header_t Head;
2597 * NDR_record_t NDR;
2598 * kern_return_t RetCode;
2599 * } mig_reply_error_t;
2600 */
2601
2602 union {
2603 Request In;
2604 Reply Out;
2605 } Mess;
2606
2607 Request *InP = &Mess.In;
2608 Reply *Out0P = &Mess.Out;
2609
2610 mach_msg_return_t msg_result;
2611
2612 #ifdef __MIG_check__Reply__rpc_jack_port_connect_t__defined
2613 kern_return_t check_result;
2614 #endif /* __MIG_check__Reply__rpc_jack_port_connect_t__defined */
2615
2616 __DeclareSendRpc(1007, "rpc_jack_port_connect")
2617
2618 InP->NDR = NDR_record;
2619
2620 InP->refnum = refnum;
2621
2622 InP->src = src;
2623
2624 InP->dst = dst;
2625
2626 InP->Head.msgh_bits =
2627 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
2628 /* msgh_size passed as argument */
2629 InP->Head.msgh_request_port = server_port;
2630 InP->Head.msgh_reply_port = mig_get_reply_port();
2631 InP->Head.msgh_id = 1007;
2632
2633 __BeforeSendRpc(1007, "rpc_jack_port_connect")
2634 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
2635 __AfterSendRpc(1007, "rpc_jack_port_connect")
2636 if (msg_result != MACH_MSG_SUCCESS) {
2637 __MachMsgErrorWithoutTimeout(msg_result);
2638 { return msg_result; }
2639 }
2640
2641
2642 #if defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)
2643 check_result = __MIG_check__Reply__rpc_jack_port_connect_t((__Reply__rpc_jack_port_connect_t *)Out0P);
2644 if (check_result != MACH_MSG_SUCCESS)
2645 { return check_result; }
2646 #endif /* defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */
2647
2648 *result = Out0P->result;
2649
2650 return KERN_SUCCESS;
2651 }
2652
2653 #if ( __MigTypeCheck || __NDR_convert__ )
2654 #if __MIG_check__Reply__JackRPCEngine_subsystem__
2655 #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)
2656 #define __MIG_check__Reply__rpc_jack_port_disconnect_t__defined
2657 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
2658 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
2659 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
2660 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \
2661 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
2662 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
2663 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined
2664 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \
2665 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
2666 #endif /* defined(__NDR_convert__*__defined) */
2667 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */
2668
2669
2670 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2671 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
2672 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2673 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2674 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
2675 #elif defined(__NDR_convert__int_rep__int__defined)
2676 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2677 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2678 __NDR_convert__int_rep__int((int *)(a), f)
2679 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
2680 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2681 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2682 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2683 #elif defined(__NDR_convert__int_rep__int32_t__defined)
2684 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2685 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2686 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
2687 #endif /* defined(__NDR_convert__*__defined) */
2688 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2689
2690
2691
2692 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2693 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
2694 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2695 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2696 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
2697 #elif defined(__NDR_convert__char_rep__int__defined)
2698 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2699 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2700 __NDR_convert__char_rep__int((int *)(a), f)
2701 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
2702 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2703 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2704 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2705 #elif defined(__NDR_convert__char_rep__int32_t__defined)
2706 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2707 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2708 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
2709 #endif /* defined(__NDR_convert__*__defined) */
2710 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2711
2712
2713
2714 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2715 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
2716 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2717 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2718 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
2719 #elif defined(__NDR_convert__float_rep__int__defined)
2720 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2721 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2722 __NDR_convert__float_rep__int((int *)(a), f)
2723 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
2724 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2725 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2726 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2727 #elif defined(__NDR_convert__float_rep__int32_t__defined)
2728 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined
2729 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \
2730 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
2731 #endif /* defined(__NDR_convert__*__defined) */
2732 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2733
2734
2735
2736 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_t(__Reply__rpc_jack_port_disconnect_t *Out0P)
2737 {
2738
2739 typedef __Reply__rpc_jack_port_disconnect_t __Reply;
2740 #if __MigTypeCheck
2741 unsigned int msgh_size;
2742 #endif /* __MigTypeCheck */
2743 if (Out0P->Head.msgh_id != 1108) {
2744 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
2745 { return MIG_SERVER_DIED; }
2746 else
2747 { return MIG_REPLY_MISMATCH; }
2748 }
2749
2750 #if __MigTypeCheck
2751 msgh_size = Out0P->Head.msgh_size;
2752
2753 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2754 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
2755 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
2756 Out0P->RetCode == KERN_SUCCESS)))
2757 { return MIG_TYPE_ERROR ; }
2758 #endif /* __MigTypeCheck */
2759
2760 if (Out0P->RetCode != KERN_SUCCESS) {
2761 #ifdef __NDR_convert__mig_reply_error_t__defined
2762 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
2763 #endif /* __NDR_convert__mig_reply_error_t__defined */
2764 return ((mig_reply_error_t *)Out0P)->RetCode;
2765 }
2766
2767 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined) || \
2768 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2769 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
2770 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined)
2771 __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
2772 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */
2773 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2774 __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.int_rep);
2775 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2776 }
2777 #endif /* defined(__NDR_convert__int_rep...) */
2778
2779 #if 0 || \
2780 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2781 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
2782 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2783 __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.char_rep);
2784 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2785 }
2786 #endif /* defined(__NDR_convert__char_rep...) */
2787
2788 #if 0 || \
2789 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2790 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
2791 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)
2792 __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.float_rep);
2793 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */
2794 }
2795 #endif /* defined(__NDR_convert__float_rep...) */
2796
2797 return MACH_MSG_SUCCESS;
2798 }
2799 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */
2800 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
2801 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
2802
2803
2804 /* Routine rpc_jack_port_disconnect */
2805 mig_external kern_return_t rpc_jack_port_disconnect
2806 (
2807 mach_port_t server_port,
2808 int refnum,
2809 int src,
2810 int dst,
2811 int *result
2812 )
2813 {
2814
2815 #ifdef __MigPackStructs
2816 #pragma pack(4)
2817 #endif
2818 typedef struct {
2819 mach_msg_header_t Head;
2820 NDR_record_t NDR;
2821 int refnum;
2822 int src;
2823 int dst;
2824 } Request;
2825 #ifdef __MigPackStructs
2826 #pragma pack()
2827 #endif
2828
2829 #ifdef __MigPackStructs
2830 #pragma pack(4)
2831 #endif
2832 typedef struct {
2833 mach_msg_header_t Head;
2834 NDR_record_t NDR;
2835 kern_return_t RetCode;
2836 int result;
2837 mach_msg_trailer_t trailer;
2838 } Reply;
2839 #ifdef __MigPackStructs
2840 #pragma pack()
2841 #endif
2842
2843 #ifdef __MigPackStructs
2844 #pragma pack(4)
2845 #endif
2846 typedef struct {
2847 mach_msg_header_t Head;
2848 NDR_record_t NDR;
2849 kern_return_t RetCode;
2850 int result;
2851 } __Reply;
2852 #ifdef __MigPackStructs
2853 #pragma pack()
2854 #endif
2855 /*
2856 * typedef struct {
2857 * mach_msg_header_t Head;
2858 * NDR_record_t NDR;
2859 * kern_return_t RetCode;
2860 * } mig_reply_error_t;
2861 */
2862
2863 union {
2864 Request In;
2865 Reply Out;
2866 } Mess;
2867
2868 Request *InP = &Mess.In;
2869 Reply *Out0P = &Mess.Out;
2870
2871 mach_msg_return_t msg_result;
2872
2873 #ifdef __MIG_check__Reply__rpc_jack_port_disconnect_t__defined
2874 kern_return_t check_result;
2875 #endif /* __MIG_check__Reply__rpc_jack_port_disconnect_t__defined */
2876
2877 __DeclareSendRpc(1008, "rpc_jack_port_disconnect")
2878
2879 InP->NDR = NDR_record;
2880
2881 InP->refnum = refnum;
2882
2883 InP->src = src;
2884
2885 InP->dst = dst;
2886
2887 InP->Head.msgh_bits =
2888 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
2889 /* msgh_size passed as argument */
2890 InP->Head.msgh_request_port = server_port;
2891 InP->Head.msgh_reply_port = mig_get_reply_port();
2892 InP->Head.msgh_id = 1008;
2893
2894 __BeforeSendRpc(1008, "rpc_jack_port_disconnect")
2895 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
2896 __AfterSendRpc(1008, "rpc_jack_port_disconnect")
2897 if (msg_result != MACH_MSG_SUCCESS) {
2898 __MachMsgErrorWithoutTimeout(msg_result);
2899 { return msg_result; }
2900 }
2901
2902
2903 #if defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)
2904 check_result = __MIG_check__Reply__rpc_jack_port_disconnect_t((__Reply__rpc_jack_port_disconnect_t *)Out0P);
2905 if (check_result != MACH_MSG_SUCCESS)
2906 { return check_result; }
2907 #endif /* defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */
2908
2909 *result = Out0P->result;
2910
2911 return KERN_SUCCESS;
2912 }
2913
2914 #if ( __MigTypeCheck || __NDR_convert__ )
2915 #if __MIG_check__Reply__JackRPCEngine_subsystem__
2916 #if !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)
2917 #define __MIG_check__Reply__rpc_jack_port_connect_name_t__defined
2918 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
2919 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
2920 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
2921 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \
2922 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
2923 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
2924 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined
2925 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \
2926 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
2927 #endif /* defined(__NDR_convert__*__defined) */
2928 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */
2929
2930
2931 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2932 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
2933 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2934 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2935 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
2936 #elif defined(__NDR_convert__int_rep__int__defined)
2937 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2938 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2939 __NDR_convert__int_rep__int((int *)(a), f)
2940 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
2941 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2942 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2943 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2944 #elif defined(__NDR_convert__int_rep__int32_t__defined)
2945 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2946 #define __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2947 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
2948 #endif /* defined(__NDR_convert__*__defined) */
2949 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
2950
2951
2952
2953 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2954 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
2955 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2956 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2957 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
2958 #elif defined(__NDR_convert__char_rep__int__defined)
2959 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2960 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2961 __NDR_convert__char_rep__int((int *)(a), f)
2962 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
2963 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2964 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2965 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2966 #elif defined(__NDR_convert__char_rep__int32_t__defined)
2967 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2968 #define __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2969 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
2970 #endif /* defined(__NDR_convert__*__defined) */
2971 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
2972
2973
2974
2975 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2976 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
2977 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2978 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2979 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
2980 #elif defined(__NDR_convert__float_rep__int__defined)
2981 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2982 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2983 __NDR_convert__float_rep__int((int *)(a), f)
2984 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
2985 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2986 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2987 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
2988 #elif defined(__NDR_convert__float_rep__int32_t__defined)
2989 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined
2990 #define __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \
2991 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
2992 #endif /* defined(__NDR_convert__*__defined) */
2993 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
2994
2995
2996
2997 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_name_t(__Reply__rpc_jack_port_connect_name_t *Out0P)
2998 {
2999
3000 typedef __Reply__rpc_jack_port_connect_name_t __Reply;
3001 #if __MigTypeCheck
3002 unsigned int msgh_size;
3003 #endif /* __MigTypeCheck */
3004 if (Out0P->Head.msgh_id != 1109) {
3005 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
3006 { return MIG_SERVER_DIED; }
3007 else
3008 { return MIG_REPLY_MISMATCH; }
3009 }
3010
3011 #if __MigTypeCheck
3012 msgh_size = Out0P->Head.msgh_size;
3013
3014 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3015 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
3016 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
3017 Out0P->RetCode == KERN_SUCCESS)))
3018 { return MIG_TYPE_ERROR ; }
3019 #endif /* __MigTypeCheck */
3020
3021 if (Out0P->RetCode != KERN_SUCCESS) {
3022 #ifdef __NDR_convert__mig_reply_error_t__defined
3023 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
3024 #endif /* __NDR_convert__mig_reply_error_t__defined */
3025 return ((mig_reply_error_t *)Out0P)->RetCode;
3026 }
3027
3028 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined) || \
3029 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3030 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
3031 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined)
3032 __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
3033 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */
3034 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3035 __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);
3036 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
3037 }
3038 #endif /* defined(__NDR_convert__int_rep...) */
3039
3040 #if 0 || \
3041 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3042 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
3043 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3044 __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);
3045 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
3046 }
3047 #endif /* defined(__NDR_convert__char_rep...) */
3048
3049 #if 0 || \
3050 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3051 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
3052 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)
3053 __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);
3054 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */
3055 }
3056 #endif /* defined(__NDR_convert__float_rep...) */
3057
3058 return MACH_MSG_SUCCESS;
3059 }
3060 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */
3061 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
3062 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
3063
3064
3065 /* Routine rpc_jack_port_connect_name */
3066 mig_external kern_return_t rpc_jack_port_connect_name
3067 (
3068 mach_port_t server_port,
3069 int refnum,
3070 client_port_name_t src,
3071 client_port_name_t dst,
3072 int *result
3073 )
3074 {
3075
3076 #ifdef __MigPackStructs
3077 #pragma pack(4)
3078 #endif
3079 typedef struct {
3080 mach_msg_header_t Head;
3081 NDR_record_t NDR;
3082 int refnum;
3083 client_port_name_t src;
3084 client_port_name_t dst;
3085 } Request;
3086 #ifdef __MigPackStructs
3087 #pragma pack()
3088 #endif
3089
3090 #ifdef __MigPackStructs
3091 #pragma pack(4)
3092 #endif
3093 typedef struct {
3094 mach_msg_header_t Head;
3095 NDR_record_t NDR;
3096 kern_return_t RetCode;
3097 int result;
3098 mach_msg_trailer_t trailer;
3099 } Reply;
3100 #ifdef __MigPackStructs
3101 #pragma pack()
3102 #endif
3103
3104 #ifdef __MigPackStructs
3105 #pragma pack(4)
3106 #endif
3107 typedef struct {
3108 mach_msg_header_t Head;
3109 NDR_record_t NDR;
3110 kern_return_t RetCode;
3111 int result;
3112 } __Reply;
3113 #ifdef __MigPackStructs
3114 #pragma pack()
3115 #endif
3116 /*
3117 * typedef struct {
3118 * mach_msg_header_t Head;
3119 * NDR_record_t NDR;
3120 * kern_return_t RetCode;
3121 * } mig_reply_error_t;
3122 */
3123
3124 union {
3125 Request In;
3126 Reply Out;
3127 } Mess;
3128
3129 Request *InP = &Mess.In;
3130 Reply *Out0P = &Mess.Out;
3131
3132 mach_msg_return_t msg_result;
3133
3134 #ifdef __MIG_check__Reply__rpc_jack_port_connect_name_t__defined
3135 kern_return_t check_result;
3136 #endif /* __MIG_check__Reply__rpc_jack_port_connect_name_t__defined */
3137
3138 __DeclareSendRpc(1009, "rpc_jack_port_connect_name")
3139
3140 InP->NDR = NDR_record;
3141
3142 InP->refnum = refnum;
3143
3144 (void) mig_strncpy(InP->src, src, 128);
3145
3146 (void) mig_strncpy(InP->dst, dst, 128);
3147
3148 InP->Head.msgh_bits =
3149 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
3150 /* msgh_size passed as argument */
3151 InP->Head.msgh_request_port = server_port;
3152 InP->Head.msgh_reply_port = mig_get_reply_port();
3153 InP->Head.msgh_id = 1009;
3154
3155 __BeforeSendRpc(1009, "rpc_jack_port_connect_name")
3156 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
3157 __AfterSendRpc(1009, "rpc_jack_port_connect_name")
3158 if (msg_result != MACH_MSG_SUCCESS) {
3159 __MachMsgErrorWithoutTimeout(msg_result);
3160 { return msg_result; }
3161 }
3162
3163
3164 #if defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)
3165 check_result = __MIG_check__Reply__rpc_jack_port_connect_name_t((__Reply__rpc_jack_port_connect_name_t *)Out0P);
3166 if (check_result != MACH_MSG_SUCCESS)
3167 { return check_result; }
3168 #endif /* defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */
3169
3170 *result = Out0P->result;
3171
3172 return KERN_SUCCESS;
3173 }
3174
3175 #if ( __MigTypeCheck || __NDR_convert__ )
3176 #if __MIG_check__Reply__JackRPCEngine_subsystem__
3177 #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)
3178 #define __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined
3179 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
3180 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
3181 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
3182 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \
3183 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
3184 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
3185 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined
3186 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \
3187 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
3188 #endif /* defined(__NDR_convert__*__defined) */
3189 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */
3190
3191
3192 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3193 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
3194 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3195 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3196 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
3197 #elif defined(__NDR_convert__int_rep__int__defined)
3198 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3199 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3200 __NDR_convert__int_rep__int((int *)(a), f)
3201 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
3202 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3203 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3204 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3205 #elif defined(__NDR_convert__int_rep__int32_t__defined)
3206 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3207 #define __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3208 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
3209 #endif /* defined(__NDR_convert__*__defined) */
3210 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3211
3212
3213
3214 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3215 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
3216 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3217 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3218 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
3219 #elif defined(__NDR_convert__char_rep__int__defined)
3220 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3221 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3222 __NDR_convert__char_rep__int((int *)(a), f)
3223 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
3224 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3225 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3226 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3227 #elif defined(__NDR_convert__char_rep__int32_t__defined)
3228 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3229 #define __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3230 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
3231 #endif /* defined(__NDR_convert__*__defined) */
3232 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3233
3234
3235
3236 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3237 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
3238 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3239 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3240 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
3241 #elif defined(__NDR_convert__float_rep__int__defined)
3242 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3243 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3244 __NDR_convert__float_rep__int((int *)(a), f)
3245 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
3246 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3247 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3248 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3249 #elif defined(__NDR_convert__float_rep__int32_t__defined)
3250 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined
3251 #define __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \
3252 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
3253 #endif /* defined(__NDR_convert__*__defined) */
3254 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3255
3256
3257
3258 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_name_t(__Reply__rpc_jack_port_disconnect_name_t *Out0P)
3259 {
3260
3261 typedef __Reply__rpc_jack_port_disconnect_name_t __Reply;
3262 #if __MigTypeCheck
3263 unsigned int msgh_size;
3264 #endif /* __MigTypeCheck */
3265 if (Out0P->Head.msgh_id != 1110) {
3266 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
3267 { return MIG_SERVER_DIED; }
3268 else
3269 { return MIG_REPLY_MISMATCH; }
3270 }
3271
3272 #if __MigTypeCheck
3273 msgh_size = Out0P->Head.msgh_size;
3274
3275 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3276 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
3277 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
3278 Out0P->RetCode == KERN_SUCCESS)))
3279 { return MIG_TYPE_ERROR ; }
3280 #endif /* __MigTypeCheck */
3281
3282 if (Out0P->RetCode != KERN_SUCCESS) {
3283 #ifdef __NDR_convert__mig_reply_error_t__defined
3284 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
3285 #endif /* __NDR_convert__mig_reply_error_t__defined */
3286 return ((mig_reply_error_t *)Out0P)->RetCode;
3287 }
3288
3289 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined) || \
3290 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3291 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
3292 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined)
3293 __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
3294 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */
3295 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3296 __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);
3297 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3298 }
3299 #endif /* defined(__NDR_convert__int_rep...) */
3300
3301 #if 0 || \
3302 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3303 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
3304 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3305 __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);
3306 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3307 }
3308 #endif /* defined(__NDR_convert__char_rep...) */
3309
3310 #if 0 || \
3311 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3312 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
3313 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)
3314 __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);
3315 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */
3316 }
3317 #endif /* defined(__NDR_convert__float_rep...) */
3318
3319 return MACH_MSG_SUCCESS;
3320 }
3321 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */
3322 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
3323 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
3324
3325
3326 /* Routine rpc_jack_port_disconnect_name */
3327 mig_external kern_return_t rpc_jack_port_disconnect_name
3328 (
3329 mach_port_t server_port,
3330 int refnum,
3331 client_port_name_t src,
3332 client_port_name_t dst,
3333 int *result
3334 )
3335 {
3336
3337 #ifdef __MigPackStructs
3338 #pragma pack(4)
3339 #endif
3340 typedef struct {
3341 mach_msg_header_t Head;
3342 NDR_record_t NDR;
3343 int refnum;
3344 client_port_name_t src;
3345 client_port_name_t dst;
3346 } Request;
3347 #ifdef __MigPackStructs
3348 #pragma pack()
3349 #endif
3350
3351 #ifdef __MigPackStructs
3352 #pragma pack(4)
3353 #endif
3354 typedef struct {
3355 mach_msg_header_t Head;
3356 NDR_record_t NDR;
3357 kern_return_t RetCode;
3358 int result;
3359 mach_msg_trailer_t trailer;
3360 } Reply;
3361 #ifdef __MigPackStructs
3362 #pragma pack()
3363 #endif
3364
3365 #ifdef __MigPackStructs
3366 #pragma pack(4)
3367 #endif
3368 typedef struct {
3369 mach_msg_header_t Head;
3370 NDR_record_t NDR;
3371 kern_return_t RetCode;
3372 int result;
3373 } __Reply;
3374 #ifdef __MigPackStructs
3375 #pragma pack()
3376 #endif
3377 /*
3378 * typedef struct {
3379 * mach_msg_header_t Head;
3380 * NDR_record_t NDR;
3381 * kern_return_t RetCode;
3382 * } mig_reply_error_t;
3383 */
3384
3385 union {
3386 Request In;
3387 Reply Out;
3388 } Mess;
3389
3390 Request *InP = &Mess.In;
3391 Reply *Out0P = &Mess.Out;
3392
3393 mach_msg_return_t msg_result;
3394
3395 #ifdef __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined
3396 kern_return_t check_result;
3397 #endif /* __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined */
3398
3399 __DeclareSendRpc(1010, "rpc_jack_port_disconnect_name")
3400
3401 InP->NDR = NDR_record;
3402
3403 InP->refnum = refnum;
3404
3405 (void) mig_strncpy(InP->src, src, 128);
3406
3407 (void) mig_strncpy(InP->dst, dst, 128);
3408
3409 InP->Head.msgh_bits =
3410 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
3411 /* msgh_size passed as argument */
3412 InP->Head.msgh_request_port = server_port;
3413 InP->Head.msgh_reply_port = mig_get_reply_port();
3414 InP->Head.msgh_id = 1010;
3415
3416 __BeforeSendRpc(1010, "rpc_jack_port_disconnect_name")
3417 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
3418 __AfterSendRpc(1010, "rpc_jack_port_disconnect_name")
3419 if (msg_result != MACH_MSG_SUCCESS) {
3420 __MachMsgErrorWithoutTimeout(msg_result);
3421 { return msg_result; }
3422 }
3423
3424
3425 #if defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)
3426 check_result = __MIG_check__Reply__rpc_jack_port_disconnect_name_t((__Reply__rpc_jack_port_disconnect_name_t *)Out0P);
3427 if (check_result != MACH_MSG_SUCCESS)
3428 { return check_result; }
3429 #endif /* defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */
3430
3431 *result = Out0P->result;
3432
3433 return KERN_SUCCESS;
3434 }
3435
3436 #if ( __MigTypeCheck || __NDR_convert__ )
3437 #if __MIG_check__Reply__JackRPCEngine_subsystem__
3438 #if !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
3439 #define __MIG_check__Reply__rpc_jack_port_rename_t__defined
3440 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
3441 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
3442 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
3443 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(a, f) \
3444 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
3445 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
3446 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
3447 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(a, f) \
3448 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
3449 #endif /* defined(__NDR_convert__*__defined) */
3450 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined */
3451
3452
3453 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
3454 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
3455 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
3456 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3457 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
3458 #elif defined(__NDR_convert__int_rep__int__defined)
3459 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
3460 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3461 __NDR_convert__int_rep__int((int *)(a), f)
3462 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
3463 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
3464 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3465 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3466 #elif defined(__NDR_convert__int_rep__int32_t__defined)
3467 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
3468 #define __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3469 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
3470 #endif /* defined(__NDR_convert__*__defined) */
3471 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined */
3472
3473
3474
3475 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
3476 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
3477 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
3478 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3479 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
3480 #elif defined(__NDR_convert__char_rep__int__defined)
3481 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
3482 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3483 __NDR_convert__char_rep__int((int *)(a), f)
3484 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
3485 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
3486 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3487 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3488 #elif defined(__NDR_convert__char_rep__int32_t__defined)
3489 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
3490 #define __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3491 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
3492 #endif /* defined(__NDR_convert__*__defined) */
3493 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined */
3494
3495
3496
3497 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
3498 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
3499 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
3500 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3501 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
3502 #elif defined(__NDR_convert__float_rep__int__defined)
3503 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
3504 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3505 __NDR_convert__float_rep__int((int *)(a), f)
3506 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
3507 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
3508 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3509 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3510 #elif defined(__NDR_convert__float_rep__int32_t__defined)
3511 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
3512 #define __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(a, f) \
3513 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
3514 #endif /* defined(__NDR_convert__*__defined) */
3515 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined */
3516
3517
3518
3519 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_rename_t(__Reply__rpc_jack_port_rename_t *Out0P)
3520 {
3521
3522 typedef __Reply__rpc_jack_port_rename_t __Reply;
3523 #if __MigTypeCheck
3524 unsigned int msgh_size;
3525 #endif /* __MigTypeCheck */
3526 if (Out0P->Head.msgh_id != 1111) {
3527 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
3528 { return MIG_SERVER_DIED; }
3529 else
3530 { return MIG_REPLY_MISMATCH; }
3531 }
3532
3533 #if __MigTypeCheck
3534 msgh_size = Out0P->Head.msgh_size;
3535
3536 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3537 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
3538 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
3539 Out0P->RetCode == KERN_SUCCESS)))
3540 { return MIG_TYPE_ERROR ; }
3541 #endif /* __MigTypeCheck */
3542
3543 if (Out0P->RetCode != KERN_SUCCESS) {
3544 #ifdef __NDR_convert__mig_reply_error_t__defined
3545 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
3546 #endif /* __NDR_convert__mig_reply_error_t__defined */
3547 return ((mig_reply_error_t *)Out0P)->RetCode;
3548 }
3549
3550 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined) || \
3551 defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
3552 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
3553 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined)
3554 __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
3555 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined */
3556 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
3557 __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.int_rep);
3558 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined */
3559 }
3560 #endif /* defined(__NDR_convert__int_rep...) */
3561
3562 #if 0 || \
3563 defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
3564 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
3565 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
3566 __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.char_rep);
3567 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined */
3568 }
3569 #endif /* defined(__NDR_convert__char_rep...) */
3570
3571 #if 0 || \
3572 defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
3573 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
3574 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
3575 __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.float_rep);
3576 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined */
3577 }
3578 #endif /* defined(__NDR_convert__float_rep...) */
3579
3580 return MACH_MSG_SUCCESS;
3581 }
3582 #endif /* !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
3583 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
3584 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
3585
3586
3587 /* Routine rpc_jack_port_rename */
3588 mig_external kern_return_t rpc_jack_port_rename
3589 (
3590 mach_port_t server_port,
3591 int refnum,
3592 int src,
3593 client_port_name_t name,
3594 int *result
3595 )
3596 {
3597
3598 #ifdef __MigPackStructs
3599 #pragma pack(4)
3600 #endif
3601 typedef struct {
3602 mach_msg_header_t Head;
3603 NDR_record_t NDR;
3604 int refnum;
3605 int src;
3606 client_port_name_t name;
3607 } Request;
3608 #ifdef __MigPackStructs
3609 #pragma pack()
3610 #endif
3611
3612 #ifdef __MigPackStructs
3613 #pragma pack(4)
3614 #endif
3615 typedef struct {
3616 mach_msg_header_t Head;
3617 NDR_record_t NDR;
3618 kern_return_t RetCode;
3619 int result;
3620 mach_msg_trailer_t trailer;
3621 } Reply;
3622 #ifdef __MigPackStructs
3623 #pragma pack()
3624 #endif
3625
3626 #ifdef __MigPackStructs
3627 #pragma pack(4)
3628 #endif
3629 typedef struct {
3630 mach_msg_header_t Head;
3631 NDR_record_t NDR;
3632 kern_return_t RetCode;
3633 int result;
3634 } __Reply;
3635 #ifdef __MigPackStructs
3636 #pragma pack()
3637 #endif
3638 /*
3639 * typedef struct {
3640 * mach_msg_header_t Head;
3641 * NDR_record_t NDR;
3642 * kern_return_t RetCode;
3643 * } mig_reply_error_t;
3644 */
3645
3646 union {
3647 Request In;
3648 Reply Out;
3649 } Mess;
3650
3651 Request *InP = &Mess.In;
3652 Reply *Out0P = &Mess.Out;
3653
3654 mach_msg_return_t msg_result;
3655
3656 #ifdef __MIG_check__Reply__rpc_jack_port_rename_t__defined
3657 kern_return_t check_result;
3658 #endif /* __MIG_check__Reply__rpc_jack_port_rename_t__defined */
3659
3660 __DeclareSendRpc(1011, "rpc_jack_port_rename")
3661
3662 InP->NDR = NDR_record;
3663
3664 InP->refnum = refnum;
3665
3666 InP->src = src;
3667
3668 (void) mig_strncpy(InP->name, name, 128);
3669
3670 InP->Head.msgh_bits =
3671 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
3672 /* msgh_size passed as argument */
3673 InP->Head.msgh_request_port = server_port;
3674 InP->Head.msgh_reply_port = mig_get_reply_port();
3675 InP->Head.msgh_id = 1011;
3676
3677 __BeforeSendRpc(1011, "rpc_jack_port_rename")
3678 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
3679 __AfterSendRpc(1011, "rpc_jack_port_rename")
3680 if (msg_result != MACH_MSG_SUCCESS) {
3681 __MachMsgErrorWithoutTimeout(msg_result);
3682 { return msg_result; }
3683 }
3684
3685
3686 #if defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
3687 check_result = __MIG_check__Reply__rpc_jack_port_rename_t((__Reply__rpc_jack_port_rename_t *)Out0P);
3688 if (check_result != MACH_MSG_SUCCESS)
3689 { return check_result; }
3690 #endif /* defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
3691
3692 *result = Out0P->result;
3693
3694 return KERN_SUCCESS;
3695 }
3696
3697 #if ( __MigTypeCheck || __NDR_convert__ )
3698 #if __MIG_check__Reply__JackRPCEngine_subsystem__
3699 #if !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)
3700 #define __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined
3701 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
3702 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
3703 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
3704 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \
3705 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
3706 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
3707 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined
3708 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \
3709 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
3710 #endif /* defined(__NDR_convert__*__defined) */
3711 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */
3712
3713
3714 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3715 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
3716 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3717 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3718 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
3719 #elif defined(__NDR_convert__int_rep__int__defined)
3720 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3721 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3722 __NDR_convert__int_rep__int((int *)(a), f)
3723 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
3724 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3725 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3726 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3727 #elif defined(__NDR_convert__int_rep__int32_t__defined)
3728 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3729 #define __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3730 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
3731 #endif /* defined(__NDR_convert__*__defined) */
3732 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3733
3734
3735
3736 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3737 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
3738 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3739 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3740 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
3741 #elif defined(__NDR_convert__char_rep__int__defined)
3742 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3743 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3744 __NDR_convert__char_rep__int((int *)(a), f)
3745 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
3746 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3747 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3748 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3749 #elif defined(__NDR_convert__char_rep__int32_t__defined)
3750 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3751 #define __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3752 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
3753 #endif /* defined(__NDR_convert__*__defined) */
3754 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3755
3756
3757
3758 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3759 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
3760 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3761 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3762 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
3763 #elif defined(__NDR_convert__float_rep__int__defined)
3764 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3765 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3766 __NDR_convert__float_rep__int((int *)(a), f)
3767 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
3768 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3769 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3770 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3771 #elif defined(__NDR_convert__float_rep__int32_t__defined)
3772 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined
3773 #define __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \
3774 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
3775 #endif /* defined(__NDR_convert__*__defined) */
3776 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3777
3778
3779
3780 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Reply__rpc_jack_set_buffer_size_t *Out0P)
3781 {
3782
3783 typedef __Reply__rpc_jack_set_buffer_size_t __Reply;
3784 #if __MigTypeCheck
3785 unsigned int msgh_size;
3786 #endif /* __MigTypeCheck */
3787 if (Out0P->Head.msgh_id != 1112) {
3788 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
3789 { return MIG_SERVER_DIED; }
3790 else
3791 { return MIG_REPLY_MISMATCH; }
3792 }
3793
3794 #if __MigTypeCheck
3795 msgh_size = Out0P->Head.msgh_size;
3796
3797 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3798 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
3799 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
3800 Out0P->RetCode == KERN_SUCCESS)))
3801 { return MIG_TYPE_ERROR ; }
3802 #endif /* __MigTypeCheck */
3803
3804 if (Out0P->RetCode != KERN_SUCCESS) {
3805 #ifdef __NDR_convert__mig_reply_error_t__defined
3806 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
3807 #endif /* __NDR_convert__mig_reply_error_t__defined */
3808 return ((mig_reply_error_t *)Out0P)->RetCode;
3809 }
3810
3811 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined) || \
3812 defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3813 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
3814 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined)
3815 __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
3816 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */
3817 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3818 __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.int_rep);
3819 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3820 }
3821 #endif /* defined(__NDR_convert__int_rep...) */
3822
3823 #if 0 || \
3824 defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3825 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
3826 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3827 __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.char_rep);
3828 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3829 }
3830 #endif /* defined(__NDR_convert__char_rep...) */
3831
3832 #if 0 || \
3833 defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3834 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
3835 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)
3836 __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.float_rep);
3837 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */
3838 }
3839 #endif /* defined(__NDR_convert__float_rep...) */
3840
3841 return MACH_MSG_SUCCESS;
3842 }
3843 #endif /* !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */
3844 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
3845 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
3846
3847
3848 /* Routine rpc_jack_set_buffer_size */
3849 mig_external kern_return_t rpc_jack_set_buffer_size
3850 (
3851 mach_port_t server_port,
3852 int buffer_size,
3853 int *result
3854 )
3855 {
3856
3857 #ifdef __MigPackStructs
3858 #pragma pack(4)
3859 #endif
3860 typedef struct {
3861 mach_msg_header_t Head;
3862 NDR_record_t NDR;
3863 int buffer_size;
3864 } Request;
3865 #ifdef __MigPackStructs
3866 #pragma pack()
3867 #endif
3868
3869 #ifdef __MigPackStructs
3870 #pragma pack(4)
3871 #endif
3872 typedef struct {
3873 mach_msg_header_t Head;
3874 NDR_record_t NDR;
3875 kern_return_t RetCode;
3876 int result;
3877 mach_msg_trailer_t trailer;
3878 } Reply;
3879 #ifdef __MigPackStructs
3880 #pragma pack()
3881 #endif
3882
3883 #ifdef __MigPackStructs
3884 #pragma pack(4)
3885 #endif
3886 typedef struct {
3887 mach_msg_header_t Head;
3888 NDR_record_t NDR;
3889 kern_return_t RetCode;
3890 int result;
3891 } __Reply;
3892 #ifdef __MigPackStructs
3893 #pragma pack()
3894 #endif
3895 /*
3896 * typedef struct {
3897 * mach_msg_header_t Head;
3898 * NDR_record_t NDR;
3899 * kern_return_t RetCode;
3900 * } mig_reply_error_t;
3901 */
3902
3903 union {
3904 Request In;
3905 Reply Out;
3906 } Mess;
3907
3908 Request *InP = &Mess.In;
3909 Reply *Out0P = &Mess.Out;
3910
3911 mach_msg_return_t msg_result;
3912
3913 #ifdef __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined
3914 kern_return_t check_result;
3915 #endif /* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */
3916
3917 __DeclareSendRpc(1012, "rpc_jack_set_buffer_size")
3918
3919 InP->NDR = NDR_record;
3920
3921 InP->buffer_size = buffer_size;
3922
3923 InP->Head.msgh_bits =
3924 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
3925 /* msgh_size passed as argument */
3926 InP->Head.msgh_request_port = server_port;
3927 InP->Head.msgh_reply_port = mig_get_reply_port();
3928 InP->Head.msgh_id = 1012;
3929
3930 __BeforeSendRpc(1012, "rpc_jack_set_buffer_size")
3931 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
3932 __AfterSendRpc(1012, "rpc_jack_set_buffer_size")
3933 if (msg_result != MACH_MSG_SUCCESS) {
3934 __MachMsgErrorWithoutTimeout(msg_result);
3935 { return msg_result; }
3936 }
3937
3938
3939 #if defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)
3940 check_result = __MIG_check__Reply__rpc_jack_set_buffer_size_t((__Reply__rpc_jack_set_buffer_size_t *)Out0P);
3941 if (check_result != MACH_MSG_SUCCESS)
3942 { return check_result; }
3943 #endif /* defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */
3944
3945 *result = Out0P->result;
3946
3947 return KERN_SUCCESS;
3948 }
3949
3950 #if ( __MigTypeCheck || __NDR_convert__ )
3951 #if __MIG_check__Reply__JackRPCEngine_subsystem__
3952 #if !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)
3953 #define __MIG_check__Reply__rpc_jack_set_freewheel_t__defined
3954 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
3955 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
3956 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
3957 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \
3958 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
3959 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
3960 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined
3961 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \
3962 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
3963 #endif /* defined(__NDR_convert__*__defined) */
3964 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */
3965
3966
3967 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3968 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
3969 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3970 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3971 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
3972 #elif defined(__NDR_convert__int_rep__int__defined)
3973 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3974 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3975 __NDR_convert__int_rep__int((int *)(a), f)
3976 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
3977 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3978 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3979 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
3980 #elif defined(__NDR_convert__int_rep__int32_t__defined)
3981 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3982 #define __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3983 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
3984 #endif /* defined(__NDR_convert__*__defined) */
3985 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
3986
3987
3988
3989 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3990 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
3991 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3992 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3993 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
3994 #elif defined(__NDR_convert__char_rep__int__defined)
3995 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
3996 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
3997 __NDR_convert__char_rep__int((int *)(a), f)
3998 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
3999 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4000 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4001 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4002 #elif defined(__NDR_convert__char_rep__int32_t__defined)
4003 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4004 #define __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4005 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
4006 #endif /* defined(__NDR_convert__*__defined) */
4007 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
4008
4009
4010
4011 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4012 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
4013 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4014 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4015 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
4016 #elif defined(__NDR_convert__float_rep__int__defined)
4017 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4018 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4019 __NDR_convert__float_rep__int((int *)(a), f)
4020 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
4021 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4022 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4023 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4024 #elif defined(__NDR_convert__float_rep__int32_t__defined)
4025 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined
4026 #define __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \
4027 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
4028 #endif /* defined(__NDR_convert__*__defined) */
4029 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
4030
4031
4032
4033 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply__rpc_jack_set_freewheel_t *Out0P)
4034 {
4035
4036 typedef __Reply__rpc_jack_set_freewheel_t __Reply;
4037 #if __MigTypeCheck
4038 unsigned int msgh_size;
4039 #endif /* __MigTypeCheck */
4040 if (Out0P->Head.msgh_id != 1113) {
4041 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
4042 { return MIG_SERVER_DIED; }
4043 else
4044 { return MIG_REPLY_MISMATCH; }
4045 }
4046
4047 #if __MigTypeCheck
4048 msgh_size = Out0P->Head.msgh_size;
4049
4050 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4051 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
4052 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
4053 Out0P->RetCode == KERN_SUCCESS)))
4054 { return MIG_TYPE_ERROR ; }
4055 #endif /* __MigTypeCheck */
4056
4057 if (Out0P->RetCode != KERN_SUCCESS) {
4058 #ifdef __NDR_convert__mig_reply_error_t__defined
4059 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
4060 #endif /* __NDR_convert__mig_reply_error_t__defined */
4061 return ((mig_reply_error_t *)Out0P)->RetCode;
4062 }
4063
4064 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined) || \
4065 defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4066 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
4067 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined)
4068 __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
4069 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */
4070 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4071 __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.int_rep);
4072 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
4073 }
4074 #endif /* defined(__NDR_convert__int_rep...) */
4075
4076 #if 0 || \
4077 defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4078 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
4079 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4080 __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.char_rep);
4081 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
4082 }
4083 #endif /* defined(__NDR_convert__char_rep...) */
4084
4085 #if 0 || \
4086 defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4087 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
4088 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)
4089 __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.float_rep);
4090 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */
4091 }
4092 #endif /* defined(__NDR_convert__float_rep...) */
4093
4094 return MACH_MSG_SUCCESS;
4095 }
4096 #endif /* !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */
4097 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
4098 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
4099
4100
4101 /* Routine rpc_jack_set_freewheel */
4102 mig_external kern_return_t rpc_jack_set_freewheel
4103 (
4104 mach_port_t server_port,
4105 int onoff,
4106 int *result
4107 )
4108 {
4109
4110 #ifdef __MigPackStructs
4111 #pragma pack(4)
4112 #endif
4113 typedef struct {
4114 mach_msg_header_t Head;
4115 NDR_record_t NDR;
4116 int onoff;
4117 } Request;
4118 #ifdef __MigPackStructs
4119 #pragma pack()
4120 #endif
4121
4122 #ifdef __MigPackStructs
4123 #pragma pack(4)
4124 #endif
4125 typedef struct {
4126 mach_msg_header_t Head;
4127 NDR_record_t NDR;
4128 kern_return_t RetCode;
4129 int result;
4130 mach_msg_trailer_t trailer;
4131 } Reply;
4132 #ifdef __MigPackStructs
4133 #pragma pack()
4134 #endif
4135
4136 #ifdef __MigPackStructs
4137 #pragma pack(4)
4138 #endif
4139 typedef struct {
4140 mach_msg_header_t Head;
4141 NDR_record_t NDR;
4142 kern_return_t RetCode;
4143 int result;
4144 } __Reply;
4145 #ifdef __MigPackStructs
4146 #pragma pack()
4147 #endif
4148 /*
4149 * typedef struct {
4150 * mach_msg_header_t Head;
4151 * NDR_record_t NDR;
4152 * kern_return_t RetCode;
4153 * } mig_reply_error_t;
4154 */
4155
4156 union {
4157 Request In;
4158 Reply Out;
4159 } Mess;
4160
4161 Request *InP = &Mess.In;
4162 Reply *Out0P = &Mess.Out;
4163
4164 mach_msg_return_t msg_result;
4165
4166 #ifdef __MIG_check__Reply__rpc_jack_set_freewheel_t__defined
4167 kern_return_t check_result;
4168 #endif /* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */
4169
4170 __DeclareSendRpc(1013, "rpc_jack_set_freewheel")
4171
4172 InP->NDR = NDR_record;
4173
4174 InP->onoff = onoff;
4175
4176 InP->Head.msgh_bits =
4177 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
4178 /* msgh_size passed as argument */
4179 InP->Head.msgh_request_port = server_port;
4180 InP->Head.msgh_reply_port = mig_get_reply_port();
4181 InP->Head.msgh_id = 1013;
4182
4183 __BeforeSendRpc(1013, "rpc_jack_set_freewheel")
4184 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
4185 __AfterSendRpc(1013, "rpc_jack_set_freewheel")
4186 if (msg_result != MACH_MSG_SUCCESS) {
4187 __MachMsgErrorWithoutTimeout(msg_result);
4188 { return msg_result; }
4189 }
4190
4191
4192 #if defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)
4193 check_result = __MIG_check__Reply__rpc_jack_set_freewheel_t((__Reply__rpc_jack_set_freewheel_t *)Out0P);
4194 if (check_result != MACH_MSG_SUCCESS)
4195 { return check_result; }
4196 #endif /* defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */
4197
4198 *result = Out0P->result;
4199
4200 return KERN_SUCCESS;
4201 }
4202
4203 #if ( __MigTypeCheck || __NDR_convert__ )
4204 #if __MIG_check__Reply__JackRPCEngine_subsystem__
4205 #if !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)
4206 #define __MIG_check__Reply__rpc_jack_release_timebase_t__defined
4207 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
4208 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
4209 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
4210 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \
4211 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
4212 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
4213 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined
4214 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \
4215 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
4216 #endif /* defined(__NDR_convert__*__defined) */
4217 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */
4218
4219
4220 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
4221 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
4222 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
4223 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4224 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
4225 #elif defined(__NDR_convert__int_rep__int__defined)
4226 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
4227 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4228 __NDR_convert__int_rep__int((int *)(a), f)
4229 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
4230 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
4231 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4232 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4233 #elif defined(__NDR_convert__int_rep__int32_t__defined)
4234 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined
4235 #define __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4236 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
4237 #endif /* defined(__NDR_convert__*__defined) */
4238 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4239
4240
4241
4242 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
4243 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
4244 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
4245 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4246 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
4247 #elif defined(__NDR_convert__char_rep__int__defined)
4248 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
4249 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4250 __NDR_convert__char_rep__int((int *)(a), f)
4251 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
4252 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
4253 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4254 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4255 #elif defined(__NDR_convert__char_rep__int32_t__defined)
4256 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined
4257 #define __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4258 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
4259 #endif /* defined(__NDR_convert__*__defined) */
4260 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4261
4262
4263
4264 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
4265 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
4266 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
4267 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4268 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
4269 #elif defined(__NDR_convert__float_rep__int__defined)
4270 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
4271 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4272 __NDR_convert__float_rep__int((int *)(a), f)
4273 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
4274 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
4275 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4276 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4277 #elif defined(__NDR_convert__float_rep__int32_t__defined)
4278 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined
4279 #define __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \
4280 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
4281 #endif /* defined(__NDR_convert__*__defined) */
4282 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4283
4284
4285
4286 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Reply__rpc_jack_release_timebase_t *Out0P)
4287 {
4288
4289 typedef __Reply__rpc_jack_release_timebase_t __Reply;
4290 #if __MigTypeCheck
4291 unsigned int msgh_size;
4292 #endif /* __MigTypeCheck */
4293 if (Out0P->Head.msgh_id != 1114) {
4294 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
4295 { return MIG_SERVER_DIED; }
4296 else
4297 { return MIG_REPLY_MISMATCH; }
4298 }
4299
4300 #if __MigTypeCheck
4301 msgh_size = Out0P->Head.msgh_size;
4302
4303 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4304 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
4305 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
4306 Out0P->RetCode == KERN_SUCCESS)))
4307 { return MIG_TYPE_ERROR ; }
4308 #endif /* __MigTypeCheck */
4309
4310 if (Out0P->RetCode != KERN_SUCCESS) {
4311 #ifdef __NDR_convert__mig_reply_error_t__defined
4312 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
4313 #endif /* __NDR_convert__mig_reply_error_t__defined */
4314 return ((mig_reply_error_t *)Out0P)->RetCode;
4315 }
4316
4317 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined) || \
4318 defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4319 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
4320 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined)
4321 __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
4322 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */
4323 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4324 __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.int_rep);
4325 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4326 }
4327 #endif /* defined(__NDR_convert__int_rep...) */
4328
4329 #if 0 || \
4330 defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4331 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
4332 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4333 __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.char_rep);
4334 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4335 }
4336 #endif /* defined(__NDR_convert__char_rep...) */
4337
4338 #if 0 || \
4339 defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4340 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
4341 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)
4342 __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.float_rep);
4343 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */
4344 }
4345 #endif /* defined(__NDR_convert__float_rep...) */
4346
4347 return MACH_MSG_SUCCESS;
4348 }
4349 #endif /* !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */
4350 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
4351 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
4352
4353
4354 /* Routine rpc_jack_release_timebase */
4355 mig_external kern_return_t rpc_jack_release_timebase
4356 (
4357 mach_port_t server_port,
4358 int refnum,
4359 int *result
4360 )
4361 {
4362
4363 #ifdef __MigPackStructs
4364 #pragma pack(4)
4365 #endif
4366 typedef struct {
4367 mach_msg_header_t Head;
4368 NDR_record_t NDR;
4369 int refnum;
4370 } Request;
4371 #ifdef __MigPackStructs
4372 #pragma pack()
4373 #endif
4374
4375 #ifdef __MigPackStructs
4376 #pragma pack(4)
4377 #endif
4378 typedef struct {
4379 mach_msg_header_t Head;
4380 NDR_record_t NDR;
4381 kern_return_t RetCode;
4382 int result;
4383 mach_msg_trailer_t trailer;
4384 } Reply;
4385 #ifdef __MigPackStructs
4386 #pragma pack()
4387 #endif
4388
4389 #ifdef __MigPackStructs
4390 #pragma pack(4)
4391 #endif
4392 typedef struct {
4393 mach_msg_header_t Head;
4394 NDR_record_t NDR;
4395 kern_return_t RetCode;
4396 int result;
4397 } __Reply;
4398 #ifdef __MigPackStructs
4399 #pragma pack()
4400 #endif
4401 /*
4402 * typedef struct {
4403 * mach_msg_header_t Head;
4404 * NDR_record_t NDR;
4405 * kern_return_t RetCode;
4406 * } mig_reply_error_t;
4407 */
4408
4409 union {
4410 Request In;
4411 Reply Out;
4412 } Mess;
4413
4414 Request *InP = &Mess.In;
4415 Reply *Out0P = &Mess.Out;
4416
4417 mach_msg_return_t msg_result;
4418
4419 #ifdef __MIG_check__Reply__rpc_jack_release_timebase_t__defined
4420 kern_return_t check_result;
4421 #endif /* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */
4422
4423 __DeclareSendRpc(1014, "rpc_jack_release_timebase")
4424
4425 InP->NDR = NDR_record;
4426
4427 InP->refnum = refnum;
4428
4429 InP->Head.msgh_bits =
4430 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
4431 /* msgh_size passed as argument */
4432 InP->Head.msgh_request_port = server_port;
4433 InP->Head.msgh_reply_port = mig_get_reply_port();
4434 InP->Head.msgh_id = 1014;
4435
4436 __BeforeSendRpc(1014, "rpc_jack_release_timebase")
4437 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
4438 __AfterSendRpc(1014, "rpc_jack_release_timebase")
4439 if (msg_result != MACH_MSG_SUCCESS) {
4440 __MachMsgErrorWithoutTimeout(msg_result);
4441 { return msg_result; }
4442 }
4443
4444
4445 #if defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)
4446 check_result = __MIG_check__Reply__rpc_jack_release_timebase_t((__Reply__rpc_jack_release_timebase_t *)Out0P);
4447 if (check_result != MACH_MSG_SUCCESS)
4448 { return check_result; }
4449 #endif /* defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */
4450
4451 *result = Out0P->result;
4452
4453 return KERN_SUCCESS;
4454 }
4455
4456 #if ( __MigTypeCheck || __NDR_convert__ )
4457 #if __MIG_check__Reply__JackRPCEngine_subsystem__
4458 #if !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)
4459 #define __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined
4460 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
4461 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
4462 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
4463 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \
4464 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
4465 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
4466 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined
4467 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \
4468 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
4469 #endif /* defined(__NDR_convert__*__defined) */
4470 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */
4471
4472
4473 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4474 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
4475 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4476 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4477 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
4478 #elif defined(__NDR_convert__int_rep__int__defined)
4479 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4480 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4481 __NDR_convert__int_rep__int((int *)(a), f)
4482 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
4483 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4484 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4485 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4486 #elif defined(__NDR_convert__int_rep__int32_t__defined)
4487 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4488 #define __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4489 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
4490 #endif /* defined(__NDR_convert__*__defined) */
4491 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4492
4493
4494
4495 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4496 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
4497 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4498 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4499 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
4500 #elif defined(__NDR_convert__char_rep__int__defined)
4501 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4502 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4503 __NDR_convert__char_rep__int((int *)(a), f)
4504 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
4505 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4506 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4507 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4508 #elif defined(__NDR_convert__char_rep__int32_t__defined)
4509 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4510 #define __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4511 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
4512 #endif /* defined(__NDR_convert__*__defined) */
4513 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4514
4515
4516
4517 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4518 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
4519 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4520 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4521 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
4522 #elif defined(__NDR_convert__float_rep__int__defined)
4523 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4524 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4525 __NDR_convert__float_rep__int((int *)(a), f)
4526 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
4527 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4528 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4529 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4530 #elif defined(__NDR_convert__float_rep__int32_t__defined)
4531 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined
4532 #define __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \
4533 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
4534 #endif /* defined(__NDR_convert__*__defined) */
4535 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4536
4537
4538
4539 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(__Reply__rpc_jack_set_timebase_callback_t *Out0P)
4540 {
4541
4542 typedef __Reply__rpc_jack_set_timebase_callback_t __Reply;
4543 #if __MigTypeCheck
4544 unsigned int msgh_size;
4545 #endif /* __MigTypeCheck */
4546 if (Out0P->Head.msgh_id != 1115) {
4547 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
4548 { return MIG_SERVER_DIED; }
4549 else
4550 { return MIG_REPLY_MISMATCH; }
4551 }
4552
4553 #if __MigTypeCheck
4554 msgh_size = Out0P->Head.msgh_size;
4555
4556 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4557 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
4558 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
4559 Out0P->RetCode == KERN_SUCCESS)))
4560 { return MIG_TYPE_ERROR ; }
4561 #endif /* __MigTypeCheck */
4562
4563 if (Out0P->RetCode != KERN_SUCCESS) {
4564 #ifdef __NDR_convert__mig_reply_error_t__defined
4565 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
4566 #endif /* __NDR_convert__mig_reply_error_t__defined */
4567 return ((mig_reply_error_t *)Out0P)->RetCode;
4568 }
4569
4570 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined) || \
4571 defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4572 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
4573 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined)
4574 __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
4575 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */
4576 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4577 __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.int_rep);
4578 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4579 }
4580 #endif /* defined(__NDR_convert__int_rep...) */
4581
4582 #if 0 || \
4583 defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4584 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
4585 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4586 __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.char_rep);
4587 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4588 }
4589 #endif /* defined(__NDR_convert__char_rep...) */
4590
4591 #if 0 || \
4592 defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4593 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
4594 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)
4595 __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.float_rep);
4596 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */
4597 }
4598 #endif /* defined(__NDR_convert__float_rep...) */
4599
4600 return MACH_MSG_SUCCESS;
4601 }
4602 #endif /* !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */
4603 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
4604 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
4605
4606
4607 /* Routine rpc_jack_set_timebase_callback */
4608 mig_external kern_return_t rpc_jack_set_timebase_callback
4609 (
4610 mach_port_t server_port,
4611 int refnum,
4612 int conditional,
4613 int *result
4614 )
4615 {
4616
4617 #ifdef __MigPackStructs
4618 #pragma pack(4)
4619 #endif
4620 typedef struct {
4621 mach_msg_header_t Head;
4622 NDR_record_t NDR;
4623 int refnum;
4624 int conditional;
4625 } Request;
4626 #ifdef __MigPackStructs
4627 #pragma pack()
4628 #endif
4629
4630 #ifdef __MigPackStructs
4631 #pragma pack(4)
4632 #endif
4633 typedef struct {
4634 mach_msg_header_t Head;
4635 NDR_record_t NDR;
4636 kern_return_t RetCode;
4637 int result;
4638 mach_msg_trailer_t trailer;
4639 } Reply;
4640 #ifdef __MigPackStructs
4641 #pragma pack()
4642 #endif
4643
4644 #ifdef __MigPackStructs
4645 #pragma pack(4)
4646 #endif
4647 typedef struct {
4648 mach_msg_header_t Head;
4649 NDR_record_t NDR;
4650 kern_return_t RetCode;
4651 int result;
4652 } __Reply;
4653 #ifdef __MigPackStructs
4654 #pragma pack()
4655 #endif
4656 /*
4657 * typedef struct {
4658 * mach_msg_header_t Head;
4659 * NDR_record_t NDR;
4660 * kern_return_t RetCode;
4661 * } mig_reply_error_t;
4662 */
4663
4664 union {
4665 Request In;
4666 Reply Out;
4667 } Mess;
4668
4669 Request *InP = &Mess.In;
4670 Reply *Out0P = &Mess.Out;
4671
4672 mach_msg_return_t msg_result;
4673
4674 #ifdef __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined
4675 kern_return_t check_result;
4676 #endif /* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */
4677
4678 __DeclareSendRpc(1015, "rpc_jack_set_timebase_callback")
4679
4680 InP->NDR = NDR_record;
4681
4682 InP->refnum = refnum;
4683
4684 InP->conditional = conditional;
4685
4686 InP->Head.msgh_bits =
4687 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
4688 /* msgh_size passed as argument */
4689 InP->Head.msgh_request_port = server_port;
4690 InP->Head.msgh_reply_port = mig_get_reply_port();
4691 InP->Head.msgh_id = 1015;
4692
4693 __BeforeSendRpc(1015, "rpc_jack_set_timebase_callback")
4694 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
4695 __AfterSendRpc(1015, "rpc_jack_set_timebase_callback")
4696 if (msg_result != MACH_MSG_SUCCESS) {
4697 __MachMsgErrorWithoutTimeout(msg_result);
4698 { return msg_result; }
4699 }
4700
4701
4702 #if defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)
4703 check_result = __MIG_check__Reply__rpc_jack_set_timebase_callback_t((__Reply__rpc_jack_set_timebase_callback_t *)Out0P);
4704 if (check_result != MACH_MSG_SUCCESS)
4705 { return check_result; }
4706 #endif /* defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */
4707
4708 *result = Out0P->result;
4709
4710 return KERN_SUCCESS;
4711 }
4712
4713 #if ( __MigTypeCheck || __NDR_convert__ )
4714 #if __MIG_check__Reply__JackRPCEngine_subsystem__
4715 #if !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined)
4716 #define __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined
4717 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
4718 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
4719 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
4720 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(a, f) \
4721 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
4722 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
4723 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined
4724 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(a, f) \
4725 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
4726 #endif /* defined(__NDR_convert__*__defined) */
4727 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined */
4728
4729
4730 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4731 #if defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)
4732 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4733 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4734 __NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
4735 #elif defined(__NDR_convert__int_rep__client_name_t__defined)
4736 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4737 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4738 __NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)
4739 #elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
4740 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4741 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4742 __NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)
4743 #elif defined(__NDR_convert__int_rep__string__defined)
4744 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4745 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4746 __NDR_convert__int_rep__string(a, f, 128)
4747 #endif /* defined(__NDR_convert__*__defined) */
4748 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4749
4750
4751 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4752 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
4753 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4754 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4755 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
4756 #elif defined(__NDR_convert__int_rep__int__defined)
4757 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4758 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4759 __NDR_convert__int_rep__int((int *)(a), f)
4760 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
4761 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4762 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4763 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4764 #elif defined(__NDR_convert__int_rep__int32_t__defined)
4765 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4766 #define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4767 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
4768 #endif /* defined(__NDR_convert__*__defined) */
4769 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4770
4771
4772
4773 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4774 #if defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)
4775 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4776 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4777 __NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
4778 #elif defined(__NDR_convert__char_rep__client_name_t__defined)
4779 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4780 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4781 __NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)
4782 #elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
4783 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4784 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4785 __NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)
4786 #elif defined(__NDR_convert__char_rep__string__defined)
4787 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4788 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4789 __NDR_convert__char_rep__string(a, f, 128)
4790 #endif /* defined(__NDR_convert__*__defined) */
4791 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4792
4793
4794 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4795 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
4796 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4797 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4798 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
4799 #elif defined(__NDR_convert__char_rep__int__defined)
4800 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4801 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4802 __NDR_convert__char_rep__int((int *)(a), f)
4803 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
4804 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4805 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4806 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4807 #elif defined(__NDR_convert__char_rep__int32_t__defined)
4808 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4809 #define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4810 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
4811 #endif /* defined(__NDR_convert__*__defined) */
4812 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4813
4814
4815
4816 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4817 #if defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)
4818 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4819 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4820 __NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)
4821 #elif defined(__NDR_convert__float_rep__client_name_t__defined)
4822 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4823 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4824 __NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)
4825 #elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
4826 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4827 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4828 __NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)
4829 #elif defined(__NDR_convert__float_rep__string__defined)
4830 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined
4831 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \
4832 __NDR_convert__float_rep__string(a, f, 128)
4833 #endif /* defined(__NDR_convert__*__defined) */
4834 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4835
4836
4837 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4838 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
4839 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4840 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4841 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
4842 #elif defined(__NDR_convert__float_rep__int__defined)
4843 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4844 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4845 __NDR_convert__float_rep__int((int *)(a), f)
4846 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
4847 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4848 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4849 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
4850 #elif defined(__NDR_convert__float_rep__int32_t__defined)
4851 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined
4852 #define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \
4853 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
4854 #endif /* defined(__NDR_convert__*__defined) */
4855 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4856
4857
4858
4859 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_get_internal_clientname_t(__Reply__rpc_jack_get_internal_clientname_t *Out0P)
4860 {
4861
4862 typedef __Reply__rpc_jack_get_internal_clientname_t __Reply;
4863 #if __MigTypeCheck
4864 unsigned int msgh_size;
4865 #endif /* __MigTypeCheck */
4866 if (Out0P->Head.msgh_id != 1116) {
4867 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
4868 { return MIG_SERVER_DIED; }
4869 else
4870 { return MIG_REPLY_MISMATCH; }
4871 }
4872
4873 #if __MigTypeCheck
4874 msgh_size = Out0P->Head.msgh_size;
4875
4876 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4877 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
4878 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
4879 Out0P->RetCode == KERN_SUCCESS)))
4880 { return MIG_TYPE_ERROR ; }
4881 #endif /* __MigTypeCheck */
4882
4883 if (Out0P->RetCode != KERN_SUCCESS) {
4884 #ifdef __NDR_convert__mig_reply_error_t__defined
4885 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
4886 #endif /* __NDR_convert__mig_reply_error_t__defined */
4887 return ((mig_reply_error_t *)Out0P)->RetCode;
4888 }
4889
4890 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined) || \
4891 defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
4892 defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4893 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
4894 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined)
4895 __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
4896 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined */
4897 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
4898 __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);
4899 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4900 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4901 __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.int_rep);
4902 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4903 }
4904 #endif /* defined(__NDR_convert__int_rep...) */
4905
4906 #if 0 || \
4907 defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
4908 defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4909 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
4910 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
4911 __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);
4912 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4913 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4914 __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.char_rep);
4915 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4916 }
4917 #endif /* defined(__NDR_convert__char_rep...) */
4918
4919 #if 0 || \
4920 defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \
4921 defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4922 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
4923 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined)
4924 __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);
4925 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */
4926 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined)
4927 __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.float_rep);
4928 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */
4929 }
4930 #endif /* defined(__NDR_convert__float_rep...) */
4931
4932 return MACH_MSG_SUCCESS;
4933 }
4934 #endif /* !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */
4935 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
4936 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
4937
4938
4939 /* Routine rpc_jack_get_internal_clientname */
4940 mig_external kern_return_t rpc_jack_get_internal_clientname
4941 (
4942 mach_port_t server_port,
4943 int refnum,
4944 int int_ref,
4945 client_name_t client_name_res,
4946 int *result
4947 )
4948 {
4949
4950 #ifdef __MigPackStructs
4951 #pragma pack(4)
4952 #endif
4953 typedef struct {
4954 mach_msg_header_t Head;
4955 NDR_record_t NDR;
4956 int refnum;
4957 int int_ref;
4958 } Request;
4959 #ifdef __MigPackStructs
4960 #pragma pack()
4961 #endif
4962
4963 #ifdef __MigPackStructs
4964 #pragma pack(4)
4965 #endif
4966 typedef struct {
4967 mach_msg_header_t Head;
4968 NDR_record_t NDR;
4969 kern_return_t RetCode;
4970 client_name_t client_name_res;
4971 int result;
4972 mach_msg_trailer_t trailer;
4973 } Reply;
4974 #ifdef __MigPackStructs
4975 #pragma pack()
4976 #endif
4977
4978 #ifdef __MigPackStructs
4979 #pragma pack(4)
4980 #endif
4981 typedef struct {
4982 mach_msg_header_t Head;
4983 NDR_record_t NDR;
4984 kern_return_t RetCode;
4985 client_name_t client_name_res;
4986 int result;
4987 } __Reply;
4988 #ifdef __MigPackStructs
4989 #pragma pack()
4990 #endif
4991 /*
4992 * typedef struct {
4993 * mach_msg_header_t Head;
4994 * NDR_record_t NDR;
4995 * kern_return_t RetCode;
4996 * } mig_reply_error_t;
4997 */
4998
4999 union {
5000 Request In;
5001 Reply Out;
5002 } Mess;
5003
5004 Request *InP = &Mess.In;
5005 Reply *Out0P = &Mess.Out;
5006
5007 mach_msg_return_t msg_result;
5008
5009 #ifdef __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined
5010 kern_return_t check_result;
5011 #endif /* __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined */
5012
5013 __DeclareSendRpc(1016, "rpc_jack_get_internal_clientname")
5014
5015 InP->NDR = NDR_record;
5016
5017 InP->refnum = refnum;
5018
5019 InP->int_ref = int_ref;
5020
5021 InP->Head.msgh_bits =
5022 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
5023 /* msgh_size passed as argument */
5024 InP->Head.msgh_request_port = server_port;
5025 InP->Head.msgh_reply_port = mig_get_reply_port();
5026 InP->Head.msgh_id = 1016;
5027
5028 __BeforeSendRpc(1016, "rpc_jack_get_internal_clientname")
5029 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
5030 __AfterSendRpc(1016, "rpc_jack_get_internal_clientname")
5031 if (msg_result != MACH_MSG_SUCCESS) {
5032 __MachMsgErrorWithoutTimeout(msg_result);
5033 { return msg_result; }
5034 }
5035
5036
5037 #if defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined)
5038 check_result = __MIG_check__Reply__rpc_jack_get_internal_clientname_t((__Reply__rpc_jack_get_internal_clientname_t *)Out0P);
5039 if (check_result != MACH_MSG_SUCCESS)
5040 { return check_result; }
5041 #endif /* defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */
5042
5043 (void) mig_strncpy(client_name_res, Out0P->client_name_res, 128);
5044
5045 *result = Out0P->result;
5046
5047 return KERN_SUCCESS;
5048 }
5049
5050 #if ( __MigTypeCheck || __NDR_convert__ )
5051 #if __MIG_check__Reply__JackRPCEngine_subsystem__
5052 #if !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined)
5053 #define __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined
5054 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
5055 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
5056 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
5057 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(a, f) \
5058 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
5059 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
5060 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined
5061 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(a, f) \
5062 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
5063 #endif /* defined(__NDR_convert__*__defined) */
5064 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined */
5065
5066
5067 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5068 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5069 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5070 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5071 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5072 #elif defined(__NDR_convert__int_rep__int__defined)
5073 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5074 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5075 __NDR_convert__int_rep__int((int *)(a), f)
5076 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5077 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5078 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5079 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5080 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5081 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5082 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5083 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5084 #endif /* defined(__NDR_convert__*__defined) */
5085 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5086
5087
5088 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5089 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5090 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5091 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5092 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5093 #elif defined(__NDR_convert__int_rep__int__defined)
5094 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5095 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5096 __NDR_convert__int_rep__int((int *)(a), f)
5097 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5098 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5099 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5100 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5101 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5102 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5103 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5104 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5105 #endif /* defined(__NDR_convert__*__defined) */
5106 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5107
5108
5109 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5110 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5111 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5112 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5113 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5114 #elif defined(__NDR_convert__int_rep__int__defined)
5115 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5116 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5117 __NDR_convert__int_rep__int((int *)(a), f)
5118 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5119 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5120 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5121 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5122 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5123 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5124 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5125 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5126 #endif /* defined(__NDR_convert__*__defined) */
5127 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5128
5129
5130
5131 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5132 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5133 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5134 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5135 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5136 #elif defined(__NDR_convert__char_rep__int__defined)
5137 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5138 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5139 __NDR_convert__char_rep__int((int *)(a), f)
5140 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5141 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5142 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5143 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5144 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5145 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5146 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5147 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5148 #endif /* defined(__NDR_convert__*__defined) */
5149 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5150
5151
5152 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5153 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5154 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5155 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5156 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5157 #elif defined(__NDR_convert__char_rep__int__defined)
5158 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5159 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5160 __NDR_convert__char_rep__int((int *)(a), f)
5161 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5162 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5163 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5164 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5165 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5166 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5167 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5168 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5169 #endif /* defined(__NDR_convert__*__defined) */
5170 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5171
5172
5173 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5174 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5175 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5176 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5177 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5178 #elif defined(__NDR_convert__char_rep__int__defined)
5179 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5180 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5181 __NDR_convert__char_rep__int((int *)(a), f)
5182 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5183 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5184 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5185 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5186 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5187 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5188 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5189 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5190 #endif /* defined(__NDR_convert__*__defined) */
5191 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5192
5193
5194
5195 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5196 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5197 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5198 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5199 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5200 #elif defined(__NDR_convert__float_rep__int__defined)
5201 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5202 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5203 __NDR_convert__float_rep__int((int *)(a), f)
5204 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5205 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5206 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5207 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5208 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5209 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined
5210 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \
5211 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5212 #endif /* defined(__NDR_convert__*__defined) */
5213 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5214
5215
5216 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5217 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5218 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5219 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5220 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5221 #elif defined(__NDR_convert__float_rep__int__defined)
5222 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5223 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5224 __NDR_convert__float_rep__int((int *)(a), f)
5225 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5226 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5227 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5228 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5229 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5230 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined
5231 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \
5232 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5233 #endif /* defined(__NDR_convert__*__defined) */
5234 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5235
5236
5237 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5238 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5239 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5240 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5241 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5242 #elif defined(__NDR_convert__float_rep__int__defined)
5243 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5244 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5245 __NDR_convert__float_rep__int((int *)(a), f)
5246 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5247 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5248 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5249 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5250 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5251 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined
5252 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \
5253 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5254 #endif /* defined(__NDR_convert__*__defined) */
5255 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5256
5257
5258
5259 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clienthandle_t(__Reply__rpc_jack_internal_clienthandle_t *Out0P)
5260 {
5261
5262 typedef __Reply__rpc_jack_internal_clienthandle_t __Reply;
5263 #if __MigTypeCheck
5264 unsigned int msgh_size;
5265 #endif /* __MigTypeCheck */
5266 if (Out0P->Head.msgh_id != 1117) {
5267 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
5268 { return MIG_SERVER_DIED; }
5269 else
5270 { return MIG_REPLY_MISMATCH; }
5271 }
5272
5273 #if __MigTypeCheck
5274 msgh_size = Out0P->Head.msgh_size;
5275
5276 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
5277 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
5278 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
5279 Out0P->RetCode == KERN_SUCCESS)))
5280 { return MIG_TYPE_ERROR ; }
5281 #endif /* __MigTypeCheck */
5282
5283 if (Out0P->RetCode != KERN_SUCCESS) {
5284 #ifdef __NDR_convert__mig_reply_error_t__defined
5285 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
5286 #endif /* __NDR_convert__mig_reply_error_t__defined */
5287 return ((mig_reply_error_t *)Out0P)->RetCode;
5288 }
5289
5290 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined) || \
5291 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
5292 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
5293 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5294 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
5295 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined)
5296 __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
5297 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined */
5298 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
5299 __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep);
5300 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5301 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
5302 __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.int_rep);
5303 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5304 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5305 __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.int_rep);
5306 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5307 }
5308 #endif /* defined(__NDR_convert__int_rep...) */
5309
5310 #if 0 || \
5311 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
5312 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
5313 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5314 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
5315 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
5316 __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep);
5317 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5318 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
5319 __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.char_rep);
5320 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5321 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5322 __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.char_rep);
5323 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5324 }
5325 #endif /* defined(__NDR_convert__char_rep...) */
5326
5327 #if 0 || \
5328 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \
5329 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \
5330 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5331 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
5332 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined)
5333 __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep);
5334 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */
5335 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined)
5336 __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.float_rep);
5337 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */
5338 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined)
5339 __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.float_rep);
5340 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */
5341 }
5342 #endif /* defined(__NDR_convert__float_rep...) */
5343
5344 return MACH_MSG_SUCCESS;
5345 }
5346 #endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */
5347 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
5348 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
5349
5350
5351 /* Routine rpc_jack_internal_clienthandle */
5352 mig_external kern_return_t rpc_jack_internal_clienthandle
5353 (
5354 mach_port_t server_port,
5355 int refnum,
5356 client_name_t client_name,
5357 int *int_ref,
5358 int *status,
5359 int *result
5360 )
5361 {
5362
5363 #ifdef __MigPackStructs
5364 #pragma pack(4)
5365 #endif
5366 typedef struct {
5367 mach_msg_header_t Head;
5368 NDR_record_t NDR;
5369 int refnum;
5370 client_name_t client_name;
5371 } Request;
5372 #ifdef __MigPackStructs
5373 #pragma pack()
5374 #endif
5375
5376 #ifdef __MigPackStructs
5377 #pragma pack(4)
5378 #endif
5379 typedef struct {
5380 mach_msg_header_t Head;
5381 NDR_record_t NDR;
5382 kern_return_t RetCode;
5383 int int_ref;
5384 int status;
5385 int result;
5386 mach_msg_trailer_t trailer;
5387 } Reply;
5388 #ifdef __MigPackStructs
5389 #pragma pack()
5390 #endif
5391
5392 #ifdef __MigPackStructs
5393 #pragma pack(4)
5394 #endif
5395 typedef struct {
5396 mach_msg_header_t Head;
5397 NDR_record_t NDR;
5398 kern_return_t RetCode;
5399 int int_ref;
5400 int status;
5401 int result;
5402 } __Reply;
5403 #ifdef __MigPackStructs
5404 #pragma pack()
5405 #endif
5406 /*
5407 * typedef struct {
5408 * mach_msg_header_t Head;
5409 * NDR_record_t NDR;
5410 * kern_return_t RetCode;
5411 * } mig_reply_error_t;
5412 */
5413
5414 union {
5415 Request In;
5416 Reply Out;
5417 } Mess;
5418
5419 Request *InP = &Mess.In;
5420 Reply *Out0P = &Mess.Out;
5421
5422 mach_msg_return_t msg_result;
5423
5424 #ifdef __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined
5425 kern_return_t check_result;
5426 #endif /* __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined */
5427
5428 __DeclareSendRpc(1017, "rpc_jack_internal_clienthandle")
5429
5430 InP->NDR = NDR_record;
5431
5432 InP->refnum = refnum;
5433
5434 (void) mig_strncpy(InP->client_name, client_name, 128);
5435
5436 InP->Head.msgh_bits =
5437 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
5438 /* msgh_size passed as argument */
5439 InP->Head.msgh_request_port = server_port;
5440 InP->Head.msgh_reply_port = mig_get_reply_port();
5441 InP->Head.msgh_id = 1017;
5442
5443 __BeforeSendRpc(1017, "rpc_jack_internal_clienthandle")
5444 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
5445 __AfterSendRpc(1017, "rpc_jack_internal_clienthandle")
5446 if (msg_result != MACH_MSG_SUCCESS) {
5447 __MachMsgErrorWithoutTimeout(msg_result);
5448 { return msg_result; }
5449 }
5450
5451
5452 #if defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined)
5453 check_result = __MIG_check__Reply__rpc_jack_internal_clienthandle_t((__Reply__rpc_jack_internal_clienthandle_t *)Out0P);
5454 if (check_result != MACH_MSG_SUCCESS)
5455 { return check_result; }
5456 #endif /* defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */
5457
5458 *int_ref = Out0P->int_ref;
5459
5460 *status = Out0P->status;
5461
5462 *result = Out0P->result;
5463
5464 return KERN_SUCCESS;
5465 }
5466
5467 #if ( __MigTypeCheck || __NDR_convert__ )
5468 #if __MIG_check__Reply__JackRPCEngine_subsystem__
5469 #if !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined)
5470 #define __MIG_check__Reply__rpc_jack_internal_clientload_t__defined
5471 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
5472 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
5473 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
5474 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(a, f) \
5475 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
5476 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
5477 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined
5478 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(a, f) \
5479 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
5480 #endif /* defined(__NDR_convert__*__defined) */
5481 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined */
5482
5483
5484 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5485 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5486 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5487 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5488 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5489 #elif defined(__NDR_convert__int_rep__int__defined)
5490 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5491 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5492 __NDR_convert__int_rep__int((int *)(a), f)
5493 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5494 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5495 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5496 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5497 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5498 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5499 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5500 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5501 #endif /* defined(__NDR_convert__*__defined) */
5502 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5503
5504
5505 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5506 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5507 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5508 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5509 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5510 #elif defined(__NDR_convert__int_rep__int__defined)
5511 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5512 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5513 __NDR_convert__int_rep__int((int *)(a), f)
5514 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5515 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5516 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5517 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5518 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5519 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5520 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5521 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5522 #endif /* defined(__NDR_convert__*__defined) */
5523 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5524
5525
5526 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5527 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5528 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5529 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5530 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5531 #elif defined(__NDR_convert__int_rep__int__defined)
5532 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5533 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5534 __NDR_convert__int_rep__int((int *)(a), f)
5535 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5536 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5537 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5538 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5539 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5540 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5541 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5542 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5543 #endif /* defined(__NDR_convert__*__defined) */
5544 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5545
5546
5547
5548 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5549 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5550 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5551 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5552 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5553 #elif defined(__NDR_convert__char_rep__int__defined)
5554 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5555 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5556 __NDR_convert__char_rep__int((int *)(a), f)
5557 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5558 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5559 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5560 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5561 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5562 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5563 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5564 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5565 #endif /* defined(__NDR_convert__*__defined) */
5566 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5567
5568
5569 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5570 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5571 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5572 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5573 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5574 #elif defined(__NDR_convert__char_rep__int__defined)
5575 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5576 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5577 __NDR_convert__char_rep__int((int *)(a), f)
5578 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5579 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5580 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5581 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5582 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5583 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5584 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5585 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5586 #endif /* defined(__NDR_convert__*__defined) */
5587 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5588
5589
5590 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5591 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5592 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5593 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5594 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5595 #elif defined(__NDR_convert__char_rep__int__defined)
5596 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5597 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5598 __NDR_convert__char_rep__int((int *)(a), f)
5599 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5600 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5601 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5602 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5603 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5604 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5605 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5606 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5607 #endif /* defined(__NDR_convert__*__defined) */
5608 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5609
5610
5611
5612 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5613 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5614 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5615 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5616 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5617 #elif defined(__NDR_convert__float_rep__int__defined)
5618 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5619 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5620 __NDR_convert__float_rep__int((int *)(a), f)
5621 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5622 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5623 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5624 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5625 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5626 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined
5627 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \
5628 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5629 #endif /* defined(__NDR_convert__*__defined) */
5630 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5631
5632
5633 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5634 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5635 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5636 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5637 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5638 #elif defined(__NDR_convert__float_rep__int__defined)
5639 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5640 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5641 __NDR_convert__float_rep__int((int *)(a), f)
5642 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5643 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5644 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5645 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5646 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5647 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined
5648 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \
5649 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5650 #endif /* defined(__NDR_convert__*__defined) */
5651 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5652
5653
5654 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5655 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
5656 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5657 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5658 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
5659 #elif defined(__NDR_convert__float_rep__int__defined)
5660 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5661 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5662 __NDR_convert__float_rep__int((int *)(a), f)
5663 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
5664 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5665 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5666 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5667 #elif defined(__NDR_convert__float_rep__int32_t__defined)
5668 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined
5669 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \
5670 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
5671 #endif /* defined(__NDR_convert__*__defined) */
5672 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5673
5674
5675
5676 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientload_t(__Reply__rpc_jack_internal_clientload_t *Out0P)
5677 {
5678
5679 typedef __Reply__rpc_jack_internal_clientload_t __Reply;
5680 #if __MigTypeCheck
5681 unsigned int msgh_size;
5682 #endif /* __MigTypeCheck */
5683 if (Out0P->Head.msgh_id != 1118) {
5684 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
5685 { return MIG_SERVER_DIED; }
5686 else
5687 { return MIG_REPLY_MISMATCH; }
5688 }
5689
5690 #if __MigTypeCheck
5691 msgh_size = Out0P->Head.msgh_size;
5692
5693 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
5694 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
5695 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
5696 Out0P->RetCode == KERN_SUCCESS)))
5697 { return MIG_TYPE_ERROR ; }
5698 #endif /* __MigTypeCheck */
5699
5700 if (Out0P->RetCode != KERN_SUCCESS) {
5701 #ifdef __NDR_convert__mig_reply_error_t__defined
5702 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
5703 #endif /* __NDR_convert__mig_reply_error_t__defined */
5704 return ((mig_reply_error_t *)Out0P)->RetCode;
5705 }
5706
5707 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined) || \
5708 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
5709 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
5710 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5711 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
5712 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined)
5713 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
5714 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined */
5715 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
5716 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.int_rep);
5717 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5718 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
5719 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep);
5720 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5721 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5722 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.int_rep);
5723 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5724 }
5725 #endif /* defined(__NDR_convert__int_rep...) */
5726
5727 #if 0 || \
5728 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
5729 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
5730 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5731 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
5732 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
5733 __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.char_rep);
5734 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5735 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
5736 __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep);
5737 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5738 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5739 __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.char_rep);
5740 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5741 }
5742 #endif /* defined(__NDR_convert__char_rep...) */
5743
5744 #if 0 || \
5745 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \
5746 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \
5747 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5748 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
5749 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined)
5750 __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.float_rep);
5751 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined */
5752 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined)
5753 __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep);
5754 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */
5755 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined)
5756 __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.float_rep);
5757 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined */
5758 }
5759 #endif /* defined(__NDR_convert__float_rep...) */
5760
5761 return MACH_MSG_SUCCESS;
5762 }
5763 #endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */
5764 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
5765 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
5766
5767
5768 /* Routine rpc_jack_internal_clientload */
5769 mig_external kern_return_t rpc_jack_internal_clientload
5770 (
5771 mach_port_t server_port,
5772 int refnum,
5773 client_name_t client_name,
5774 so_name_t so_name,
5775 objet_data_t objet_data,
5776 int options,
5777 int *status,
5778 int *int_ref,
5779 int *result
5780 )
5781 {
5782
5783 #ifdef __MigPackStructs
5784 #pragma pack(4)
5785 #endif
5786 typedef struct {
5787 mach_msg_header_t Head;
5788 NDR_record_t NDR;
5789 int refnum;
5790 client_name_t client_name;
5791 so_name_t so_name;
5792 objet_data_t objet_data;
5793 int options;
5794 } Request;
5795 #ifdef __MigPackStructs
5796 #pragma pack()
5797 #endif
5798
5799 #ifdef __MigPackStructs
5800 #pragma pack(4)
5801 #endif
5802 typedef struct {
5803 mach_msg_header_t Head;
5804 NDR_record_t NDR;
5805 kern_return_t RetCode;
5806 int status;
5807 int int_ref;
5808 int result;
5809 mach_msg_trailer_t trailer;
5810 } Reply;
5811 #ifdef __MigPackStructs
5812 #pragma pack()
5813 #endif
5814
5815 #ifdef __MigPackStructs
5816 #pragma pack(4)
5817 #endif
5818 typedef struct {
5819 mach_msg_header_t Head;
5820 NDR_record_t NDR;
5821 kern_return_t RetCode;
5822 int status;
5823 int int_ref;
5824 int result;
5825 } __Reply;
5826 #ifdef __MigPackStructs
5827 #pragma pack()
5828 #endif
5829 /*
5830 * typedef struct {
5831 * mach_msg_header_t Head;
5832 * NDR_record_t NDR;
5833 * kern_return_t RetCode;
5834 * } mig_reply_error_t;
5835 */
5836
5837 union {
5838 Request In;
5839 Reply Out;
5840 } Mess;
5841
5842 Request *InP = &Mess.In;
5843 Reply *Out0P = &Mess.Out;
5844
5845 mach_msg_return_t msg_result;
5846
5847 #ifdef __MIG_check__Reply__rpc_jack_internal_clientload_t__defined
5848 kern_return_t check_result;
5849 #endif /* __MIG_check__Reply__rpc_jack_internal_clientload_t__defined */
5850
5851 __DeclareSendRpc(1018, "rpc_jack_internal_clientload")
5852
5853 InP->NDR = NDR_record;
5854
5855 InP->refnum = refnum;
5856
5857 (void) mig_strncpy(InP->client_name, client_name, 128);
5858
5859 (void) mig_strncpy(InP->so_name, so_name, 1024);
5860
5861 (void) mig_strncpy(InP->objet_data, objet_data, 1024);
5862
5863 InP->options = options;
5864
5865 InP->Head.msgh_bits =
5866 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
5867 /* msgh_size passed as argument */
5868 InP->Head.msgh_request_port = server_port;
5869 InP->Head.msgh_reply_port = mig_get_reply_port();
5870 InP->Head.msgh_id = 1018;
5871
5872 __BeforeSendRpc(1018, "rpc_jack_internal_clientload")
5873 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
5874 __AfterSendRpc(1018, "rpc_jack_internal_clientload")
5875 if (msg_result != MACH_MSG_SUCCESS) {
5876 __MachMsgErrorWithoutTimeout(msg_result);
5877 { return msg_result; }
5878 }
5879
5880
5881 #if defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined)
5882 check_result = __MIG_check__Reply__rpc_jack_internal_clientload_t((__Reply__rpc_jack_internal_clientload_t *)Out0P);
5883 if (check_result != MACH_MSG_SUCCESS)
5884 { return check_result; }
5885 #endif /* defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */
5886
5887 *status = Out0P->status;
5888
5889 *int_ref = Out0P->int_ref;
5890
5891 *result = Out0P->result;
5892
5893 return KERN_SUCCESS;
5894 }
5895
5896 #if ( __MigTypeCheck || __NDR_convert__ )
5897 #if __MIG_check__Reply__JackRPCEngine_subsystem__
5898 #if !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined)
5899 #define __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined
5900 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
5901 #if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
5902 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
5903 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(a, f) \
5904 __NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)
5905 #elif defined(__NDR_convert__int_rep__kern_return_t__defined)
5906 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined
5907 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(a, f) \
5908 __NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
5909 #endif /* defined(__NDR_convert__*__defined) */
5910 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined */
5911
5912
5913 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5914 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5915 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5916 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5917 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5918 #elif defined(__NDR_convert__int_rep__int__defined)
5919 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5920 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5921 __NDR_convert__int_rep__int((int *)(a), f)
5922 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5923 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5924 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5925 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5926 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5927 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5928 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5929 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5930 #endif /* defined(__NDR_convert__*__defined) */
5931 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
5932
5933
5934 #ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5935 #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
5936 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5937 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5938 __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)
5939 #elif defined(__NDR_convert__int_rep__int__defined)
5940 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5941 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5942 __NDR_convert__int_rep__int((int *)(a), f)
5943 #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)
5944 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5945 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5946 __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5947 #elif defined(__NDR_convert__int_rep__int32_t__defined)
5948 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5949 #define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5950 __NDR_convert__int_rep__int32_t((int32_t *)(a), f)
5951 #endif /* defined(__NDR_convert__*__defined) */
5952 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
5953
5954
5955
5956 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5957 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5958 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5959 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5960 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5961 #elif defined(__NDR_convert__char_rep__int__defined)
5962 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5963 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5964 __NDR_convert__char_rep__int((int *)(a), f)
5965 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5966 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5967 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5968 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5969 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5970 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
5971 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
5972 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5973 #endif /* defined(__NDR_convert__*__defined) */
5974 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
5975
5976
5977 #ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5978 #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
5979 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5980 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5981 __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)
5982 #elif defined(__NDR_convert__char_rep__int__defined)
5983 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5984 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5985 __NDR_convert__char_rep__int((int *)(a), f)
5986 #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)
5987 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5988 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5989 __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
5990 #elif defined(__NDR_convert__char_rep__int32_t__defined)
5991 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
5992 #define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
5993 __NDR_convert__char_rep__int32_t((int32_t *)(a), f)
5994 #endif /* defined(__NDR_convert__*__defined) */
5995 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
5996
5997
5998
5999 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
6000 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
6001 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
6002 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
6003 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
6004 #elif defined(__NDR_convert__float_rep__int__defined)
6005 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
6006 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
6007 __NDR_convert__float_rep__int((int *)(a), f)
6008 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
6009 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
6010 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
6011 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
6012 #elif defined(__NDR_convert__float_rep__int32_t__defined)
6013 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined
6014 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \
6015 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
6016 #endif /* defined(__NDR_convert__*__defined) */
6017 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
6018
6019
6020 #ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
6021 #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
6022 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
6023 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
6024 __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)
6025 #elif defined(__NDR_convert__float_rep__int__defined)
6026 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
6027 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
6028 __NDR_convert__float_rep__int((int *)(a), f)
6029 #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)
6030 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
6031 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
6032 __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)
6033 #elif defined(__NDR_convert__float_rep__int32_t__defined)
6034 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined
6035 #define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \
6036 __NDR_convert__float_rep__int32_t((int32_t *)(a), f)
6037 #endif /* defined(__NDR_convert__*__defined) */
6038 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
6039
6040
6041
6042 mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientunload_t(__Reply__rpc_jack_internal_clientunload_t *Out0P)
6043 {
6044
6045 typedef __Reply__rpc_jack_internal_clientunload_t __Reply;
6046 #if __MigTypeCheck
6047 unsigned int msgh_size;
6048 #endif /* __MigTypeCheck */
6049 if (Out0P->Head.msgh_id != 1119) {
6050 if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
6051 { return MIG_SERVER_DIED; }
6052 else
6053 { return MIG_REPLY_MISMATCH; }
6054 }
6055
6056 #if __MigTypeCheck
6057 msgh_size = Out0P->Head.msgh_size;
6058
6059 if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
6060 ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
6061 (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
6062 Out0P->RetCode == KERN_SUCCESS)))
6063 { return MIG_TYPE_ERROR ; }
6064 #endif /* __MigTypeCheck */
6065
6066 if (Out0P->RetCode != KERN_SUCCESS) {
6067 #ifdef __NDR_convert__mig_reply_error_t__defined
6068 __NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
6069 #endif /* __NDR_convert__mig_reply_error_t__defined */
6070 return ((mig_reply_error_t *)Out0P)->RetCode;
6071 }
6072
6073 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined) || \
6074 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
6075 defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6076 if (Out0P->NDR.int_rep != NDR_record.int_rep) {
6077 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined)
6078 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
6079 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined */
6080 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
6081 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.int_rep);
6082 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
6083 #if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6084 __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.int_rep);
6085 #endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
6086 }
6087 #endif /* defined(__NDR_convert__int_rep...) */
6088
6089 #if 0 || \
6090 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
6091 defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6092 if (Out0P->NDR.char_rep != NDR_record.char_rep) {
6093 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
6094 __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.char_rep);
6095 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
6096 #if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6097 __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.char_rep);
6098 #endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
6099 }
6100 #endif /* defined(__NDR_convert__char_rep...) */
6101
6102 #if 0 || \
6103 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \
6104 defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6105 if (Out0P->NDR.float_rep != NDR_record.float_rep) {
6106 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined)
6107 __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.float_rep);
6108 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */
6109 #if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined)
6110 __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.float_rep);
6111 #endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */
6112 }
6113 #endif /* defined(__NDR_convert__float_rep...) */
6114
6115 return MACH_MSG_SUCCESS;
6116 }
6117 #endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */
6118 #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
6119 #endif /* ( __MigTypeCheck || __NDR_convert__ ) */
6120
6121
6122 /* Routine rpc_jack_internal_clientunload */
6123 mig_external kern_return_t rpc_jack_internal_clientunload
6124 (
6125 mach_port_t server_port,
6126 int refnum,
6127 int int_ref,
6128 int *status,
6129 int *result
6130 )
6131 {
6132
6133 #ifdef __MigPackStructs
6134 #pragma pack(4)
6135 #endif
6136 typedef struct {
6137 mach_msg_header_t Head;
6138 NDR_record_t NDR;
6139 int refnum;
6140 int int_ref;
6141 } Request;
6142 #ifdef __MigPackStructs
6143 #pragma pack()
6144 #endif
6145
6146 #ifdef __MigPackStructs
6147 #pragma pack(4)
6148 #endif
6149 typedef struct {
6150 mach_msg_header_t Head;
6151 NDR_record_t NDR;
6152 kern_return_t RetCode;
6153 int status;
6154 int result;
6155 mach_msg_trailer_t trailer;
6156 } Reply;
6157 #ifdef __MigPackStructs
6158 #pragma pack()
6159 #endif
6160
6161 #ifdef __MigPackStructs
6162 #pragma pack(4)
6163 #endif
6164 typedef struct {
6165 mach_msg_header_t Head;
6166 NDR_record_t NDR;
6167 kern_return_t RetCode;
6168 int status;
6169 int result;
6170 } __Reply;
6171 #ifdef __MigPackStructs
6172 #pragma pack()
6173 #endif
6174 /*
6175 * typedef struct {
6176 * mach_msg_header_t Head;
6177 * NDR_record_t NDR;
6178 * kern_return_t RetCode;
6179 * } mig_reply_error_t;
6180 */
6181
6182 union {
6183 Request In;
6184 Reply Out;
6185 } Mess;
6186
6187 Request *InP = &Mess.In;
6188 Reply *Out0P = &Mess.Out;
6189
6190 mach_msg_return_t msg_result;
6191
6192 #ifdef __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined
6193 kern_return_t check_result;
6194 #endif /* __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined */
6195
6196 __DeclareSendRpc(1019, "rpc_jack_internal_clientunload")
6197
6198 InP->NDR = NDR_record;
6199
6200 InP->refnum = refnum;
6201
6202 InP->int_ref = int_ref;
6203
6204 InP->Head.msgh_bits =
6205 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
6206 /* msgh_size passed as argument */
6207 InP->Head.msgh_request_port = server_port;
6208 InP->Head.msgh_reply_port = mig_get_reply_port();
6209 InP->Head.msgh_id = 1019;
6210
6211 __BeforeSendRpc(1019, "rpc_jack_internal_clientunload")
6212 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
6213 __AfterSendRpc(1019, "rpc_jack_internal_clientunload")
6214 if (msg_result != MACH_MSG_SUCCESS) {
6215 __MachMsgErrorWithoutTimeout(msg_result);
6216 { return msg_result; }
6217 }
6218
6219
6220 #if defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined)
6221 check_result = __MIG_check__Reply__rpc_jack_internal_clientunload_t((__Reply__rpc_jack_internal_clientunload_t *)Out0P);
6222 if (check_result != MACH_MSG_SUCCESS)
6223 { return check_result; }
6224 #endif /* defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */
6225
6226 *status = Out0P->status;
6227
6228 *result = Out0P->result;
6229
6230 return KERN_SUCCESS;
6231 }
6232
6233 /* SimpleRoutine rpc_jack_client_rt_notify */
6234 mig_external kern_return_t rpc_jack_client_rt_notify
6235 (
6236 mach_port_t client_port,
6237 int refnum,
6238 int notify,
6239 int value,
6240 int timeout
6241 )
6242 {
6243
6244 #ifdef __MigPackStructs
6245 #pragma pack(4)
6246 #endif
6247 typedef struct {
6248 mach_msg_header_t Head;
6249 NDR_record_t NDR;
6250 int refnum;
6251 int notify;
6252 int value;
6253 } Request;
6254 #ifdef __MigPackStructs
6255 #pragma pack()
6256 #endif
6257 /*
6258 * typedef struct {
6259 * mach_msg_header_t Head;
6260 * NDR_record_t NDR;
6261 * kern_return_t RetCode;
6262 * } mig_reply_error_t;
6263 */
6264
6265 union {
6266 Request In;
6267 } Mess;
6268
6269 Request *InP = &Mess.In;
6270
6271 mach_msg_return_t msg_result;
6272
6273 #ifdef __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined
6274 kern_return_t check_result;
6275 #endif /* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */
6276
6277 __DeclareSendSimple(1020, "rpc_jack_client_rt_notify")
6278
6279 InP->NDR = NDR_record;
6280
6281 InP->refnum = refnum;
6282
6283 InP->notify = notify;
6284
6285 InP->value = value;
6286
6287 InP->Head.msgh_bits =
6288 MACH_MSGH_BITS(19, 0);
6289 /* msgh_size passed as argument */
6290 InP->Head.msgh_request_port = client_port;
6291 InP->Head.msgh_reply_port = MACH_PORT_NULL;
6292 InP->Head.msgh_id = 1020;
6293
6294 __BeforeSendSimple(1020, "rpc_jack_client_rt_notify")
6295 msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, timeout, MACH_PORT_NULL);
6296 __AfterSendSimple(1020, "rpc_jack_client_rt_notify")
6297
6298 if (msg_result == MACH_SEND_TIMED_OUT) {
6299 }
6300
6301 return msg_result;
6302 }
JACK2 codebase