jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
172 Commits
8 Branches
256MB
Tree: bb25e2e701
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bb25e2e701'
${ noResults }
jack2/macosx/RPC/JackRPCEngineUser.c

4116 lines
171KB
Raw Blame History 

  1. /*

  2.  * IDENTIFICATION:

  3.  * stub generated Tue Jan 30 00:00:52 2007

  4.  * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.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_REPLY: \

  54. 	case MACH_RCV_INVALID_NAME: \

  55. 	case MACH_RCV_PORT_DIED: \

  56. 	case MACH_RCV_PORT_CHANGED: \

  57. 	case MACH_RCV_TIMED_OUT: \

  58. 		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \

  59. 		break; \

  60. 	default: \

  61. 		mig_put_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_REPLY: \

  70. 	case MACH_RCV_INVALID_NAME: \

  71. 	case MACH_RCV_PORT_DIED: \

  72. 	case MACH_RCV_PORT_CHANGED: \

  73. 		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \

  74. 		break; \

  75. 	default: \

  76. 		mig_put_reply_port(InP->Head.msgh_reply_port); \

  77. 	} \

  78. }

  79. #endif	/* __MachMsgErrorWithoutTimeout */

  80. 

  81. #ifndef	__DeclareSendRpc

  82. #define	__DeclareSendRpc(_NUM_, _NAME_)

  83. #endif	/* __DeclareSendRpc */

  84. 

  85. #ifndef	__BeforeSendRpc

  86. #define	__BeforeSendRpc(_NUM_, _NAME_)

  87. #endif	/* __BeforeSendRpc */

  88. 

  89. #ifndef	__AfterSendRpc

  90. #define	__AfterSendRpc(_NUM_, _NAME_)

  91. #endif	/* __AfterSendRpc */

  92. 

  93. #ifndef	__DeclareSendSimple

  94. #define	__DeclareSendSimple(_NUM_, _NAME_)

  95. #endif	/* __DeclareSendSimple */

  96. 

  97. #ifndef	__BeforeSendSimple

  98. #define	__BeforeSendSimple(_NUM_, _NAME_)

  99. #endif	/* __BeforeSendSimple */

  100. 

  101. #ifndef	__AfterSendSimple

  102. #define	__AfterSendSimple(_NUM_, _NAME_)

  103. #endif	/* __AfterSendSimple */

  104. 

  105. #define msgh_request_port	msgh_remote_port

  106. #define msgh_reply_port		msgh_local_port

  107. 

  108. 

  109. 

  110. #if ( __MigTypeCheck || __NDR_convert__ )

  111. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  112. #if !defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)

  113. #define __MIG_check__Reply__rpc_jack_client_open_t__defined

  114. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  115. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  116. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  117. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  118. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  119. #elif	defined(__NDR_convert__int_rep__int__defined)

  120. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  121. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  122. 	__NDR_convert__int_rep__int((int *)(a), f)

  123. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  124. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  125. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  126. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  127. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  128. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  129. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  130. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  131. #endif /* defined(__NDR_convert__*__defined) */

  132. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */

  133. 

  134. 

  135. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  136. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  137. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  138. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  139. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  140. #elif	defined(__NDR_convert__int_rep__int__defined)

  141. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  142. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  143. 	__NDR_convert__int_rep__int((int *)(a), f)

  144. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  145. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  146. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  147. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  148. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  149. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  150. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  151. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  152. #endif /* defined(__NDR_convert__*__defined) */

  153. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_client__defined */

  154. 

  155. 

  156. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  157. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  158. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  159. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  160. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  161. #elif	defined(__NDR_convert__int_rep__int__defined)

  162. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  163. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  164. 	__NDR_convert__int_rep__int((int *)(a), f)

  165. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  166. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  167. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  168. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  169. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  170. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  171. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  172. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  173. #endif /* defined(__NDR_convert__*__defined) */

  174. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */

  175. 

  176. 

  177. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined

  178. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  179. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined

  180. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  181. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  182. #elif	defined(__NDR_convert__int_rep__int__defined)

  183. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined

  184. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  185. 	__NDR_convert__int_rep__int((int *)(a), f)

  186. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  187. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined

  188. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  189. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  190. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  191. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined

  192. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  193. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  194. #endif /* defined(__NDR_convert__*__defined) */

  195. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_open_t__result__defined */

  196. 

  197. 

  198. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  199. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  200. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  201. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  202. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  203. #elif	defined(__NDR_convert__char_rep__int__defined)

  204. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  205. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  206. 	__NDR_convert__char_rep__int((int *)(a), f)

  207. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  208. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  209. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  210. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  211. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  212. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  213. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  214. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  215. #endif /* defined(__NDR_convert__*__defined) */

  216. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */

  217. 

  218. 

  219. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  220. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  221. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  222. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  223. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  224. #elif	defined(__NDR_convert__char_rep__int__defined)

  225. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  226. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  227. 	__NDR_convert__char_rep__int((int *)(a), f)

  228. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  229. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  230. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  231. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  232. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  233. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  234. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  235. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  236. #endif /* defined(__NDR_convert__*__defined) */

  237. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_client__defined */

  238. 

  239. 

  240. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  241. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  242. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  243. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  244. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  245. #elif	defined(__NDR_convert__char_rep__int__defined)

  246. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  247. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  248. 	__NDR_convert__char_rep__int((int *)(a), f)

  249. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  250. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  251. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  252. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  253. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  254. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  255. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  256. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  257. #endif /* defined(__NDR_convert__*__defined) */

  258. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */

  259. 

  260. 

  261. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined

  262. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  263. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined

  264. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  265. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  266. #elif	defined(__NDR_convert__char_rep__int__defined)

  267. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined

  268. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  269. 	__NDR_convert__char_rep__int((int *)(a), f)

  270. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  271. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined

  272. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  273. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  274. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  275. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined

  276. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  277. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  278. #endif /* defined(__NDR_convert__*__defined) */

  279. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_open_t__result__defined */

  280. 

  281. 

  282. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  283. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  284. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  285. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  286. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  287. #elif	defined(__NDR_convert__float_rep__int__defined)

  288. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  289. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  290. 	__NDR_convert__float_rep__int((int *)(a), f)

  291. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  292. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  293. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  294. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  295. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  296. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined

  297. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine(a, f) \

  298. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  299. #endif /* defined(__NDR_convert__*__defined) */

  300. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_engine__defined */

  301. 

  302. 

  303. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  304. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  305. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  306. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  307. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  308. #elif	defined(__NDR_convert__float_rep__int__defined)

  309. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  310. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  311. 	__NDR_convert__float_rep__int((int *)(a), f)

  312. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  313. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  314. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  315. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  316. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  317. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined

  318. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client(a, f) \

  319. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  320. #endif /* defined(__NDR_convert__*__defined) */

  321. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_client__defined */

  322. 

  323. 

  324. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  325. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  326. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  327. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  328. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  329. #elif	defined(__NDR_convert__float_rep__int__defined)

  330. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  331. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  332. 	__NDR_convert__float_rep__int((int *)(a), f)

  333. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  334. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  335. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  336. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  337. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  338. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined

  339. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph(a, f) \

  340. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  341. #endif /* defined(__NDR_convert__*__defined) */

  342. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__shared_graph__defined */

  343. 

  344. 

  345. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined

  346. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  347. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined

  348. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  349. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  350. #elif	defined(__NDR_convert__float_rep__int__defined)

  351. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined

  352. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  353. 	__NDR_convert__float_rep__int((int *)(a), f)

  354. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  355. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined

  356. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  357. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  358. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  359. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined

  360. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result(a, f) \

  361. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  362. #endif /* defined(__NDR_convert__*__defined) */

  363. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_open_t__result__defined */

  364. 

  365. 

  366. 

  367. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_open_t(__Reply__rpc_jack_client_open_t *Out0P)

  368. {

  369. 

  370. 	typedef __Reply__rpc_jack_client_open_t __Reply;

  371. 	boolean_t msgh_simple;

  372. #if	__MigTypeCheck

  373. 	unsigned int msgh_size;

  374. #endif	/* __MigTypeCheck */

  375. 	if (Out0P->Head.msgh_id != 1100) {

  376. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  377. 		{ return MIG_SERVER_DIED; }

  378. 	    else

  379. 		{ return MIG_REPLY_MISMATCH; }

  380. 	}

  381. 

  382. 	msgh_simple = !(Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

  383. #if	__MigTypeCheck

  384. 	msgh_size = Out0P->Head.msgh_size;

  385. 

  386. 	if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||

  387. 	    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  388. 	    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  389. 	    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))

  390. 		{ return MIG_TYPE_ERROR ; }

  391. #endif	/* __MigTypeCheck */

  392. 

  393. 	if (msgh_simple) {

  394. #ifdef	__NDR_convert__mig_reply_error_t__defined

  395. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  396. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  397. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  398. 	}

  399. 

  400. #if	__MigTypeCheck

  401. 	if (Out0P->private_port.type != MACH_MSG_PORT_DESCRIPTOR ||

  402. 	    Out0P->private_port.disposition != 17)

  403. 		{ return MIG_TYPE_ERROR; }

  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. 	mach_port_t *private_port,

  479. 	int *shared_engine,

  480. 	int *shared_client,

  481. 	int *shared_graph,

  482. 	int *result

  483. )

  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. 	} Request;

  495. #ifdef  __MigPackStructs

  496. #pragma pack()

  497. #endif

  498. 

  499. #ifdef  __MigPackStructs

  500. #pragma pack(4)

  501. #endif

  502. 	typedef struct {

  503. 		mach_msg_header_t Head;

  504. 		/* start of the kernel processed data */

  505. 		mach_msg_body_t msgh_body;

  506. 		mach_msg_port_descriptor_t private_port;

  507. 		/* end of the kernel processed data */

  508. 		NDR_record_t NDR;

  509. 		int shared_engine;

  510. 		int shared_client;

  511. 		int shared_graph;

  512. 		int result;

  513. 		mach_msg_trailer_t trailer;

  514. 	} Reply;

  515. #ifdef  __MigPackStructs

  516. #pragma pack()

  517. #endif

  518. 

  519. #ifdef  __MigPackStructs

  520. #pragma pack(4)

  521. #endif

  522. 	typedef struct {

  523. 		mach_msg_header_t Head;

  524. 		/* start of the kernel processed data */

  525. 		mach_msg_body_t msgh_body;

  526. 		mach_msg_port_descriptor_t private_port;

  527. 		/* end of the kernel processed data */

  528. 		NDR_record_t NDR;

  529. 		int shared_engine;

  530. 		int shared_client;

  531. 		int shared_graph;

  532. 		int result;

  533. 	} __Reply;

  534. #ifdef  __MigPackStructs

  535. #pragma pack()

  536. #endif

  537. 	/*

  538. 	 * typedef struct {

  539. 	 * 	mach_msg_header_t Head;

  540. 	 * 	NDR_record_t NDR;

  541. 	 * 	kern_return_t RetCode;

  542. 	 * } mig_reply_error_t;

  543. 	 */

  544. 

  545. 	union {

  546. 		Request In;

  547. 		Reply Out;

  548. 	} Mess;

  549. 

  550. 	Request *InP = &Mess.In;

  551. 	Reply *Out0P = &Mess.Out;

  552. 

  553. 	mach_msg_return_t msg_result;

  554. 

  555. #ifdef	__MIG_check__Reply__rpc_jack_client_open_t__defined

  556. 	kern_return_t check_result;

  557. #endif	/* __MIG_check__Reply__rpc_jack_client_open_t__defined */

  558. 

  559. 	__DeclareSendRpc(1000, "rpc_jack_client_open")

  560. 

  561. 	InP->NDR = NDR_record;

  562. 

  563. 	(void) mig_strncpy(InP->client_name, client_name, 128);

  564. 

  565. 	InP->Head.msgh_bits =

  566. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  567. 	/* msgh_size passed as argument */

  568. 	InP->Head.msgh_request_port = server_port;

  569. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  570. 	InP->Head.msgh_id = 1000;

  571. 

  572. 	__BeforeSendRpc(1000, "rpc_jack_client_open")

  573. 	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);

  574. 	__AfterSendRpc(1000, "rpc_jack_client_open")

  575. 	if (msg_result != MACH_MSG_SUCCESS) {

  576. 		__MachMsgErrorWithoutTimeout(msg_result);

  577. 		{ return msg_result; }

  578. 	}

  579. 

  580. 

  581. #if	defined(__MIG_check__Reply__rpc_jack_client_open_t__defined)

  582. 	check_result = __MIG_check__Reply__rpc_jack_client_open_t((__Reply__rpc_jack_client_open_t *)Out0P);

  583. 	if (check_result != MACH_MSG_SUCCESS)

  584. 		{ return check_result; }

  585. #endif	/* defined(__MIG_check__Reply__rpc_jack_client_open_t__defined) */

  586. 

  587. 	*private_port = Out0P->private_port.name;

  588. 	*shared_engine = Out0P->shared_engine;

  589. 

  590. 	*shared_client = Out0P->shared_client;

  591. 

  592. 	*shared_graph = Out0P->shared_graph;

  593. 

  594. 	*result = Out0P->result;

  595. 

  596. 	return KERN_SUCCESS;

  597.     }

  598. }

  599. 

  600. #if ( __MigTypeCheck || __NDR_convert__ )

  601. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  602. #if !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)

  603. #define __MIG_check__Reply__rpc_jack_client_close_t__defined

  604. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  605. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  606. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  607. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \

  608. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  609. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  610. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  611. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \

  612. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  613. #endif /* defined(__NDR_convert__*__defined) */

  614. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */

  615. 

  616. 

  617. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  618. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  619. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  620. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  621. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  622. #elif	defined(__NDR_convert__int_rep__int__defined)

  623. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  624. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  625. 	__NDR_convert__int_rep__int((int *)(a), f)

  626. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  627. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  628. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  629. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  630. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  631. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  632. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  633. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  634. #endif /* defined(__NDR_convert__*__defined) */

  635. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */

  636. 

  637. 

  638. 

  639. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  640. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  641. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  642. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  643. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  644. #elif	defined(__NDR_convert__char_rep__int__defined)

  645. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  646. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  647. 	__NDR_convert__char_rep__int((int *)(a), f)

  648. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  649. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  650. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  651. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  652. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  653. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  654. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  655. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  656. #endif /* defined(__NDR_convert__*__defined) */

  657. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */

  658. 

  659. 

  660. 

  661. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  662. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  663. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  664. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  665. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  666. #elif	defined(__NDR_convert__float_rep__int__defined)

  667. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  668. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  669. 	__NDR_convert__float_rep__int((int *)(a), f)

  670. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  671. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  672. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  673. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  674. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  675. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  676. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

  677. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  678. #endif /* defined(__NDR_convert__*__defined) */

  679. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */

  680. 

  681. 

  682. 

  683. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_close_t(__Reply__rpc_jack_client_close_t *Out0P)

  684. {

  685. 

  686. 	typedef __Reply__rpc_jack_client_close_t __Reply;

  687. #if	__MigTypeCheck

  688. 	unsigned int msgh_size;

  689. #endif	/* __MigTypeCheck */

  690. 	if (Out0P->Head.msgh_id != 1101) {

  691. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  692. 		{ return MIG_SERVER_DIED; }

  693. 	    else

  694. 		{ return MIG_REPLY_MISMATCH; }

  695. 	}

  696. 

  697. #if	__MigTypeCheck

  698. 	msgh_size = Out0P->Head.msgh_size;

  699. 

  700. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  701. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  702. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  703. 	      Out0P->RetCode == KERN_SUCCESS)))

  704. 		{ return MIG_TYPE_ERROR ; }

  705. #endif	/* __MigTypeCheck */

  706. 

  707. 	if (Out0P->RetCode != KERN_SUCCESS) {

  708. #ifdef	__NDR_convert__mig_reply_error_t__defined

  709. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  710. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  711. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  712. 	}

  713. 

  714. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined) || \

  715. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)

  716. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  717. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined)

  718. 		__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  719. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */

  720. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)

  721. 		__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.int_rep);

  722. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */

  723. 	}

  724. #endif	/* defined(__NDR_convert__int_rep...) */

  725. 

  726. #if	0 || \

  727. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)

  728. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  729. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)

  730. 		__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.char_rep);

  731. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */

  732. 	}

  733. #endif	/* defined(__NDR_convert__char_rep...) */

  734. 

  735. #if	0 || \

  736. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)

  737. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  738. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)

  739. 		__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(&Out0P->result, Out0P->NDR.float_rep);

  740. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */

  741. 	}

  742. #endif	/* defined(__NDR_convert__float_rep...) */

  743. 

  744. 	return MACH_MSG_SUCCESS;

  745. }

  746. #endif /* !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */

  747. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  748. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  749. 

  750. 

  751. /* Routine rpc_jack_client_close */

  752. mig_external kern_return_t rpc_jack_client_close

  753. (

  754. 	mach_port_t server_port,

  755. 	int refnum,

  756. 	int *result

  757. )

  758. {

  759.     {

  760. 

  761. #ifdef  __MigPackStructs

  762. #pragma pack(4)

  763. #endif

  764. 	typedef struct {

  765. 		mach_msg_header_t Head;

  766. 		NDR_record_t NDR;

  767. 		int refnum;

  768. 	} Request;

  769. #ifdef  __MigPackStructs

  770. #pragma pack()

  771. #endif

  772. 

  773. #ifdef  __MigPackStructs

  774. #pragma pack(4)

  775. #endif

  776. 	typedef struct {

  777. 		mach_msg_header_t Head;

  778. 		NDR_record_t NDR;

  779. 		kern_return_t RetCode;

  780. 		int result;

  781. 		mach_msg_trailer_t trailer;

  782. 	} Reply;

  783. #ifdef  __MigPackStructs

  784. #pragma pack()

  785. #endif

  786. 

  787. #ifdef  __MigPackStructs

  788. #pragma pack(4)

  789. #endif

  790. 	typedef struct {

  791. 		mach_msg_header_t Head;

  792. 		NDR_record_t NDR;

  793. 		kern_return_t RetCode;

  794. 		int result;

  795. 	} __Reply;

  796. #ifdef  __MigPackStructs

  797. #pragma pack()

  798. #endif

  799. 	/*

  800. 	 * typedef struct {

  801. 	 * 	mach_msg_header_t Head;

  802. 	 * 	NDR_record_t NDR;

  803. 	 * 	kern_return_t RetCode;

  804. 	 * } mig_reply_error_t;

  805. 	 */

  806. 

  807. 	union {

  808. 		Request In;

  809. 		Reply Out;

  810. 	} Mess;

  811. 

  812. 	Request *InP = &Mess.In;

  813. 	Reply *Out0P = &Mess.Out;

  814. 

  815. 	mach_msg_return_t msg_result;

  816. 

  817. #ifdef	__MIG_check__Reply__rpc_jack_client_close_t__defined

  818. 	kern_return_t check_result;

  819. #endif	/* __MIG_check__Reply__rpc_jack_client_close_t__defined */

  820. 

  821. 	__DeclareSendRpc(1001, "rpc_jack_client_close")

  822. 

  823. 	InP->NDR = NDR_record;

  824. 

  825. 	InP->refnum = refnum;

  826. 

  827. 	InP->Head.msgh_bits =

  828. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  829. 	/* msgh_size passed as argument */

  830. 	InP->Head.msgh_request_port = server_port;

  831. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  832. 	InP->Head.msgh_id = 1001;

  833. 

  834. 	__BeforeSendRpc(1001, "rpc_jack_client_close")

  835. 	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);

  836. 	__AfterSendRpc(1001, "rpc_jack_client_close")

  837. 	if (msg_result != MACH_MSG_SUCCESS) {

  838. 		__MachMsgErrorWithoutTimeout(msg_result);

  839. 		{ return msg_result; }

  840. 	}

  841. 

  842. 

  843. #if	defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)

  844. 	check_result = __MIG_check__Reply__rpc_jack_client_close_t((__Reply__rpc_jack_client_close_t *)Out0P);

  845. 	if (check_result != MACH_MSG_SUCCESS)

  846. 		{ return check_result; }

  847. #endif	/* defined(__MIG_check__Reply__rpc_jack_client_close_t__defined) */

  848. 

  849. 	*result = Out0P->result;

  850. 

  851. 	return KERN_SUCCESS;

  852.     }

  853. }

  854. 

  855. #if ( __MigTypeCheck || __NDR_convert__ )

  856. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  857. #if !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)

  858. #define __MIG_check__Reply__rpc_jack_client_activate_t__defined

  859. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  860. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  861. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  862. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \

  863. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  864. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  865. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  866. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \

  867. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  868. #endif /* defined(__NDR_convert__*__defined) */

  869. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */

  870. 

  871. 

  872. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  873. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  874. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  875. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  876. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  877. #elif	defined(__NDR_convert__int_rep__int__defined)

  878. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  879. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  880. 	__NDR_convert__int_rep__int((int *)(a), f)

  881. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  882. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  883. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  884. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  885. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  886. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  887. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  888. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  889. #endif /* defined(__NDR_convert__*__defined) */

  890. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */

  891. 

  892. 

  893. 

  894. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  895. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  896. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  897. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  898. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  899. #elif	defined(__NDR_convert__char_rep__int__defined)

  900. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  901. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  902. 	__NDR_convert__char_rep__int((int *)(a), f)

  903. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  904. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  905. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  906. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  907. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  908. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  909. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  910. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  911. #endif /* defined(__NDR_convert__*__defined) */

  912. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */

  913. 

  914. 

  915. 

  916. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  917. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  918. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  919. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  920. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  921. #elif	defined(__NDR_convert__float_rep__int__defined)

  922. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  923. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  924. 	__NDR_convert__float_rep__int((int *)(a), f)

  925. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  926. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  927. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  928. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  929. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  930. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  931. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

  932. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  933. #endif /* defined(__NDR_convert__*__defined) */

  934. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */

  935. 

  936. 

  937. 

  938. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_activate_t(__Reply__rpc_jack_client_activate_t *Out0P)

  939. {

  940. 

  941. 	typedef __Reply__rpc_jack_client_activate_t __Reply;

  942. #if	__MigTypeCheck

  943. 	unsigned int msgh_size;

  944. #endif	/* __MigTypeCheck */

  945. 	if (Out0P->Head.msgh_id != 1102) {

  946. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  947. 		{ return MIG_SERVER_DIED; }

  948. 	    else

  949. 		{ return MIG_REPLY_MISMATCH; }

  950. 	}

  951. 

  952. #if	__MigTypeCheck

  953. 	msgh_size = Out0P->Head.msgh_size;

  954. 

  955. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  956. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  957. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  958. 	      Out0P->RetCode == KERN_SUCCESS)))

  959. 		{ return MIG_TYPE_ERROR ; }

  960. #endif	/* __MigTypeCheck */

  961. 

  962. 	if (Out0P->RetCode != KERN_SUCCESS) {

  963. #ifdef	__NDR_convert__mig_reply_error_t__defined

  964. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  965. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  966. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  967. 	}

  968. 

  969. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined) || \

  970. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)

  971. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  972. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined)

  973. 		__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  974. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */

  975. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)

  976. 		__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.int_rep);

  977. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */

  978. 	}

  979. #endif	/* defined(__NDR_convert__int_rep...) */

  980. 

  981. #if	0 || \

  982. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)

  983. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  984. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)

  985. 		__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.char_rep);

  986. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */

  987. 	}

  988. #endif	/* defined(__NDR_convert__char_rep...) */

  989. 

  990. #if	0 || \

  991. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)

  992. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  993. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)

  994. 		__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(&Out0P->result, Out0P->NDR.float_rep);

  995. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */

  996. 	}

  997. #endif	/* defined(__NDR_convert__float_rep...) */

  998. 

  999. 	return MACH_MSG_SUCCESS;

  1000. }

  1001. #endif /* !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */

  1002. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  1003. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  1004. 

  1005. 

  1006. /* Routine rpc_jack_client_activate */

  1007. mig_external kern_return_t rpc_jack_client_activate

  1008. (

  1009. 	mach_port_t server_port,

  1010. 	int refnum,

  1011. 	int *result

  1012. )

  1013. {

  1014.     {

  1015. 

  1016. #ifdef  __MigPackStructs

  1017. #pragma pack(4)

  1018. #endif

  1019. 	typedef struct {

  1020. 		mach_msg_header_t Head;

  1021. 		NDR_record_t NDR;

  1022. 		int refnum;

  1023. 	} Request;

  1024. #ifdef  __MigPackStructs

  1025. #pragma pack()

  1026. #endif

  1027. 

  1028. #ifdef  __MigPackStructs

  1029. #pragma pack(4)

  1030. #endif

  1031. 	typedef struct {

  1032. 		mach_msg_header_t Head;

  1033. 		NDR_record_t NDR;

  1034. 		kern_return_t RetCode;

  1035. 		int result;

  1036. 		mach_msg_trailer_t trailer;

  1037. 	} Reply;

  1038. #ifdef  __MigPackStructs

  1039. #pragma pack()

  1040. #endif

  1041. 

  1042. #ifdef  __MigPackStructs

  1043. #pragma pack(4)

  1044. #endif

  1045. 	typedef struct {

  1046. 		mach_msg_header_t Head;

  1047. 		NDR_record_t NDR;

  1048. 		kern_return_t RetCode;

  1049. 		int result;

  1050. 	} __Reply;

  1051. #ifdef  __MigPackStructs

  1052. #pragma pack()

  1053. #endif

  1054. 	/*

  1055. 	 * typedef struct {

  1056. 	 * 	mach_msg_header_t Head;

  1057. 	 * 	NDR_record_t NDR;

  1058. 	 * 	kern_return_t RetCode;

  1059. 	 * } mig_reply_error_t;

  1060. 	 */

  1061. 

  1062. 	union {

  1063. 		Request In;

  1064. 		Reply Out;

  1065. 	} Mess;

  1066. 

  1067. 	Request *InP = &Mess.In;

  1068. 	Reply *Out0P = &Mess.Out;

  1069. 

  1070. 	mach_msg_return_t msg_result;

  1071. 

  1072. #ifdef	__MIG_check__Reply__rpc_jack_client_activate_t__defined

  1073. 	kern_return_t check_result;

  1074. #endif	/* __MIG_check__Reply__rpc_jack_client_activate_t__defined */

  1075. 

  1076. 	__DeclareSendRpc(1002, "rpc_jack_client_activate")

  1077. 

  1078. 	InP->NDR = NDR_record;

  1079. 

  1080. 	InP->refnum = refnum;

  1081. 

  1082. 	InP->Head.msgh_bits =

  1083. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1084. 	/* msgh_size passed as argument */

  1085. 	InP->Head.msgh_request_port = server_port;

  1086. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  1087. 	InP->Head.msgh_id = 1002;

  1088. 

  1089. 	__BeforeSendRpc(1002, "rpc_jack_client_activate")

  1090. 	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);

  1091. 	__AfterSendRpc(1002, "rpc_jack_client_activate")

  1092. 	if (msg_result != MACH_MSG_SUCCESS) {

  1093. 		__MachMsgErrorWithoutTimeout(msg_result);

  1094. 		{ return msg_result; }

  1095. 	}

  1096. 

  1097. 

  1098. #if	defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)

  1099. 	check_result = __MIG_check__Reply__rpc_jack_client_activate_t((__Reply__rpc_jack_client_activate_t *)Out0P);

  1100. 	if (check_result != MACH_MSG_SUCCESS)

  1101. 		{ return check_result; }

  1102. #endif	/* defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined) */

  1103. 

  1104. 	*result = Out0P->result;

  1105. 

  1106. 	return KERN_SUCCESS;

  1107.     }

  1108. }

  1109. 

  1110. #if ( __MigTypeCheck || __NDR_convert__ )

  1111. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1112. #if !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)

  1113. #define __MIG_check__Reply__rpc_jack_client_deactivate_t__defined

  1114. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1115. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1116. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1117. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \

  1118. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  1119. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1120. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1121. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \

  1122. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  1123. #endif /* defined(__NDR_convert__*__defined) */

  1124. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */

  1125. 

  1126. 

  1127. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1128. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1129. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1130. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1131. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  1132. #elif	defined(__NDR_convert__int_rep__int__defined)

  1133. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1134. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1135. 	__NDR_convert__int_rep__int((int *)(a), f)

  1136. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1137. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1138. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1139. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1140. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1141. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1142. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1143. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  1144. #endif /* defined(__NDR_convert__*__defined) */

  1145. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1146. 

  1147. 

  1148. 

  1149. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1150. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1151. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1152. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1153. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  1154. #elif	defined(__NDR_convert__char_rep__int__defined)

  1155. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1156. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1157. 	__NDR_convert__char_rep__int((int *)(a), f)

  1158. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1159. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1160. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1161. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1162. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1163. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1164. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1165. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  1166. #endif /* defined(__NDR_convert__*__defined) */

  1167. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1168. 

  1169. 

  1170. 

  1171. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1172. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1173. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1174. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1175. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  1176. #elif	defined(__NDR_convert__float_rep__int__defined)

  1177. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1178. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1179. 	__NDR_convert__float_rep__int((int *)(a), f)

  1180. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1181. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1182. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1183. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1184. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1185. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1186. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

  1187. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  1188. #endif /* defined(__NDR_convert__*__defined) */

  1189. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1190. 

  1191. 

  1192. 

  1193. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_deactivate_t(__Reply__rpc_jack_client_deactivate_t *Out0P)

  1194. {

  1195. 

  1196. 	typedef __Reply__rpc_jack_client_deactivate_t __Reply;

  1197. #if	__MigTypeCheck

  1198. 	unsigned int msgh_size;

  1199. #endif	/* __MigTypeCheck */

  1200. 	if (Out0P->Head.msgh_id != 1103) {

  1201. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  1202. 		{ return MIG_SERVER_DIED; }

  1203. 	    else

  1204. 		{ return MIG_REPLY_MISMATCH; }

  1205. 	}

  1206. 

  1207. #if	__MigTypeCheck

  1208. 	msgh_size = Out0P->Head.msgh_size;

  1209. 

  1210. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  1211. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  1212. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  1213. 	      Out0P->RetCode == KERN_SUCCESS)))

  1214. 		{ return MIG_TYPE_ERROR ; }

  1215. #endif	/* __MigTypeCheck */

  1216. 

  1217. 	if (Out0P->RetCode != KERN_SUCCESS) {

  1218. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1219. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1220. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  1221. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  1222. 	}

  1223. 

  1224. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined) || \

  1225. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1226. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  1227. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined)

  1228. 		__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  1229. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */

  1230. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1231. 		__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.int_rep);

  1232. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1233. 	}

  1234. #endif	/* defined(__NDR_convert__int_rep...) */

  1235. 

  1236. #if	0 || \

  1237. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1238. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  1239. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1240. 		__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.char_rep);

  1241. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1242. 	}

  1243. #endif	/* defined(__NDR_convert__char_rep...) */

  1244. 

  1245. #if	0 || \

  1246. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1247. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  1248. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

  1249. 		__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(&Out0P->result, Out0P->NDR.float_rep);

  1250. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1251. 	}

  1252. #endif	/* defined(__NDR_convert__float_rep...) */

  1253. 

  1254. 	return MACH_MSG_SUCCESS;

  1255. }

  1256. #endif /* !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */

  1257. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  1258. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  1259. 

  1260. 

  1261. /* Routine rpc_jack_client_deactivate */

  1262. mig_external kern_return_t rpc_jack_client_deactivate

  1263. (

  1264. 	mach_port_t server_port,

  1265. 	int refnum,

  1266. 	int *result

  1267. )

  1268. {

  1269.     {

  1270. 

  1271. #ifdef  __MigPackStructs

  1272. #pragma pack(4)

  1273. #endif

  1274. 	typedef struct {

  1275. 		mach_msg_header_t Head;

  1276. 		NDR_record_t NDR;

  1277. 		int refnum;

  1278. 	} Request;

  1279. #ifdef  __MigPackStructs

  1280. #pragma pack()

  1281. #endif

  1282. 

  1283. #ifdef  __MigPackStructs

  1284. #pragma pack(4)

  1285. #endif

  1286. 	typedef struct {

  1287. 		mach_msg_header_t Head;

  1288. 		NDR_record_t NDR;

  1289. 		kern_return_t RetCode;

  1290. 		int result;

  1291. 		mach_msg_trailer_t trailer;

  1292. 	} Reply;

  1293. #ifdef  __MigPackStructs

  1294. #pragma pack()

  1295. #endif

  1296. 

  1297. #ifdef  __MigPackStructs

  1298. #pragma pack(4)

  1299. #endif

  1300. 	typedef struct {

  1301. 		mach_msg_header_t Head;

  1302. 		NDR_record_t NDR;

  1303. 		kern_return_t RetCode;

  1304. 		int result;

  1305. 	} __Reply;

  1306. #ifdef  __MigPackStructs

  1307. #pragma pack()

  1308. #endif

  1309. 	/*

  1310. 	 * typedef struct {

  1311. 	 * 	mach_msg_header_t Head;

  1312. 	 * 	NDR_record_t NDR;

  1313. 	 * 	kern_return_t RetCode;

  1314. 	 * } mig_reply_error_t;

  1315. 	 */

  1316. 

  1317. 	union {

  1318. 		Request In;

  1319. 		Reply Out;

  1320. 	} Mess;

  1321. 

  1322. 	Request *InP = &Mess.In;

  1323. 	Reply *Out0P = &Mess.Out;

  1324. 

  1325. 	mach_msg_return_t msg_result;

  1326. 

  1327. #ifdef	__MIG_check__Reply__rpc_jack_client_deactivate_t__defined

  1328. 	kern_return_t check_result;

  1329. #endif	/* __MIG_check__Reply__rpc_jack_client_deactivate_t__defined */

  1330. 

  1331. 	__DeclareSendRpc(1003, "rpc_jack_client_deactivate")

  1332. 

  1333. 	InP->NDR = NDR_record;

  1334. 

  1335. 	InP->refnum = refnum;

  1336. 

  1337. 	InP->Head.msgh_bits =

  1338. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1339. 	/* msgh_size passed as argument */

  1340. 	InP->Head.msgh_request_port = server_port;

  1341. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  1342. 	InP->Head.msgh_id = 1003;

  1343. 

  1344. 	__BeforeSendRpc(1003, "rpc_jack_client_deactivate")

  1345. 	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);

  1346. 	__AfterSendRpc(1003, "rpc_jack_client_deactivate")

  1347. 	if (msg_result != MACH_MSG_SUCCESS) {

  1348. 		__MachMsgErrorWithoutTimeout(msg_result);

  1349. 		{ return msg_result; }

  1350. 	}

  1351. 

  1352. 

  1353. #if	defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)

  1354. 	check_result = __MIG_check__Reply__rpc_jack_client_deactivate_t((__Reply__rpc_jack_client_deactivate_t *)Out0P);

  1355. 	if (check_result != MACH_MSG_SUCCESS)

  1356. 		{ return check_result; }

  1357. #endif	/* defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined) */

  1358. 

  1359. 	*result = Out0P->result;

  1360. 

  1361. 	return KERN_SUCCESS;

  1362.     }

  1363. }

  1364. 

  1365. #if ( __MigTypeCheck || __NDR_convert__ )

  1366. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1367. #if !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)

  1368. #define __MIG_check__Reply__rpc_jack_port_register_t__defined

  1369. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1370. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1371. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1372. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \

  1373. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  1374. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1375. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1376. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \

  1377. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  1378. #endif /* defined(__NDR_convert__*__defined) */

  1379. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */

  1380. 

  1381. 

  1382. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1383. #if	defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)

  1384. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1385. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1386. 	__NDR_convert__int_rep__JackRPCEngine__unsigned((unsigned *)(a), f)

  1387. #elif	defined(__NDR_convert__int_rep__unsigned__defined)

  1388. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1389. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1390. 	__NDR_convert__int_rep__unsigned((unsigned *)(a), f)

  1391. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)

  1392. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1393. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1394. 	__NDR_convert__int_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)

  1395. #elif	defined(__NDR_convert__int_rep__uint32_t__defined)

  1396. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1397. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1398. 	__NDR_convert__int_rep__uint32_t((uint32_t *)(a), f)

  1399. #endif /* defined(__NDR_convert__*__defined) */

  1400. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1401. 

  1402. 

  1403. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1404. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1405. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1406. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1407. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  1408. #elif	defined(__NDR_convert__int_rep__int__defined)

  1409. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1410. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1411. 	__NDR_convert__int_rep__int((int *)(a), f)

  1412. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1413. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1414. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1415. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1416. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1417. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1418. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1419. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  1420. #endif /* defined(__NDR_convert__*__defined) */

  1421. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */

  1422. 

  1423. 

  1424. 

  1425. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1426. #if	defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)

  1427. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1428. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1429. 	__NDR_convert__char_rep__JackRPCEngine__unsigned((unsigned *)(a), f)

  1430. #elif	defined(__NDR_convert__char_rep__unsigned__defined)

  1431. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1432. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1433. 	__NDR_convert__char_rep__unsigned((unsigned *)(a), f)

  1434. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)

  1435. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1436. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1437. 	__NDR_convert__char_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)

  1438. #elif	defined(__NDR_convert__char_rep__uint32_t__defined)

  1439. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1440. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1441. 	__NDR_convert__char_rep__uint32_t((uint32_t *)(a), f)

  1442. #endif /* defined(__NDR_convert__*__defined) */

  1443. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1444. 

  1445. 

  1446. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1447. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1448. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1449. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1450. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  1451. #elif	defined(__NDR_convert__char_rep__int__defined)

  1452. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1453. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1454. 	__NDR_convert__char_rep__int((int *)(a), f)

  1455. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1456. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1457. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1458. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1459. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1460. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1461. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1462. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  1463. #endif /* defined(__NDR_convert__*__defined) */

  1464. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */

  1465. 

  1466. 

  1467. 

  1468. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1469. #if	defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)

  1470. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1471. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1472. 	__NDR_convert__float_rep__JackRPCEngine__unsigned((unsigned *)(a), f)

  1473. #elif	defined(__NDR_convert__float_rep__unsigned__defined)

  1474. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1475. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1476. 	__NDR_convert__float_rep__unsigned((unsigned *)(a), f)

  1477. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)

  1478. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1479. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1480. 	__NDR_convert__float_rep__JackRPCEngine__uint32_t((uint32_t *)(a), f)

  1481. #elif	defined(__NDR_convert__float_rep__uint32_t__defined)

  1482. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1483. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

  1484. 	__NDR_convert__float_rep__uint32_t((uint32_t *)(a), f)

  1485. #endif /* defined(__NDR_convert__*__defined) */

  1486. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1487. 

  1488. 

  1489. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1490. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1491. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1492. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1493. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  1494. #elif	defined(__NDR_convert__float_rep__int__defined)

  1495. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1496. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1497. 	__NDR_convert__float_rep__int((int *)(a), f)

  1498. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1499. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1500. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1501. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1502. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1503. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1504. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

  1505. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  1506. #endif /* defined(__NDR_convert__*__defined) */

  1507. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */

  1508. 

  1509. 

  1510. 

  1511. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_register_t(__Reply__rpc_jack_port_register_t *Out0P)

  1512. {

  1513. 

  1514. 	typedef __Reply__rpc_jack_port_register_t __Reply;

  1515. #if	__MigTypeCheck

  1516. 	unsigned int msgh_size;

  1517. #endif	/* __MigTypeCheck */

  1518. 	if (Out0P->Head.msgh_id != 1104) {

  1519. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  1520. 		{ return MIG_SERVER_DIED; }

  1521. 	    else

  1522. 		{ return MIG_REPLY_MISMATCH; }

  1523. 	}

  1524. 

  1525. #if	__MigTypeCheck

  1526. 	msgh_size = Out0P->Head.msgh_size;

  1527. 

  1528. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  1529. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  1530. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  1531. 	      Out0P->RetCode == KERN_SUCCESS)))

  1532. 		{ return MIG_TYPE_ERROR ; }

  1533. #endif	/* __MigTypeCheck */

  1534. 

  1535. 	if (Out0P->RetCode != KERN_SUCCESS) {

  1536. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1537. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1538. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  1539. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  1540. 	}

  1541. 

  1542. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined) || \

  1543. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1544. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)

  1545. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  1546. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined)

  1547. 		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  1548. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */

  1549. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined)

  1550. 		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.int_rep);

  1551. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1552. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)

  1553. 		__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.int_rep);

  1554. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */

  1555. 	}

  1556. #endif	/* defined(__NDR_convert__int_rep...) */

  1557. 

  1558. #if	0 || \

  1559. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1560. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)

  1561. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  1562. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined)

  1563. 		__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.char_rep);

  1564. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1565. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)

  1566. 		__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.char_rep);

  1567. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */

  1568. 	}

  1569. #endif	/* defined(__NDR_convert__char_rep...) */

  1570. 

  1571. #if	0 || \

  1572. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1573. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)

  1574. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  1575. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined)

  1576. 		__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(&Out0P->port_index, Out0P->NDR.float_rep);

  1577. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1578. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)

  1579. 		__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(&Out0P->result, Out0P->NDR.float_rep);

  1580. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */

  1581. 	}

  1582. #endif	/* defined(__NDR_convert__float_rep...) */

  1583. 

  1584. 	return MACH_MSG_SUCCESS;

  1585. }

  1586. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */

  1587. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  1588. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  1589. 

  1590. 

  1591. /* Routine rpc_jack_port_register */

  1592. mig_external kern_return_t rpc_jack_port_register

  1593. (

  1594. 	mach_port_t server_port,

  1595. 	int refnum,

  1596. 	client_port_name_t name,

  1597. 	unsigned flags,

  1598. 	unsigned buffer_size,

  1599. 	unsigned *port_index,

  1600. 	int *result

  1601. )

  1602. {

  1603.     {

  1604. 

  1605. #ifdef  __MigPackStructs

  1606. #pragma pack(4)

  1607. #endif

  1608. 	typedef struct {

  1609. 		mach_msg_header_t Head;

  1610. 		NDR_record_t NDR;

  1611. 		int refnum;

  1612. 		client_port_name_t name;

  1613. 		unsigned flags;

  1614. 		unsigned buffer_size;

  1615. 	} Request;

  1616. #ifdef  __MigPackStructs

  1617. #pragma pack()

  1618. #endif

  1619. 

  1620. #ifdef  __MigPackStructs

  1621. #pragma pack(4)

  1622. #endif

  1623. 	typedef struct {

  1624. 		mach_msg_header_t Head;

  1625. 		NDR_record_t NDR;

  1626. 		kern_return_t RetCode;

  1627. 		unsigned port_index;

  1628. 		int result;

  1629. 		mach_msg_trailer_t trailer;

  1630. 	} Reply;

  1631. #ifdef  __MigPackStructs

  1632. #pragma pack()

  1633. #endif

  1634. 

  1635. #ifdef  __MigPackStructs

  1636. #pragma pack(4)

  1637. #endif

  1638. 	typedef struct {

  1639. 		mach_msg_header_t Head;

  1640. 		NDR_record_t NDR;

  1641. 		kern_return_t RetCode;

  1642. 		unsigned port_index;

  1643. 		int result;

  1644. 	} __Reply;

  1645. #ifdef  __MigPackStructs

  1646. #pragma pack()

  1647. #endif

  1648. 	/*

  1649. 	 * typedef struct {

  1650. 	 * 	mach_msg_header_t Head;

  1651. 	 * 	NDR_record_t NDR;

  1652. 	 * 	kern_return_t RetCode;

  1653. 	 * } mig_reply_error_t;

  1654. 	 */

  1655. 

  1656. 	union {

  1657. 		Request In;

  1658. 		Reply Out;

  1659. 	} Mess;

  1660. 

  1661. 	Request *InP = &Mess.In;

  1662. 	Reply *Out0P = &Mess.Out;

  1663. 

  1664. 	mach_msg_return_t msg_result;

  1665. 

  1666. #ifdef	__MIG_check__Reply__rpc_jack_port_register_t__defined

  1667. 	kern_return_t check_result;

  1668. #endif	/* __MIG_check__Reply__rpc_jack_port_register_t__defined */

  1669. 

  1670. 	__DeclareSendRpc(1004, "rpc_jack_port_register")

  1671. 

  1672. 	InP->NDR = NDR_record;

  1673. 

  1674. 	InP->refnum = refnum;

  1675. 

  1676. 	(void) mig_strncpy(InP->name, name, 128);

  1677. 

  1678. 	InP->flags = flags;

  1679. 

  1680. 	InP->buffer_size = buffer_size;

  1681. 

  1682. 	InP->Head.msgh_bits =

  1683. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1684. 	/* msgh_size passed as argument */

  1685. 	InP->Head.msgh_request_port = server_port;

  1686. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  1687. 	InP->Head.msgh_id = 1004;

  1688. 

  1689. 	__BeforeSendRpc(1004, "rpc_jack_port_register")

  1690. 	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);

  1691. 	__AfterSendRpc(1004, "rpc_jack_port_register")

  1692. 	if (msg_result != MACH_MSG_SUCCESS) {

  1693. 		__MachMsgErrorWithoutTimeout(msg_result);

  1694. 		{ return msg_result; }

  1695. 	}

  1696. 

  1697. 

  1698. #if	defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)

  1699. 	check_result = __MIG_check__Reply__rpc_jack_port_register_t((__Reply__rpc_jack_port_register_t *)Out0P);

  1700. 	if (check_result != MACH_MSG_SUCCESS)

  1701. 		{ return check_result; }

  1702. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_register_t__defined) */

  1703. 

  1704. 	*port_index = Out0P->port_index;

  1705. 

  1706. 	*result = Out0P->result;

  1707. 

  1708. 	return KERN_SUCCESS;

  1709.     }

  1710. }

  1711. 

  1712. #if ( __MigTypeCheck || __NDR_convert__ )

  1713. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1714. #if !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)

  1715. #define __MIG_check__Reply__rpc_jack_port_unregister_t__defined

  1716. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  1717. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1718. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  1719. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \

  1720. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  1721. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1722. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  1723. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \

  1724. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  1725. #endif /* defined(__NDR_convert__*__defined) */

  1726. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */

  1727. 

  1728. 

  1729. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1730. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1731. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1732. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1733. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  1734. #elif	defined(__NDR_convert__int_rep__int__defined)

  1735. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1736. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1737. 	__NDR_convert__int_rep__int((int *)(a), f)

  1738. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1739. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1740. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1741. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1742. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1743. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1744. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1745. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  1746. #endif /* defined(__NDR_convert__*__defined) */

  1747. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1748. 

  1749. 

  1750. 

  1751. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1752. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1753. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1754. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1755. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  1756. #elif	defined(__NDR_convert__char_rep__int__defined)

  1757. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1758. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1759. 	__NDR_convert__char_rep__int((int *)(a), f)

  1760. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1761. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1762. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1763. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1764. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1765. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1766. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1767. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  1768. #endif /* defined(__NDR_convert__*__defined) */

  1769. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1770. 

  1771. 

  1772. 

  1773. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1774. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1775. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1776. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1777. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  1778. #elif	defined(__NDR_convert__float_rep__int__defined)

  1779. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1780. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1781. 	__NDR_convert__float_rep__int((int *)(a), f)

  1782. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1783. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1784. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1785. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  1786. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1787. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  1788. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

  1789. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  1790. #endif /* defined(__NDR_convert__*__defined) */

  1791. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1792. 

  1793. 

  1794. 

  1795. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_unregister_t(__Reply__rpc_jack_port_unregister_t *Out0P)

  1796. {

  1797. 

  1798. 	typedef __Reply__rpc_jack_port_unregister_t __Reply;

  1799. #if	__MigTypeCheck

  1800. 	unsigned int msgh_size;

  1801. #endif	/* __MigTypeCheck */

  1802. 	if (Out0P->Head.msgh_id != 1105) {

  1803. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  1804. 		{ return MIG_SERVER_DIED; }

  1805. 	    else

  1806. 		{ return MIG_REPLY_MISMATCH; }

  1807. 	}

  1808. 

  1809. #if	__MigTypeCheck

  1810. 	msgh_size = Out0P->Head.msgh_size;

  1811. 

  1812. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  1813. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  1814. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  1815. 	      Out0P->RetCode == KERN_SUCCESS)))

  1816. 		{ return MIG_TYPE_ERROR ; }

  1817. #endif	/* __MigTypeCheck */

  1818. 

  1819. 	if (Out0P->RetCode != KERN_SUCCESS) {

  1820. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1821. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1822. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  1823. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  1824. 	}

  1825. 

  1826. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined) || \

  1827. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1828. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  1829. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined)

  1830. 		__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  1831. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */

  1832. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1833. 		__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.int_rep);

  1834. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1835. 	}

  1836. #endif	/* defined(__NDR_convert__int_rep...) */

  1837. 

  1838. #if	0 || \

  1839. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1840. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  1841. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1842. 		__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.char_rep);

  1843. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1844. 	}

  1845. #endif	/* defined(__NDR_convert__char_rep...) */

  1846. 

  1847. #if	0 || \

  1848. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1849. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  1850. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)

  1851. 		__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(&Out0P->result, Out0P->NDR.float_rep);

  1852. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  1853. 	}

  1854. #endif	/* defined(__NDR_convert__float_rep...) */

  1855. 

  1856. 	return MACH_MSG_SUCCESS;

  1857. }

  1858. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */

  1859. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  1860. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  1861. 

  1862. 

  1863. /* Routine rpc_jack_port_unregister */

  1864. mig_external kern_return_t rpc_jack_port_unregister

  1865. (

  1866. 	mach_port_t server_port,

  1867. 	int refnum,

  1868. 	int port,

  1869. 	int *result

  1870. )

  1871. {

  1872.     {

  1873. 

  1874. #ifdef  __MigPackStructs

  1875. #pragma pack(4)

  1876. #endif

  1877. 	typedef struct {

  1878. 		mach_msg_header_t Head;

  1879. 		NDR_record_t NDR;

  1880. 		int refnum;

  1881. 		int port;

  1882. 	} Request;

  1883. #ifdef  __MigPackStructs

  1884. #pragma pack()

  1885. #endif

  1886. 

  1887. #ifdef  __MigPackStructs

  1888. #pragma pack(4)

  1889. #endif

  1890. 	typedef struct {

  1891. 		mach_msg_header_t Head;

  1892. 		NDR_record_t NDR;

  1893. 		kern_return_t RetCode;

  1894. 		int result;

  1895. 		mach_msg_trailer_t trailer;

  1896. 	} Reply;

  1897. #ifdef  __MigPackStructs

  1898. #pragma pack()

  1899. #endif

  1900. 

  1901. #ifdef  __MigPackStructs

  1902. #pragma pack(4)

  1903. #endif

  1904. 	typedef struct {

  1905. 		mach_msg_header_t Head;

  1906. 		NDR_record_t NDR;

  1907. 		kern_return_t RetCode;

  1908. 		int result;

  1909. 	} __Reply;

  1910. #ifdef  __MigPackStructs

  1911. #pragma pack()

  1912. #endif

  1913. 	/*

  1914. 	 * typedef struct {

  1915. 	 * 	mach_msg_header_t Head;

  1916. 	 * 	NDR_record_t NDR;

  1917. 	 * 	kern_return_t RetCode;

  1918. 	 * } mig_reply_error_t;

  1919. 	 */

  1920. 

  1921. 	union {

  1922. 		Request In;

  1923. 		Reply Out;

  1924. 	} Mess;

  1925. 

  1926. 	Request *InP = &Mess.In;

  1927. 	Reply *Out0P = &Mess.Out;

  1928. 

  1929. 	mach_msg_return_t msg_result;

  1930. 

  1931. #ifdef	__MIG_check__Reply__rpc_jack_port_unregister_t__defined

  1932. 	kern_return_t check_result;

  1933. #endif	/* __MIG_check__Reply__rpc_jack_port_unregister_t__defined */

  1934. 

  1935. 	__DeclareSendRpc(1005, "rpc_jack_port_unregister")

  1936. 

  1937. 	InP->NDR = NDR_record;

  1938. 

  1939. 	InP->refnum = refnum;

  1940. 

  1941. 	InP->port = port;

  1942. 

  1943. 	InP->Head.msgh_bits =

  1944. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1945. 	/* msgh_size passed as argument */

  1946. 	InP->Head.msgh_request_port = server_port;

  1947. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  1948. 	InP->Head.msgh_id = 1005;

  1949. 

  1950. 	__BeforeSendRpc(1005, "rpc_jack_port_unregister")

  1951. 	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);

  1952. 	__AfterSendRpc(1005, "rpc_jack_port_unregister")

  1953. 	if (msg_result != MACH_MSG_SUCCESS) {

  1954. 		__MachMsgErrorWithoutTimeout(msg_result);

  1955. 		{ return msg_result; }

  1956. 	}

  1957. 

  1958. 

  1959. #if	defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)

  1960. 	check_result = __MIG_check__Reply__rpc_jack_port_unregister_t((__Reply__rpc_jack_port_unregister_t *)Out0P);

  1961. 	if (check_result != MACH_MSG_SUCCESS)

  1962. 		{ return check_result; }

  1963. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined) */

  1964. 

  1965. 	*result = Out0P->result;

  1966. 

  1967. 	return KERN_SUCCESS;

  1968.     }

  1969. }

  1970. 

  1971. #if ( __MigTypeCheck || __NDR_convert__ )

  1972. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1973. #if !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)

  1974. #define __MIG_check__Reply__rpc_jack_port_connect_t__defined

  1975. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  1976. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1977. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  1978. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \

  1979. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  1980. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1981. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  1982. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \

  1983. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  1984. #endif /* defined(__NDR_convert__*__defined) */

  1985. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */

  1986. 

  1987. 

  1988. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  1989. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1990. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  1991. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  1992. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  1993. #elif	defined(__NDR_convert__int_rep__int__defined)

  1994. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  1995. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  1996. 	__NDR_convert__int_rep__int((int *)(a), f)

  1997. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1998. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  1999. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2000. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2001. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2002. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2003. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2004. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  2005. #endif /* defined(__NDR_convert__*__defined) */

  2006. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2007. 

  2008. 

  2009. 

  2010. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2011. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2012. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2013. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2014. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  2015. #elif	defined(__NDR_convert__char_rep__int__defined)

  2016. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2017. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2018. 	__NDR_convert__char_rep__int((int *)(a), f)

  2019. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2020. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2021. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2022. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2023. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2024. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2025. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2026. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  2027. #endif /* defined(__NDR_convert__*__defined) */

  2028. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2029. 

  2030. 

  2031. 

  2032. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2033. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2034. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2035. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2036. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  2037. #elif	defined(__NDR_convert__float_rep__int__defined)

  2038. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2039. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2040. 	__NDR_convert__float_rep__int((int *)(a), f)

  2041. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2042. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2043. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2044. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2045. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2046. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2047. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

  2048. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  2049. #endif /* defined(__NDR_convert__*__defined) */

  2050. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2051. 

  2052. 

  2053. 

  2054. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_t(__Reply__rpc_jack_port_connect_t *Out0P)

  2055. {

  2056. 

  2057. 	typedef __Reply__rpc_jack_port_connect_t __Reply;

  2058. #if	__MigTypeCheck

  2059. 	unsigned int msgh_size;

  2060. #endif	/* __MigTypeCheck */

  2061. 	if (Out0P->Head.msgh_id != 1106) {

  2062. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  2063. 		{ return MIG_SERVER_DIED; }

  2064. 	    else

  2065. 		{ return MIG_REPLY_MISMATCH; }

  2066. 	}

  2067. 

  2068. #if	__MigTypeCheck

  2069. 	msgh_size = Out0P->Head.msgh_size;

  2070. 

  2071. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  2072. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  2073. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  2074. 	      Out0P->RetCode == KERN_SUCCESS)))

  2075. 		{ return MIG_TYPE_ERROR ; }

  2076. #endif	/* __MigTypeCheck */

  2077. 

  2078. 	if (Out0P->RetCode != KERN_SUCCESS) {

  2079. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2080. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2081. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  2082. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  2083. 	}

  2084. 

  2085. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined) || \

  2086. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2087. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  2088. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined)

  2089. 		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  2090. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */

  2091. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2092. 		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.int_rep);

  2093. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2094. 	}

  2095. #endif	/* defined(__NDR_convert__int_rep...) */

  2096. 

  2097. #if	0 || \

  2098. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2099. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  2100. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2101. 		__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.char_rep);

  2102. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2103. 	}

  2104. #endif	/* defined(__NDR_convert__char_rep...) */

  2105. 

  2106. #if	0 || \

  2107. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2108. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  2109. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)

  2110. 		__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(&Out0P->result, Out0P->NDR.float_rep);

  2111. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2112. 	}

  2113. #endif	/* defined(__NDR_convert__float_rep...) */

  2114. 

  2115. 	return MACH_MSG_SUCCESS;

  2116. }

  2117. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */

  2118. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  2119. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  2120. 

  2121. 

  2122. /* Routine rpc_jack_port_connect */

  2123. mig_external kern_return_t rpc_jack_port_connect

  2124. (

  2125. 	mach_port_t server_port,

  2126. 	int refnum,

  2127. 	int src,

  2128. 	int dst,

  2129. 	int *result

  2130. )

  2131. {

  2132.     {

  2133. 

  2134. #ifdef  __MigPackStructs

  2135. #pragma pack(4)

  2136. #endif

  2137. 	typedef struct {

  2138. 		mach_msg_header_t Head;

  2139. 		NDR_record_t NDR;

  2140. 		int refnum;

  2141. 		int src;

  2142. 		int dst;

  2143. 	} Request;

  2144. #ifdef  __MigPackStructs

  2145. #pragma pack()

  2146. #endif

  2147. 

  2148. #ifdef  __MigPackStructs

  2149. #pragma pack(4)

  2150. #endif

  2151. 	typedef struct {

  2152. 		mach_msg_header_t Head;

  2153. 		NDR_record_t NDR;

  2154. 		kern_return_t RetCode;

  2155. 		int result;

  2156. 		mach_msg_trailer_t trailer;

  2157. 	} Reply;

  2158. #ifdef  __MigPackStructs

  2159. #pragma pack()

  2160. #endif

  2161. 

  2162. #ifdef  __MigPackStructs

  2163. #pragma pack(4)

  2164. #endif

  2165. 	typedef struct {

  2166. 		mach_msg_header_t Head;

  2167. 		NDR_record_t NDR;

  2168. 		kern_return_t RetCode;

  2169. 		int result;

  2170. 	} __Reply;

  2171. #ifdef  __MigPackStructs

  2172. #pragma pack()

  2173. #endif

  2174. 	/*

  2175. 	 * typedef struct {

  2176. 	 * 	mach_msg_header_t Head;

  2177. 	 * 	NDR_record_t NDR;

  2178. 	 * 	kern_return_t RetCode;

  2179. 	 * } mig_reply_error_t;

  2180. 	 */

  2181. 

  2182. 	union {

  2183. 		Request In;

  2184. 		Reply Out;

  2185. 	} Mess;

  2186. 

  2187. 	Request *InP = &Mess.In;

  2188. 	Reply *Out0P = &Mess.Out;

  2189. 

  2190. 	mach_msg_return_t msg_result;

  2191. 

  2192. #ifdef	__MIG_check__Reply__rpc_jack_port_connect_t__defined

  2193. 	kern_return_t check_result;

  2194. #endif	/* __MIG_check__Reply__rpc_jack_port_connect_t__defined */

  2195. 

  2196. 	__DeclareSendRpc(1006, "rpc_jack_port_connect")

  2197. 

  2198. 	InP->NDR = NDR_record;

  2199. 

  2200. 	InP->refnum = refnum;

  2201. 

  2202. 	InP->src = src;

  2203. 

  2204. 	InP->dst = dst;

  2205. 

  2206. 	InP->Head.msgh_bits =

  2207. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2208. 	/* msgh_size passed as argument */

  2209. 	InP->Head.msgh_request_port = server_port;

  2210. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  2211. 	InP->Head.msgh_id = 1006;

  2212. 

  2213. 	__BeforeSendRpc(1006, "rpc_jack_port_connect")

  2214. 	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);

  2215. 	__AfterSendRpc(1006, "rpc_jack_port_connect")

  2216. 	if (msg_result != MACH_MSG_SUCCESS) {

  2217. 		__MachMsgErrorWithoutTimeout(msg_result);

  2218. 		{ return msg_result; }

  2219. 	}

  2220. 

  2221. 

  2222. #if	defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)

  2223. 	check_result = __MIG_check__Reply__rpc_jack_port_connect_t((__Reply__rpc_jack_port_connect_t *)Out0P);

  2224. 	if (check_result != MACH_MSG_SUCCESS)

  2225. 		{ return check_result; }

  2226. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined) */

  2227. 

  2228. 	*result = Out0P->result;

  2229. 

  2230. 	return KERN_SUCCESS;

  2231.     }

  2232. }

  2233. 

  2234. #if ( __MigTypeCheck || __NDR_convert__ )

  2235. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2236. #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)

  2237. #define __MIG_check__Reply__rpc_jack_port_disconnect_t__defined

  2238. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2239. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2240. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2241. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \

  2242. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  2243. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2244. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2245. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \

  2246. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  2247. #endif /* defined(__NDR_convert__*__defined) */

  2248. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */

  2249. 

  2250. 

  2251. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2252. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2253. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2254. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2255. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  2256. #elif	defined(__NDR_convert__int_rep__int__defined)

  2257. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2258. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2259. 	__NDR_convert__int_rep__int((int *)(a), f)

  2260. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2261. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2262. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2263. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2264. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2265. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2266. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2267. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  2268. #endif /* defined(__NDR_convert__*__defined) */

  2269. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2270. 

  2271. 

  2272. 

  2273. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2274. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2275. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2276. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2277. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  2278. #elif	defined(__NDR_convert__char_rep__int__defined)

  2279. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2280. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2281. 	__NDR_convert__char_rep__int((int *)(a), f)

  2282. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2283. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2284. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2285. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2286. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2287. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2288. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2289. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  2290. #endif /* defined(__NDR_convert__*__defined) */

  2291. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2292. 

  2293. 

  2294. 

  2295. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2296. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2297. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2298. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2299. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  2300. #elif	defined(__NDR_convert__float_rep__int__defined)

  2301. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2302. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2303. 	__NDR_convert__float_rep__int((int *)(a), f)

  2304. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2305. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2306. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2307. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2308. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2309. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2310. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

  2311. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  2312. #endif /* defined(__NDR_convert__*__defined) */

  2313. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2314. 

  2315. 

  2316. 

  2317. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_t(__Reply__rpc_jack_port_disconnect_t *Out0P)

  2318. {

  2319. 

  2320. 	typedef __Reply__rpc_jack_port_disconnect_t __Reply;

  2321. #if	__MigTypeCheck

  2322. 	unsigned int msgh_size;

  2323. #endif	/* __MigTypeCheck */

  2324. 	if (Out0P->Head.msgh_id != 1107) {

  2325. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  2326. 		{ return MIG_SERVER_DIED; }

  2327. 	    else

  2328. 		{ return MIG_REPLY_MISMATCH; }

  2329. 	}

  2330. 

  2331. #if	__MigTypeCheck

  2332. 	msgh_size = Out0P->Head.msgh_size;

  2333. 

  2334. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  2335. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  2336. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  2337. 	      Out0P->RetCode == KERN_SUCCESS)))

  2338. 		{ return MIG_TYPE_ERROR ; }

  2339. #endif	/* __MigTypeCheck */

  2340. 

  2341. 	if (Out0P->RetCode != KERN_SUCCESS) {

  2342. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2343. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2344. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  2345. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  2346. 	}

  2347. 

  2348. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined) || \

  2349. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2350. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  2351. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined)

  2352. 		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  2353. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */

  2354. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2355. 		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.int_rep);

  2356. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2357. 	}

  2358. #endif	/* defined(__NDR_convert__int_rep...) */

  2359. 

  2360. #if	0 || \

  2361. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2362. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  2363. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2364. 		__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.char_rep);

  2365. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2366. 	}

  2367. #endif	/* defined(__NDR_convert__char_rep...) */

  2368. 

  2369. #if	0 || \

  2370. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2371. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  2372. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

  2373. 		__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(&Out0P->result, Out0P->NDR.float_rep);

  2374. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2375. 	}

  2376. #endif	/* defined(__NDR_convert__float_rep...) */

  2377. 

  2378. 	return MACH_MSG_SUCCESS;

  2379. }

  2380. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */

  2381. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  2382. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  2383. 

  2384. 

  2385. /* Routine rpc_jack_port_disconnect */

  2386. mig_external kern_return_t rpc_jack_port_disconnect

  2387. (

  2388. 	mach_port_t server_port,

  2389. 	int refnum,

  2390. 	int src,

  2391. 	int dst,

  2392. 	int *result

  2393. )

  2394. {

  2395.     {

  2396. 

  2397. #ifdef  __MigPackStructs

  2398. #pragma pack(4)

  2399. #endif

  2400. 	typedef struct {

  2401. 		mach_msg_header_t Head;

  2402. 		NDR_record_t NDR;

  2403. 		int refnum;

  2404. 		int src;

  2405. 		int dst;

  2406. 	} Request;

  2407. #ifdef  __MigPackStructs

  2408. #pragma pack()

  2409. #endif

  2410. 

  2411. #ifdef  __MigPackStructs

  2412. #pragma pack(4)

  2413. #endif

  2414. 	typedef struct {

  2415. 		mach_msg_header_t Head;

  2416. 		NDR_record_t NDR;

  2417. 		kern_return_t RetCode;

  2418. 		int result;

  2419. 		mach_msg_trailer_t trailer;

  2420. 	} Reply;

  2421. #ifdef  __MigPackStructs

  2422. #pragma pack()

  2423. #endif

  2424. 

  2425. #ifdef  __MigPackStructs

  2426. #pragma pack(4)

  2427. #endif

  2428. 	typedef struct {

  2429. 		mach_msg_header_t Head;

  2430. 		NDR_record_t NDR;

  2431. 		kern_return_t RetCode;

  2432. 		int result;

  2433. 	} __Reply;

  2434. #ifdef  __MigPackStructs

  2435. #pragma pack()

  2436. #endif

  2437. 	/*

  2438. 	 * typedef struct {

  2439. 	 * 	mach_msg_header_t Head;

  2440. 	 * 	NDR_record_t NDR;

  2441. 	 * 	kern_return_t RetCode;

  2442. 	 * } mig_reply_error_t;

  2443. 	 */

  2444. 

  2445. 	union {

  2446. 		Request In;

  2447. 		Reply Out;

  2448. 	} Mess;

  2449. 

  2450. 	Request *InP = &Mess.In;

  2451. 	Reply *Out0P = &Mess.Out;

  2452. 

  2453. 	mach_msg_return_t msg_result;

  2454. 

  2455. #ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_t__defined

  2456. 	kern_return_t check_result;

  2457. #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_t__defined */

  2458. 

  2459. 	__DeclareSendRpc(1007, "rpc_jack_port_disconnect")

  2460. 

  2461. 	InP->NDR = NDR_record;

  2462. 

  2463. 	InP->refnum = refnum;

  2464. 

  2465. 	InP->src = src;

  2466. 

  2467. 	InP->dst = dst;

  2468. 

  2469. 	InP->Head.msgh_bits =

  2470. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2471. 	/* msgh_size passed as argument */

  2472. 	InP->Head.msgh_request_port = server_port;

  2473. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  2474. 	InP->Head.msgh_id = 1007;

  2475. 

  2476. 	__BeforeSendRpc(1007, "rpc_jack_port_disconnect")

  2477. 	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);

  2478. 	__AfterSendRpc(1007, "rpc_jack_port_disconnect")

  2479. 	if (msg_result != MACH_MSG_SUCCESS) {

  2480. 		__MachMsgErrorWithoutTimeout(msg_result);

  2481. 		{ return msg_result; }

  2482. 	}

  2483. 

  2484. 

  2485. #if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)

  2486. 	check_result = __MIG_check__Reply__rpc_jack_port_disconnect_t((__Reply__rpc_jack_port_disconnect_t *)Out0P);

  2487. 	if (check_result != MACH_MSG_SUCCESS)

  2488. 		{ return check_result; }

  2489. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined) */

  2490. 

  2491. 	*result = Out0P->result;

  2492. 

  2493. 	return KERN_SUCCESS;

  2494.     }

  2495. }

  2496. 

  2497. #if ( __MigTypeCheck || __NDR_convert__ )

  2498. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2499. #if !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)

  2500. #define __MIG_check__Reply__rpc_jack_port_connect_name_t__defined

  2501. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2502. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2503. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2504. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \

  2505. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  2506. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2507. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2508. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \

  2509. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  2510. #endif /* defined(__NDR_convert__*__defined) */

  2511. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */

  2512. 

  2513. 

  2514. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2515. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2516. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2517. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2518. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  2519. #elif	defined(__NDR_convert__int_rep__int__defined)

  2520. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2521. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2522. 	__NDR_convert__int_rep__int((int *)(a), f)

  2523. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2524. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2525. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2526. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2527. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2528. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2529. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2530. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  2531. #endif /* defined(__NDR_convert__*__defined) */

  2532. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2533. 

  2534. 

  2535. 

  2536. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2537. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2538. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2539. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2540. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  2541. #elif	defined(__NDR_convert__char_rep__int__defined)

  2542. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2543. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2544. 	__NDR_convert__char_rep__int((int *)(a), f)

  2545. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2546. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2547. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2548. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2549. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2550. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2551. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2552. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  2553. #endif /* defined(__NDR_convert__*__defined) */

  2554. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2555. 

  2556. 

  2557. 

  2558. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2559. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2560. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2561. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2562. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  2563. #elif	defined(__NDR_convert__float_rep__int__defined)

  2564. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2565. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2566. 	__NDR_convert__float_rep__int((int *)(a), f)

  2567. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2568. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2569. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2570. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2571. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2572. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2573. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

  2574. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  2575. #endif /* defined(__NDR_convert__*__defined) */

  2576. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2577. 

  2578. 

  2579. 

  2580. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_name_t(__Reply__rpc_jack_port_connect_name_t *Out0P)

  2581. {

  2582. 

  2583. 	typedef __Reply__rpc_jack_port_connect_name_t __Reply;

  2584. #if	__MigTypeCheck

  2585. 	unsigned int msgh_size;

  2586. #endif	/* __MigTypeCheck */

  2587. 	if (Out0P->Head.msgh_id != 1108) {

  2588. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  2589. 		{ return MIG_SERVER_DIED; }

  2590. 	    else

  2591. 		{ return MIG_REPLY_MISMATCH; }

  2592. 	}

  2593. 

  2594. #if	__MigTypeCheck

  2595. 	msgh_size = Out0P->Head.msgh_size;

  2596. 

  2597. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  2598. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  2599. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  2600. 	      Out0P->RetCode == KERN_SUCCESS)))

  2601. 		{ return MIG_TYPE_ERROR ; }

  2602. #endif	/* __MigTypeCheck */

  2603. 

  2604. 	if (Out0P->RetCode != KERN_SUCCESS) {

  2605. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2606. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2607. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  2608. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  2609. 	}

  2610. 

  2611. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined) || \

  2612. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2613. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  2614. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined)

  2615. 		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  2616. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */

  2617. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2618. 		__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);

  2619. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2620. 	}

  2621. #endif	/* defined(__NDR_convert__int_rep...) */

  2622. 

  2623. #if	0 || \

  2624. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2625. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  2626. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2627. 		__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);

  2628. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2629. 	}

  2630. #endif	/* defined(__NDR_convert__char_rep...) */

  2631. 

  2632. #if	0 || \

  2633. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2634. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  2635. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

  2636. 		__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);

  2637. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2638. 	}

  2639. #endif	/* defined(__NDR_convert__float_rep...) */

  2640. 

  2641. 	return MACH_MSG_SUCCESS;

  2642. }

  2643. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */

  2644. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  2645. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  2646. 

  2647. 

  2648. /* Routine rpc_jack_port_connect_name */

  2649. mig_external kern_return_t rpc_jack_port_connect_name

  2650. (

  2651. 	mach_port_t server_port,

  2652. 	int refnum,

  2653. 	client_port_name_t src,

  2654. 	client_port_name_t dst,

  2655. 	int *result

  2656. )

  2657. {

  2658.     {

  2659. 

  2660. #ifdef  __MigPackStructs

  2661. #pragma pack(4)

  2662. #endif

  2663. 	typedef struct {

  2664. 		mach_msg_header_t Head;

  2665. 		NDR_record_t NDR;

  2666. 		int refnum;

  2667. 		client_port_name_t src;

  2668. 		client_port_name_t dst;

  2669. 	} Request;

  2670. #ifdef  __MigPackStructs

  2671. #pragma pack()

  2672. #endif

  2673. 

  2674. #ifdef  __MigPackStructs

  2675. #pragma pack(4)

  2676. #endif

  2677. 	typedef struct {

  2678. 		mach_msg_header_t Head;

  2679. 		NDR_record_t NDR;

  2680. 		kern_return_t RetCode;

  2681. 		int result;

  2682. 		mach_msg_trailer_t trailer;

  2683. 	} Reply;

  2684. #ifdef  __MigPackStructs

  2685. #pragma pack()

  2686. #endif

  2687. 

  2688. #ifdef  __MigPackStructs

  2689. #pragma pack(4)

  2690. #endif

  2691. 	typedef struct {

  2692. 		mach_msg_header_t Head;

  2693. 		NDR_record_t NDR;

  2694. 		kern_return_t RetCode;

  2695. 		int result;

  2696. 	} __Reply;

  2697. #ifdef  __MigPackStructs

  2698. #pragma pack()

  2699. #endif

  2700. 	/*

  2701. 	 * typedef struct {

  2702. 	 * 	mach_msg_header_t Head;

  2703. 	 * 	NDR_record_t NDR;

  2704. 	 * 	kern_return_t RetCode;

  2705. 	 * } mig_reply_error_t;

  2706. 	 */

  2707. 

  2708. 	union {

  2709. 		Request In;

  2710. 		Reply Out;

  2711. 	} Mess;

  2712. 

  2713. 	Request *InP = &Mess.In;

  2714. 	Reply *Out0P = &Mess.Out;

  2715. 

  2716. 	mach_msg_return_t msg_result;

  2717. 

  2718. #ifdef	__MIG_check__Reply__rpc_jack_port_connect_name_t__defined

  2719. 	kern_return_t check_result;

  2720. #endif	/* __MIG_check__Reply__rpc_jack_port_connect_name_t__defined */

  2721. 

  2722. 	__DeclareSendRpc(1008, "rpc_jack_port_connect_name")

  2723. 

  2724. 	InP->NDR = NDR_record;

  2725. 

  2726. 	InP->refnum = refnum;

  2727. 

  2728. 	(void) mig_strncpy(InP->src, src, 128);

  2729. 

  2730. 	(void) mig_strncpy(InP->dst, dst, 128);

  2731. 

  2732. 	InP->Head.msgh_bits =

  2733. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2734. 	/* msgh_size passed as argument */

  2735. 	InP->Head.msgh_request_port = server_port;

  2736. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  2737. 	InP->Head.msgh_id = 1008;

  2738. 

  2739. 	__BeforeSendRpc(1008, "rpc_jack_port_connect_name")

  2740. 	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);

  2741. 	__AfterSendRpc(1008, "rpc_jack_port_connect_name")

  2742. 	if (msg_result != MACH_MSG_SUCCESS) {

  2743. 		__MachMsgErrorWithoutTimeout(msg_result);

  2744. 		{ return msg_result; }

  2745. 	}

  2746. 

  2747. 

  2748. #if	defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)

  2749. 	check_result = __MIG_check__Reply__rpc_jack_port_connect_name_t((__Reply__rpc_jack_port_connect_name_t *)Out0P);

  2750. 	if (check_result != MACH_MSG_SUCCESS)

  2751. 		{ return check_result; }

  2752. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined) */

  2753. 

  2754. 	*result = Out0P->result;

  2755. 

  2756. 	return KERN_SUCCESS;

  2757.     }

  2758. }

  2759. 

  2760. #if ( __MigTypeCheck || __NDR_convert__ )

  2761. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2762. #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)

  2763. #define __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined

  2764. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  2765. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2766. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  2767. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \

  2768. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  2769. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2770. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  2771. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \

  2772. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  2773. #endif /* defined(__NDR_convert__*__defined) */

  2774. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */

  2775. 

  2776. 

  2777. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2778. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2779. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2780. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2781. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  2782. #elif	defined(__NDR_convert__int_rep__int__defined)

  2783. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2784. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2785. 	__NDR_convert__int_rep__int((int *)(a), f)

  2786. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2787. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2788. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2789. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2790. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2791. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2792. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2793. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  2794. #endif /* defined(__NDR_convert__*__defined) */

  2795. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2796. 

  2797. 

  2798. 

  2799. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2800. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2801. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2802. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2803. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  2804. #elif	defined(__NDR_convert__char_rep__int__defined)

  2805. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2806. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2807. 	__NDR_convert__char_rep__int((int *)(a), f)

  2808. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2809. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2810. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2811. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2812. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2813. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2814. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2815. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  2816. #endif /* defined(__NDR_convert__*__defined) */

  2817. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2818. 

  2819. 

  2820. 

  2821. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2822. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2823. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2824. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2825. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  2826. #elif	defined(__NDR_convert__float_rep__int__defined)

  2827. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2828. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2829. 	__NDR_convert__float_rep__int((int *)(a), f)

  2830. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2831. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2832. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2833. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  2834. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2835. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  2836. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

  2837. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  2838. #endif /* defined(__NDR_convert__*__defined) */

  2839. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2840. 

  2841. 

  2842. 

  2843. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_name_t(__Reply__rpc_jack_port_disconnect_name_t *Out0P)

  2844. {

  2845. 

  2846. 	typedef __Reply__rpc_jack_port_disconnect_name_t __Reply;

  2847. #if	__MigTypeCheck

  2848. 	unsigned int msgh_size;

  2849. #endif	/* __MigTypeCheck */

  2850. 	if (Out0P->Head.msgh_id != 1109) {

  2851. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  2852. 		{ return MIG_SERVER_DIED; }

  2853. 	    else

  2854. 		{ return MIG_REPLY_MISMATCH; }

  2855. 	}

  2856. 

  2857. #if	__MigTypeCheck

  2858. 	msgh_size = Out0P->Head.msgh_size;

  2859. 

  2860. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  2861. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  2862. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  2863. 	      Out0P->RetCode == KERN_SUCCESS)))

  2864. 		{ return MIG_TYPE_ERROR ; }

  2865. #endif	/* __MigTypeCheck */

  2866. 

  2867. 	if (Out0P->RetCode != KERN_SUCCESS) {

  2868. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2869. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2870. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  2871. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  2872. 	}

  2873. 

  2874. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined) || \

  2875. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2876. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  2877. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined)

  2878. 		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  2879. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */

  2880. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2881. 		__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.int_rep);

  2882. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2883. 	}

  2884. #endif	/* defined(__NDR_convert__int_rep...) */

  2885. 

  2886. #if	0 || \

  2887. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2888. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  2889. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2890. 		__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.char_rep);

  2891. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2892. 	}

  2893. #endif	/* defined(__NDR_convert__char_rep...) */

  2894. 

  2895. #if	0 || \

  2896. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2897. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  2898. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

  2899. 		__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(&Out0P->result, Out0P->NDR.float_rep);

  2900. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  2901. 	}

  2902. #endif	/* defined(__NDR_convert__float_rep...) */

  2903. 

  2904. 	return MACH_MSG_SUCCESS;

  2905. }

  2906. #endif /* !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */

  2907. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  2908. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  2909. 

  2910. 

  2911. /* Routine rpc_jack_port_disconnect_name */

  2912. mig_external kern_return_t rpc_jack_port_disconnect_name

  2913. (

  2914. 	mach_port_t server_port,

  2915. 	int refnum,

  2916. 	client_port_name_t src,

  2917. 	client_port_name_t dst,

  2918. 	int *result

  2919. )

  2920. {

  2921.     {

  2922. 

  2923. #ifdef  __MigPackStructs

  2924. #pragma pack(4)

  2925. #endif

  2926. 	typedef struct {

  2927. 		mach_msg_header_t Head;

  2928. 		NDR_record_t NDR;

  2929. 		int refnum;

  2930. 		client_port_name_t src;

  2931. 		client_port_name_t dst;

  2932. 	} Request;

  2933. #ifdef  __MigPackStructs

  2934. #pragma pack()

  2935. #endif

  2936. 

  2937. #ifdef  __MigPackStructs

  2938. #pragma pack(4)

  2939. #endif

  2940. 	typedef struct {

  2941. 		mach_msg_header_t Head;

  2942. 		NDR_record_t NDR;

  2943. 		kern_return_t RetCode;

  2944. 		int result;

  2945. 		mach_msg_trailer_t trailer;

  2946. 	} Reply;

  2947. #ifdef  __MigPackStructs

  2948. #pragma pack()

  2949. #endif

  2950. 

  2951. #ifdef  __MigPackStructs

  2952. #pragma pack(4)

  2953. #endif

  2954. 	typedef struct {

  2955. 		mach_msg_header_t Head;

  2956. 		NDR_record_t NDR;

  2957. 		kern_return_t RetCode;

  2958. 		int result;

  2959. 	} __Reply;

  2960. #ifdef  __MigPackStructs

  2961. #pragma pack()

  2962. #endif

  2963. 	/*

  2964. 	 * typedef struct {

  2965. 	 * 	mach_msg_header_t Head;

  2966. 	 * 	NDR_record_t NDR;

  2967. 	 * 	kern_return_t RetCode;

  2968. 	 * } mig_reply_error_t;

  2969. 	 */

  2970. 

  2971. 	union {

  2972. 		Request In;

  2973. 		Reply Out;

  2974. 	} Mess;

  2975. 

  2976. 	Request *InP = &Mess.In;

  2977. 	Reply *Out0P = &Mess.Out;

  2978. 

  2979. 	mach_msg_return_t msg_result;

  2980. 

  2981. #ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined

  2982. 	kern_return_t check_result;

  2983. #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined */

  2984. 

  2985. 	__DeclareSendRpc(1009, "rpc_jack_port_disconnect_name")

  2986. 

  2987. 	InP->NDR = NDR_record;

  2988. 

  2989. 	InP->refnum = refnum;

  2990. 

  2991. 	(void) mig_strncpy(InP->src, src, 128);

  2992. 

  2993. 	(void) mig_strncpy(InP->dst, dst, 128);

  2994. 

  2995. 	InP->Head.msgh_bits =

  2996. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2997. 	/* msgh_size passed as argument */

  2998. 	InP->Head.msgh_request_port = server_port;

  2999. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  3000. 	InP->Head.msgh_id = 1009;

  3001. 

  3002. 	__BeforeSendRpc(1009, "rpc_jack_port_disconnect_name")

  3003. 	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);

  3004. 	__AfterSendRpc(1009, "rpc_jack_port_disconnect_name")

  3005. 	if (msg_result != MACH_MSG_SUCCESS) {

  3006. 		__MachMsgErrorWithoutTimeout(msg_result);

  3007. 		{ return msg_result; }

  3008. 	}

  3009. 

  3010. 

  3011. #if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)

  3012. 	check_result = __MIG_check__Reply__rpc_jack_port_disconnect_name_t((__Reply__rpc_jack_port_disconnect_name_t *)Out0P);

  3013. 	if (check_result != MACH_MSG_SUCCESS)

  3014. 		{ return check_result; }

  3015. #endif	/* defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined) */

  3016. 

  3017. 	*result = Out0P->result;

  3018. 

  3019. 	return KERN_SUCCESS;

  3020.     }

  3021. }

  3022. 

  3023. #if ( __MigTypeCheck || __NDR_convert__ )

  3024. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3025. #if !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)

  3026. #define __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined

  3027. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3028. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3029. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3030. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \

  3031. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  3032. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3033. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3034. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \

  3035. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  3036. #endif /* defined(__NDR_convert__*__defined) */

  3037. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */

  3038. 

  3039. 

  3040. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3041. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3042. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3043. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3044. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  3045. #elif	defined(__NDR_convert__int_rep__int__defined)

  3046. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3047. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3048. 	__NDR_convert__int_rep__int((int *)(a), f)

  3049. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3050. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3051. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3052. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3053. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3054. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3055. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3056. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  3057. #endif /* defined(__NDR_convert__*__defined) */

  3058. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3059. 

  3060. 

  3061. 

  3062. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3063. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3064. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3065. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3066. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  3067. #elif	defined(__NDR_convert__char_rep__int__defined)

  3068. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3069. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3070. 	__NDR_convert__char_rep__int((int *)(a), f)

  3071. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3072. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3073. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3074. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3075. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3076. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3077. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3078. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  3079. #endif /* defined(__NDR_convert__*__defined) */

  3080. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3081. 

  3082. 

  3083. 

  3084. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3085. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3086. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3087. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3088. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  3089. #elif	defined(__NDR_convert__float_rep__int__defined)

  3090. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3091. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3092. 	__NDR_convert__float_rep__int((int *)(a), f)

  3093. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3094. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3095. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3096. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3097. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3098. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3099. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

  3100. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  3101. #endif /* defined(__NDR_convert__*__defined) */

  3102. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3103. 

  3104. 

  3105. 

  3106. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Reply__rpc_jack_set_buffer_size_t *Out0P)

  3107. {

  3108. 

  3109. 	typedef __Reply__rpc_jack_set_buffer_size_t __Reply;

  3110. #if	__MigTypeCheck

  3111. 	unsigned int msgh_size;

  3112. #endif	/* __MigTypeCheck */

  3113. 	if (Out0P->Head.msgh_id != 1110) {

  3114. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  3115. 		{ return MIG_SERVER_DIED; }

  3116. 	    else

  3117. 		{ return MIG_REPLY_MISMATCH; }

  3118. 	}

  3119. 

  3120. #if	__MigTypeCheck

  3121. 	msgh_size = Out0P->Head.msgh_size;

  3122. 

  3123. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  3124. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  3125. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  3126. 	      Out0P->RetCode == KERN_SUCCESS)))

  3127. 		{ return MIG_TYPE_ERROR ; }

  3128. #endif	/* __MigTypeCheck */

  3129. 

  3130. 	if (Out0P->RetCode != KERN_SUCCESS) {

  3131. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3132. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3133. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  3134. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  3135. 	}

  3136. 

  3137. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined) || \

  3138. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3139. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  3140. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined)

  3141. 		__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  3142. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */

  3143. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3144. 		__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.int_rep);

  3145. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3146. 	}

  3147. #endif	/* defined(__NDR_convert__int_rep...) */

  3148. 

  3149. #if	0 || \

  3150. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3151. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  3152. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3153. 		__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.char_rep);

  3154. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3155. 	}

  3156. #endif	/* defined(__NDR_convert__char_rep...) */

  3157. 

  3158. #if	0 || \

  3159. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3160. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  3161. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

  3162. 		__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(&Out0P->result, Out0P->NDR.float_rep);

  3163. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3164. 	}

  3165. #endif	/* defined(__NDR_convert__float_rep...) */

  3166. 

  3167. 	return MACH_MSG_SUCCESS;

  3168. }

  3169. #endif /* !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */

  3170. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  3171. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  3172. 

  3173. 

  3174. /* Routine rpc_jack_set_buffer_size */

  3175. mig_external kern_return_t rpc_jack_set_buffer_size

  3176. (

  3177. 	mach_port_t server_port,

  3178. 	int buffer_size,

  3179. 	int *result

  3180. )

  3181. {

  3182.     {

  3183. 

  3184. #ifdef  __MigPackStructs

  3185. #pragma pack(4)

  3186. #endif

  3187. 	typedef struct {

  3188. 		mach_msg_header_t Head;

  3189. 		NDR_record_t NDR;

  3190. 		int buffer_size;

  3191. 	} Request;

  3192. #ifdef  __MigPackStructs

  3193. #pragma pack()

  3194. #endif

  3195. 

  3196. #ifdef  __MigPackStructs

  3197. #pragma pack(4)

  3198. #endif

  3199. 	typedef struct {

  3200. 		mach_msg_header_t Head;

  3201. 		NDR_record_t NDR;

  3202. 		kern_return_t RetCode;

  3203. 		int result;

  3204. 		mach_msg_trailer_t trailer;

  3205. 	} Reply;

  3206. #ifdef  __MigPackStructs

  3207. #pragma pack()

  3208. #endif

  3209. 

  3210. #ifdef  __MigPackStructs

  3211. #pragma pack(4)

  3212. #endif

  3213. 	typedef struct {

  3214. 		mach_msg_header_t Head;

  3215. 		NDR_record_t NDR;

  3216. 		kern_return_t RetCode;

  3217. 		int result;

  3218. 	} __Reply;

  3219. #ifdef  __MigPackStructs

  3220. #pragma pack()

  3221. #endif

  3222. 	/*

  3223. 	 * typedef struct {

  3224. 	 * 	mach_msg_header_t Head;

  3225. 	 * 	NDR_record_t NDR;

  3226. 	 * 	kern_return_t RetCode;

  3227. 	 * } mig_reply_error_t;

  3228. 	 */

  3229. 

  3230. 	union {

  3231. 		Request In;

  3232. 		Reply Out;

  3233. 	} Mess;

  3234. 

  3235. 	Request *InP = &Mess.In;

  3236. 	Reply *Out0P = &Mess.Out;

  3237. 

  3238. 	mach_msg_return_t msg_result;

  3239. 

  3240. #ifdef	__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined

  3241. 	kern_return_t check_result;

  3242. #endif	/* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */

  3243. 

  3244. 	__DeclareSendRpc(1010, "rpc_jack_set_buffer_size")

  3245. 

  3246. 	InP->NDR = NDR_record;

  3247. 

  3248. 	InP->buffer_size = buffer_size;

  3249. 

  3250. 	InP->Head.msgh_bits =

  3251. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3252. 	/* msgh_size passed as argument */

  3253. 	InP->Head.msgh_request_port = server_port;

  3254. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  3255. 	InP->Head.msgh_id = 1010;

  3256. 

  3257. 	__BeforeSendRpc(1010, "rpc_jack_set_buffer_size")

  3258. 	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);

  3259. 	__AfterSendRpc(1010, "rpc_jack_set_buffer_size")

  3260. 	if (msg_result != MACH_MSG_SUCCESS) {

  3261. 		__MachMsgErrorWithoutTimeout(msg_result);

  3262. 		{ return msg_result; }

  3263. 	}

  3264. 

  3265. 

  3266. #if	defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)

  3267. 	check_result = __MIG_check__Reply__rpc_jack_set_buffer_size_t((__Reply__rpc_jack_set_buffer_size_t *)Out0P);

  3268. 	if (check_result != MACH_MSG_SUCCESS)

  3269. 		{ return check_result; }

  3270. #endif	/* defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined) */

  3271. 

  3272. 	*result = Out0P->result;

  3273. 

  3274. 	return KERN_SUCCESS;

  3275.     }

  3276. }

  3277. 

  3278. #if ( __MigTypeCheck || __NDR_convert__ )

  3279. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3280. #if !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)

  3281. #define __MIG_check__Reply__rpc_jack_set_freewheel_t__defined

  3282. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3283. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3284. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3285. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \

  3286. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  3287. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3288. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3289. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \

  3290. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  3291. #endif /* defined(__NDR_convert__*__defined) */

  3292. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */

  3293. 

  3294. 

  3295. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3296. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3297. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3298. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3299. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  3300. #elif	defined(__NDR_convert__int_rep__int__defined)

  3301. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3302. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3303. 	__NDR_convert__int_rep__int((int *)(a), f)

  3304. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3305. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3306. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3307. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3308. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3309. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3310. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3311. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  3312. #endif /* defined(__NDR_convert__*__defined) */

  3313. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3314. 

  3315. 

  3316. 

  3317. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3318. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3319. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3320. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3321. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  3322. #elif	defined(__NDR_convert__char_rep__int__defined)

  3323. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3324. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3325. 	__NDR_convert__char_rep__int((int *)(a), f)

  3326. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3327. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3328. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3329. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3330. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3331. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3332. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3333. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  3334. #endif /* defined(__NDR_convert__*__defined) */

  3335. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3336. 

  3337. 

  3338. 

  3339. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3340. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3341. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3342. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3343. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  3344. #elif	defined(__NDR_convert__float_rep__int__defined)

  3345. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3346. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3347. 	__NDR_convert__float_rep__int((int *)(a), f)

  3348. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3349. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3350. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3351. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3352. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3353. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3354. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

  3355. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  3356. #endif /* defined(__NDR_convert__*__defined) */

  3357. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3358. 

  3359. 

  3360. 

  3361. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply__rpc_jack_set_freewheel_t *Out0P)

  3362. {

  3363. 

  3364. 	typedef __Reply__rpc_jack_set_freewheel_t __Reply;

  3365. #if	__MigTypeCheck

  3366. 	unsigned int msgh_size;

  3367. #endif	/* __MigTypeCheck */

  3368. 	if (Out0P->Head.msgh_id != 1111) {

  3369. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  3370. 		{ return MIG_SERVER_DIED; }

  3371. 	    else

  3372. 		{ return MIG_REPLY_MISMATCH; }

  3373. 	}

  3374. 

  3375. #if	__MigTypeCheck

  3376. 	msgh_size = Out0P->Head.msgh_size;

  3377. 

  3378. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  3379. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  3380. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  3381. 	      Out0P->RetCode == KERN_SUCCESS)))

  3382. 		{ return MIG_TYPE_ERROR ; }

  3383. #endif	/* __MigTypeCheck */

  3384. 

  3385. 	if (Out0P->RetCode != KERN_SUCCESS) {

  3386. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3387. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3388. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  3389. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  3390. 	}

  3391. 

  3392. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined) || \

  3393. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3394. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  3395. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined)

  3396. 		__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  3397. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */

  3398. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3399. 		__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.int_rep);

  3400. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3401. 	}

  3402. #endif	/* defined(__NDR_convert__int_rep...) */

  3403. 

  3404. #if	0 || \

  3405. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3406. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  3407. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3408. 		__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.char_rep);

  3409. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3410. 	}

  3411. #endif	/* defined(__NDR_convert__char_rep...) */

  3412. 

  3413. #if	0 || \

  3414. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3415. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  3416. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

  3417. 		__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(&Out0P->result, Out0P->NDR.float_rep);

  3418. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3419. 	}

  3420. #endif	/* defined(__NDR_convert__float_rep...) */

  3421. 

  3422. 	return MACH_MSG_SUCCESS;

  3423. }

  3424. #endif /* !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */

  3425. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  3426. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  3427. 

  3428. 

  3429. /* Routine rpc_jack_set_freewheel */

  3430. mig_external kern_return_t rpc_jack_set_freewheel

  3431. (

  3432. 	mach_port_t server_port,

  3433. 	int onoff,

  3434. 	int *result

  3435. )

  3436. {

  3437.     {

  3438. 

  3439. #ifdef  __MigPackStructs

  3440. #pragma pack(4)

  3441. #endif

  3442. 	typedef struct {

  3443. 		mach_msg_header_t Head;

  3444. 		NDR_record_t NDR;

  3445. 		int onoff;

  3446. 	} Request;

  3447. #ifdef  __MigPackStructs

  3448. #pragma pack()

  3449. #endif

  3450. 

  3451. #ifdef  __MigPackStructs

  3452. #pragma pack(4)

  3453. #endif

  3454. 	typedef struct {

  3455. 		mach_msg_header_t Head;

  3456. 		NDR_record_t NDR;

  3457. 		kern_return_t RetCode;

  3458. 		int result;

  3459. 		mach_msg_trailer_t trailer;

  3460. 	} Reply;

  3461. #ifdef  __MigPackStructs

  3462. #pragma pack()

  3463. #endif

  3464. 

  3465. #ifdef  __MigPackStructs

  3466. #pragma pack(4)

  3467. #endif

  3468. 	typedef struct {

  3469. 		mach_msg_header_t Head;

  3470. 		NDR_record_t NDR;

  3471. 		kern_return_t RetCode;

  3472. 		int result;

  3473. 	} __Reply;

  3474. #ifdef  __MigPackStructs

  3475. #pragma pack()

  3476. #endif

  3477. 	/*

  3478. 	 * typedef struct {

  3479. 	 * 	mach_msg_header_t Head;

  3480. 	 * 	NDR_record_t NDR;

  3481. 	 * 	kern_return_t RetCode;

  3482. 	 * } mig_reply_error_t;

  3483. 	 */

  3484. 

  3485. 	union {

  3486. 		Request In;

  3487. 		Reply Out;

  3488. 	} Mess;

  3489. 

  3490. 	Request *InP = &Mess.In;

  3491. 	Reply *Out0P = &Mess.Out;

  3492. 

  3493. 	mach_msg_return_t msg_result;

  3494. 

  3495. #ifdef	__MIG_check__Reply__rpc_jack_set_freewheel_t__defined

  3496. 	kern_return_t check_result;

  3497. #endif	/* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */

  3498. 

  3499. 	__DeclareSendRpc(1011, "rpc_jack_set_freewheel")

  3500. 

  3501. 	InP->NDR = NDR_record;

  3502. 

  3503. 	InP->onoff = onoff;

  3504. 

  3505. 	InP->Head.msgh_bits =

  3506. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3507. 	/* msgh_size passed as argument */

  3508. 	InP->Head.msgh_request_port = server_port;

  3509. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  3510. 	InP->Head.msgh_id = 1011;

  3511. 

  3512. 	__BeforeSendRpc(1011, "rpc_jack_set_freewheel")

  3513. 	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);

  3514. 	__AfterSendRpc(1011, "rpc_jack_set_freewheel")

  3515. 	if (msg_result != MACH_MSG_SUCCESS) {

  3516. 		__MachMsgErrorWithoutTimeout(msg_result);

  3517. 		{ return msg_result; }

  3518. 	}

  3519. 

  3520. 

  3521. #if	defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)

  3522. 	check_result = __MIG_check__Reply__rpc_jack_set_freewheel_t((__Reply__rpc_jack_set_freewheel_t *)Out0P);

  3523. 	if (check_result != MACH_MSG_SUCCESS)

  3524. 		{ return check_result; }

  3525. #endif	/* defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined) */

  3526. 

  3527. 	*result = Out0P->result;

  3528. 

  3529. 	return KERN_SUCCESS;

  3530.     }

  3531. }

  3532. 

  3533. #if ( __MigTypeCheck || __NDR_convert__ )

  3534. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3535. #if !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)

  3536. #define __MIG_check__Reply__rpc_jack_release_timebase_t__defined

  3537. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3538. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3539. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3540. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \

  3541. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  3542. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3543. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3544. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \

  3545. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  3546. #endif /* defined(__NDR_convert__*__defined) */

  3547. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */

  3548. 

  3549. 

  3550. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3551. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3552. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3553. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3554. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  3555. #elif	defined(__NDR_convert__int_rep__int__defined)

  3556. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3557. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3558. 	__NDR_convert__int_rep__int((int *)(a), f)

  3559. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3560. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3561. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3562. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3563. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3564. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3565. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3566. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  3567. #endif /* defined(__NDR_convert__*__defined) */

  3568. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3569. 

  3570. 

  3571. 

  3572. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3573. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3574. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3575. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3576. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  3577. #elif	defined(__NDR_convert__char_rep__int__defined)

  3578. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3579. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3580. 	__NDR_convert__char_rep__int((int *)(a), f)

  3581. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3582. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3583. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3584. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3585. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3586. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3587. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3588. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  3589. #endif /* defined(__NDR_convert__*__defined) */

  3590. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3591. 

  3592. 

  3593. 

  3594. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3595. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3596. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3597. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3598. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  3599. #elif	defined(__NDR_convert__float_rep__int__defined)

  3600. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3601. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3602. 	__NDR_convert__float_rep__int((int *)(a), f)

  3603. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3604. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3605. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3606. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3607. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3608. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3609. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

  3610. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  3611. #endif /* defined(__NDR_convert__*__defined) */

  3612. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3613. 

  3614. 

  3615. 

  3616. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Reply__rpc_jack_release_timebase_t *Out0P)

  3617. {

  3618. 

  3619. 	typedef __Reply__rpc_jack_release_timebase_t __Reply;

  3620. #if	__MigTypeCheck

  3621. 	unsigned int msgh_size;

  3622. #endif	/* __MigTypeCheck */

  3623. 	if (Out0P->Head.msgh_id != 1112) {

  3624. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  3625. 		{ return MIG_SERVER_DIED; }

  3626. 	    else

  3627. 		{ return MIG_REPLY_MISMATCH; }

  3628. 	}

  3629. 

  3630. #if	__MigTypeCheck

  3631. 	msgh_size = Out0P->Head.msgh_size;

  3632. 

  3633. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  3634. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  3635. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  3636. 	      Out0P->RetCode == KERN_SUCCESS)))

  3637. 		{ return MIG_TYPE_ERROR ; }

  3638. #endif	/* __MigTypeCheck */

  3639. 

  3640. 	if (Out0P->RetCode != KERN_SUCCESS) {

  3641. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3642. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3643. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  3644. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  3645. 	}

  3646. 

  3647. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined) || \

  3648. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3649. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  3650. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined)

  3651. 		__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  3652. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */

  3653. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3654. 		__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.int_rep);

  3655. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3656. 	}

  3657. #endif	/* defined(__NDR_convert__int_rep...) */

  3658. 

  3659. #if	0 || \

  3660. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3661. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  3662. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3663. 		__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.char_rep);

  3664. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3665. 	}

  3666. #endif	/* defined(__NDR_convert__char_rep...) */

  3667. 

  3668. #if	0 || \

  3669. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3670. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  3671. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)

  3672. 		__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(&Out0P->result, Out0P->NDR.float_rep);

  3673. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3674. 	}

  3675. #endif	/* defined(__NDR_convert__float_rep...) */

  3676. 

  3677. 	return MACH_MSG_SUCCESS;

  3678. }

  3679. #endif /* !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */

  3680. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  3681. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  3682. 

  3683. 

  3684. /* Routine rpc_jack_release_timebase */

  3685. mig_external kern_return_t rpc_jack_release_timebase

  3686. (

  3687. 	mach_port_t server_port,

  3688. 	int refnum,

  3689. 	int *result

  3690. )

  3691. {

  3692.     {

  3693. 

  3694. #ifdef  __MigPackStructs

  3695. #pragma pack(4)

  3696. #endif

  3697. 	typedef struct {

  3698. 		mach_msg_header_t Head;

  3699. 		NDR_record_t NDR;

  3700. 		int refnum;

  3701. 	} Request;

  3702. #ifdef  __MigPackStructs

  3703. #pragma pack()

  3704. #endif

  3705. 

  3706. #ifdef  __MigPackStructs

  3707. #pragma pack(4)

  3708. #endif

  3709. 	typedef struct {

  3710. 		mach_msg_header_t Head;

  3711. 		NDR_record_t NDR;

  3712. 		kern_return_t RetCode;

  3713. 		int result;

  3714. 		mach_msg_trailer_t trailer;

  3715. 	} Reply;

  3716. #ifdef  __MigPackStructs

  3717. #pragma pack()

  3718. #endif

  3719. 

  3720. #ifdef  __MigPackStructs

  3721. #pragma pack(4)

  3722. #endif

  3723. 	typedef struct {

  3724. 		mach_msg_header_t Head;

  3725. 		NDR_record_t NDR;

  3726. 		kern_return_t RetCode;

  3727. 		int result;

  3728. 	} __Reply;

  3729. #ifdef  __MigPackStructs

  3730. #pragma pack()

  3731. #endif

  3732. 	/*

  3733. 	 * typedef struct {

  3734. 	 * 	mach_msg_header_t Head;

  3735. 	 * 	NDR_record_t NDR;

  3736. 	 * 	kern_return_t RetCode;

  3737. 	 * } mig_reply_error_t;

  3738. 	 */

  3739. 

  3740. 	union {

  3741. 		Request In;

  3742. 		Reply Out;

  3743. 	} Mess;

  3744. 

  3745. 	Request *InP = &Mess.In;

  3746. 	Reply *Out0P = &Mess.Out;

  3747. 

  3748. 	mach_msg_return_t msg_result;

  3749. 

  3750. #ifdef	__MIG_check__Reply__rpc_jack_release_timebase_t__defined

  3751. 	kern_return_t check_result;

  3752. #endif	/* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */

  3753. 

  3754. 	__DeclareSendRpc(1012, "rpc_jack_release_timebase")

  3755. 

  3756. 	InP->NDR = NDR_record;

  3757. 

  3758. 	InP->refnum = refnum;

  3759. 

  3760. 	InP->Head.msgh_bits =

  3761. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3762. 	/* msgh_size passed as argument */

  3763. 	InP->Head.msgh_request_port = server_port;

  3764. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  3765. 	InP->Head.msgh_id = 1012;

  3766. 

  3767. 	__BeforeSendRpc(1012, "rpc_jack_release_timebase")

  3768. 	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);

  3769. 	__AfterSendRpc(1012, "rpc_jack_release_timebase")

  3770. 	if (msg_result != MACH_MSG_SUCCESS) {

  3771. 		__MachMsgErrorWithoutTimeout(msg_result);

  3772. 		{ return msg_result; }

  3773. 	}

  3774. 

  3775. 

  3776. #if	defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)

  3777. 	check_result = __MIG_check__Reply__rpc_jack_release_timebase_t((__Reply__rpc_jack_release_timebase_t *)Out0P);

  3778. 	if (check_result != MACH_MSG_SUCCESS)

  3779. 		{ return check_result; }

  3780. #endif	/* defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined) */

  3781. 

  3782. 	*result = Out0P->result;

  3783. 

  3784. 	return KERN_SUCCESS;

  3785.     }

  3786. }

  3787. 

  3788. #if ( __MigTypeCheck || __NDR_convert__ )

  3789. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3790. #if !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)

  3791. #define __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined

  3792. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  3793. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3794. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  3795. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \

  3796. 	__NDR_convert__int_rep__JackRPCEngine__kern_return_t((kern_return_t *)(a), f)

  3797. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3798. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  3799. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \

  3800. 	__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)

  3801. #endif /* defined(__NDR_convert__*__defined) */

  3802. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */

  3803. 

  3804. 

  3805. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3806. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3807. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3808. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3809. 	__NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f)

  3810. #elif	defined(__NDR_convert__int_rep__int__defined)

  3811. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3812. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3813. 	__NDR_convert__int_rep__int((int *)(a), f)

  3814. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3815. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3816. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3817. 	__NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3818. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3819. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3820. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3821. 	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)

  3822. #endif /* defined(__NDR_convert__*__defined) */

  3823. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3824. 

  3825. 

  3826. 

  3827. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3828. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3829. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3830. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3831. 	__NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f)

  3832. #elif	defined(__NDR_convert__char_rep__int__defined)

  3833. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3834. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3835. 	__NDR_convert__char_rep__int((int *)(a), f)

  3836. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3837. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3838. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3839. 	__NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3840. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3841. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3842. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3843. 	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)

  3844. #endif /* defined(__NDR_convert__*__defined) */

  3845. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3846. 

  3847. 

  3848. 

  3849. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3850. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3851. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3852. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3853. 	__NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f)

  3854. #elif	defined(__NDR_convert__float_rep__int__defined)

  3855. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3856. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3857. 	__NDR_convert__float_rep__int((int *)(a), f)

  3858. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3859. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3860. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3861. 	__NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f)

  3862. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3863. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  3864. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

  3865. 	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)

  3866. #endif /* defined(__NDR_convert__*__defined) */

  3867. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3868. 

  3869. 

  3870. 

  3871. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(__Reply__rpc_jack_set_timebase_callback_t *Out0P)

  3872. {

  3873. 

  3874. 	typedef __Reply__rpc_jack_set_timebase_callback_t __Reply;

  3875. #if	__MigTypeCheck

  3876. 	unsigned int msgh_size;

  3877. #endif	/* __MigTypeCheck */

  3878. 	if (Out0P->Head.msgh_id != 1113) {

  3879. 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)

  3880. 		{ return MIG_SERVER_DIED; }

  3881. 	    else

  3882. 		{ return MIG_REPLY_MISMATCH; }

  3883. 	}

  3884. 

  3885. #if	__MigTypeCheck

  3886. 	msgh_size = Out0P->Head.msgh_size;

  3887. 

  3888. 	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||

  3889. 	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&

  3890. 	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||

  3891. 	      Out0P->RetCode == KERN_SUCCESS)))

  3892. 		{ return MIG_TYPE_ERROR ; }

  3893. #endif	/* __MigTypeCheck */

  3894. 

  3895. 	if (Out0P->RetCode != KERN_SUCCESS) {

  3896. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3897. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3898. #endif	/* __NDR_convert__mig_reply_error_t__defined */

  3899. 		return ((mig_reply_error_t *)Out0P)->RetCode;

  3900. 	}

  3901. 

  3902. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined) || \

  3903. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3904. 	if (Out0P->NDR.int_rep != NDR_record.int_rep) {

  3905. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined)

  3906. 		__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  3907. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */

  3908. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3909. 		__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.int_rep);

  3910. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3911. 	}

  3912. #endif	/* defined(__NDR_convert__int_rep...) */

  3913. 

  3914. #if	0 || \

  3915. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3916. 	if (Out0P->NDR.char_rep != NDR_record.char_rep) {

  3917. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3918. 		__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.char_rep);

  3919. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3920. 	}

  3921. #endif	/* defined(__NDR_convert__char_rep...) */

  3922. 

  3923. #if	0 || \

  3924. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3925. 	if (Out0P->NDR.float_rep != NDR_record.float_rep) {

  3926. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

  3927. 		__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(&Out0P->result, Out0P->NDR.float_rep);

  3928. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  3929. 	}

  3930. #endif	/* defined(__NDR_convert__float_rep...) */

  3931. 

  3932. 	return MACH_MSG_SUCCESS;

  3933. }

  3934. #endif /* !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */

  3935. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

  3936. #endif /* ( __MigTypeCheck || __NDR_convert__ ) */

  3937. 

  3938. 

  3939. /* Routine rpc_jack_set_timebase_callback */

  3940. mig_external kern_return_t rpc_jack_set_timebase_callback

  3941. (

  3942. 	mach_port_t server_port,

  3943. 	int refnum,

  3944. 	int conditional,

  3945. 	int *result

  3946. )

  3947. {

  3948.     {

  3949. 

  3950. #ifdef  __MigPackStructs

  3951. #pragma pack(4)

  3952. #endif

  3953. 	typedef struct {

  3954. 		mach_msg_header_t Head;

  3955. 		NDR_record_t NDR;

  3956. 		int refnum;

  3957. 		int conditional;

  3958. 	} Request;

  3959. #ifdef  __MigPackStructs

  3960. #pragma pack()

  3961. #endif

  3962. 

  3963. #ifdef  __MigPackStructs

  3964. #pragma pack(4)

  3965. #endif

  3966. 	typedef struct {

  3967. 		mach_msg_header_t Head;

  3968. 		NDR_record_t NDR;

  3969. 		kern_return_t RetCode;

  3970. 		int result;

  3971. 		mach_msg_trailer_t trailer;

  3972. 	} Reply;

  3973. #ifdef  __MigPackStructs

  3974. #pragma pack()

  3975. #endif

  3976. 

  3977. #ifdef  __MigPackStructs

  3978. #pragma pack(4)

  3979. #endif

  3980. 	typedef struct {

  3981. 		mach_msg_header_t Head;

  3982. 		NDR_record_t NDR;

  3983. 		kern_return_t RetCode;

  3984. 		int result;

  3985. 	} __Reply;

  3986. #ifdef  __MigPackStructs

  3987. #pragma pack()

  3988. #endif

  3989. 	/*

  3990. 	 * typedef struct {

  3991. 	 * 	mach_msg_header_t Head;

  3992. 	 * 	NDR_record_t NDR;

  3993. 	 * 	kern_return_t RetCode;

  3994. 	 * } mig_reply_error_t;

  3995. 	 */

  3996. 

  3997. 	union {

  3998. 		Request In;

  3999. 		Reply Out;

  4000. 	} Mess;

  4001. 

  4002. 	Request *InP = &Mess.In;

  4003. 	Reply *Out0P = &Mess.Out;

  4004. 

  4005. 	mach_msg_return_t msg_result;

  4006. 

  4007. #ifdef	__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined

  4008. 	kern_return_t check_result;

  4009. #endif	/* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */

  4010. 

  4011. 	__DeclareSendRpc(1013, "rpc_jack_set_timebase_callback")

  4012. 

  4013. 	InP->NDR = NDR_record;

  4014. 

  4015. 	InP->refnum = refnum;

  4016. 

  4017. 	InP->conditional = conditional;

  4018. 

  4019. 	InP->Head.msgh_bits =

  4020. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  4021. 	/* msgh_size passed as argument */

  4022. 	InP->Head.msgh_request_port = server_port;

  4023. 	InP->Head.msgh_reply_port = mig_get_reply_port();

  4024. 	InP->Head.msgh_id = 1013;

  4025. 

  4026. 	__BeforeSendRpc(1013, "rpc_jack_set_timebase_callback")

  4027. 	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);

  4028. 	__AfterSendRpc(1013, "rpc_jack_set_timebase_callback")

  4029. 	if (msg_result != MACH_MSG_SUCCESS) {

  4030. 		__MachMsgErrorWithoutTimeout(msg_result);

  4031. 		{ return msg_result; }

  4032. 	}

  4033. 

  4034. 

  4035. #if	defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)

  4036. 	check_result = __MIG_check__Reply__rpc_jack_set_timebase_callback_t((__Reply__rpc_jack_set_timebase_callback_t *)Out0P);

  4037. 	if (check_result != MACH_MSG_SUCCESS)

  4038. 		{ return check_result; }

  4039. #endif	/* defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined) */

  4040. 

  4041. 	*result = Out0P->result;

  4042. 

  4043. 	return KERN_SUCCESS;

  4044.     }

  4045. }

  4046. 

  4047. /* SimpleRoutine rpc_jack_client_rt_notify */

  4048. mig_external kern_return_t rpc_jack_client_rt_notify

  4049. (

  4050. 	mach_port_t client_port,

  4051. 	int refnum,

  4052. 	int notify,

  4053. 	int value,

  4054. 	int timeout

  4055. )

  4056. {

  4057.     {

  4058. 

  4059. #ifdef  __MigPackStructs

  4060. #pragma pack(4)

  4061. #endif

  4062. 	typedef struct {

  4063. 		mach_msg_header_t Head;

  4064. 		NDR_record_t NDR;

  4065. 		int refnum;

  4066. 		int notify;

  4067. 		int value;

  4068. 	} Request;

  4069. #ifdef  __MigPackStructs

  4070. #pragma pack()

  4071. #endif

  4072. 	/*

  4073. 	 * typedef struct {

  4074. 	 * 	mach_msg_header_t Head;

  4075. 	 * 	NDR_record_t NDR;

  4076. 	 * 	kern_return_t RetCode;

  4077. 	 * } mig_reply_error_t;

  4078. 	 */

  4079. 

  4080. 	union {

  4081. 		Request In;

  4082. 	} Mess;

  4083. 

  4084. 	Request *InP = &Mess.In;

  4085. 

  4086. 	mach_msg_return_t msg_result;

  4087. 

  4088. #ifdef	__MIG_check__Reply__rpc_jack_client_rt_notify_t__defined

  4089. 	kern_return_t check_result;

  4090. #endif	/* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */

  4091. 

  4092. 	__DeclareSendSimple(1014, "rpc_jack_client_rt_notify")

  4093. 

  4094. 	InP->NDR = NDR_record;

  4095. 

  4096. 	InP->refnum = refnum;

  4097. 

  4098. 	InP->notify = notify;

  4099. 

  4100. 	InP->value = value;

  4101. 

  4102. 	InP->Head.msgh_bits =

  4103. 		MACH_MSGH_BITS(19, 0);

  4104. 	/* msgh_size passed as argument */

  4105. 	InP->Head.msgh_request_port = client_port;

  4106. 	InP->Head.msgh_reply_port = MACH_PORT_NULL;

  4107. 	InP->Head.msgh_id = 1014;

  4108. 

  4109. 	__BeforeSendSimple(1014, "rpc_jack_client_rt_notify")

  4110. 	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);

  4111. 	__AfterSendSimple(1014, "rpc_jack_client_rt_notify")

  4112. 		return msg_result;

  4113. 	return KERN_SUCCESS;

  4114.     }

  4115. }