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.
238 Commits
8 Branches
256MB
Tree: f79aaaadd2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f79aaaadd2'
${ noResults }
jack2/macosx/RPC/JackRPCEngineUser.c

4535 lines
192KB
Raw Blame History 

  1. /*

  2.  * IDENTIFICATION:

  3.  * stub generated Wed Aug 15 17:00:32 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_check_t__defined)

  603. #define __MIG_check__Reply__rpc_jack_client_check_t__defined

  604. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_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_check_t__RetCode__defined

  607. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_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_check_t__RetCode__defined

  611. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_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_check_t__RetCode__defined */

  615. 

  616. 

  617. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  618. #if	defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined)

  619. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  620. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  621. 	__NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)

  622. #elif	defined(__NDR_convert__int_rep__client_name_t__defined)

  623. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  624. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  625. 	__NDR_convert__int_rep__client_name_t((client_name_t *)(a), f)

  626. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)

  627. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  628. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  629. 	__NDR_convert__int_rep__JackRPCEngine__string(a, f, 128)

  630. #elif	defined(__NDR_convert__int_rep__string__defined)

  631. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  632. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  633. 	__NDR_convert__int_rep__string(a, f, 128)

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

  635. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  636. 

  637. 

  638. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined

  639. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  640. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined

  641. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  643. #elif	defined(__NDR_convert__int_rep__int__defined)

  644. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined

  645. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  647. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  648. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined

  649. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  651. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  652. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined

  653. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

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

  656. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */

  657. 

  658. 

  659. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined

  660. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  661. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined

  662. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  664. #elif	defined(__NDR_convert__int_rep__int__defined)

  665. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined

  666. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  668. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  669. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined

  670. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  672. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  673. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined

  674. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

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

  677. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */

  678. 

  679. 

  680. 

  681. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  682. #if	defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined)

  683. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  684. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  685. 	__NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)

  686. #elif	defined(__NDR_convert__char_rep__client_name_t__defined)

  687. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  688. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  689. 	__NDR_convert__char_rep__client_name_t((client_name_t *)(a), f)

  690. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)

  691. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  692. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  693. 	__NDR_convert__char_rep__JackRPCEngine__string(a, f, 128)

  694. #elif	defined(__NDR_convert__char_rep__string__defined)

  695. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  696. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  697. 	__NDR_convert__char_rep__string(a, f, 128)

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

  699. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  700. 

  701. 

  702. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined

  703. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  704. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined

  705. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  707. #elif	defined(__NDR_convert__char_rep__int__defined)

  708. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined

  709. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  711. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  712. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined

  713. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  715. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  716. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined

  717. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

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

  720. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */

  721. 

  722. 

  723. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined

  724. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  725. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined

  726. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  728. #elif	defined(__NDR_convert__char_rep__int__defined)

  729. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined

  730. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  732. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  733. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined

  734. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  736. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  737. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined

  738. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

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

  741. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */

  742. 

  743. 

  744. 

  745. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  746. #if	defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined)

  747. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  748. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  749. 	__NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f)

  750. #elif	defined(__NDR_convert__float_rep__client_name_t__defined)

  751. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  752. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  753. 	__NDR_convert__float_rep__client_name_t((client_name_t *)(a), f)

  754. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)

  755. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  756. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  757. 	__NDR_convert__float_rep__JackRPCEngine__string(a, f, 128)

  758. #elif	defined(__NDR_convert__float_rep__string__defined)

  759. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined

  760. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(a, f) \

  761. 	__NDR_convert__float_rep__string(a, f, 128)

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

  763. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  764. 

  765. 

  766. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined

  767. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  768. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined

  769. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  771. #elif	defined(__NDR_convert__float_rep__int__defined)

  772. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined

  773. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  775. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  776. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined

  777. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

  779. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  780. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined

  781. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(a, f) \

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

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

  784. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */

  785. 

  786. 

  787. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined

  788. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  789. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined

  790. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  792. #elif	defined(__NDR_convert__float_rep__int__defined)

  793. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined

  794. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  796. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  797. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined

  798. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

  800. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  801. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined

  802. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(a, f) \

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

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

  805. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */

  806. 

  807. 

  808. 

  809. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_check_t(__Reply__rpc_jack_client_check_t *Out0P)

  810. {

  811. 

  812. 	typedef __Reply__rpc_jack_client_check_t __Reply;

  813. #if	__MigTypeCheck

  814. 	unsigned int msgh_size;

  815. #endif	/* __MigTypeCheck */

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

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

  818. 		{ return MIG_SERVER_DIED; }

  819. 	    else

  820. 		{ return MIG_REPLY_MISMATCH; }

  821. 	}

  822. 

  823. #if	__MigTypeCheck

  824. 	msgh_size = Out0P->Head.msgh_size;

  825. 

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

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

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

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

  830. 		{ return MIG_TYPE_ERROR ; }

  831. #endif	/* __MigTypeCheck */

  832. 

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

  834. #ifdef	__NDR_convert__mig_reply_error_t__defined

  835. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  836. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  838. 	}

  839. 

  840. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined) || \

  841. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \

  842. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined) || \

  843. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)

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

  845. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined)

  846. 		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);

  847. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__RetCode__defined */

  848. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)

  849. 		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep);

  850. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  851. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined)

  852. 		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.int_rep);

  853. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__status__defined */

  854. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined)

  855. 		__NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.int_rep);

  856. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_check_t__result__defined */

  857. 	}

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

  859. 

  860. #if	0 || \

  861. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \

  862. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined) || \

  863. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)

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

  865. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)

  866. 		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep);

  867. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  868. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined)

  869. 		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.char_rep);

  870. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__status__defined */

  871. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined)

  872. 		__NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.char_rep);

  873. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_check_t__result__defined */

  874. 	}

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

  876. 

  877. #if	0 || \

  878. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined) || \

  879. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined) || \

  880. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)

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

  882. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined)

  883. 		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep);

  884. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__client_name_res__defined */

  885. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined)

  886. 		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status(&Out0P->status, Out0P->NDR.float_rep);

  887. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__status__defined */

  888. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined)

  889. 		__NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result(&Out0P->result, Out0P->NDR.float_rep);

  890. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_check_t__result__defined */

  891. 	}

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

  893. 

  894. 	return MACH_MSG_SUCCESS;

  895. }

  896. #endif /* !defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */

  897. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  899. 

  900. 

  901. /* Routine rpc_jack_client_check */

  902. mig_external kern_return_t rpc_jack_client_check

  903. (

  904. 	mach_port_t server_port,

  905. 	client_name_t client_name,

  906. 	client_name_t client_name_res,

  907. 	int options,

  908. 	int *status,

  909. 	int *result

  910. )

  911. {

  912.     {

  913. 

  914. #ifdef  __MigPackStructs

  915. #pragma pack(4)

  916. #endif

  917. 	typedef struct {

  918. 		mach_msg_header_t Head;

  919. 		NDR_record_t NDR;

  920. 		client_name_t client_name;

  921. 		int options;

  922. 	} Request;

  923. #ifdef  __MigPackStructs

  924. #pragma pack()

  925. #endif

  926. 

  927. #ifdef  __MigPackStructs

  928. #pragma pack(4)

  929. #endif

  930. 	typedef struct {

  931. 		mach_msg_header_t Head;

  932. 		NDR_record_t NDR;

  933. 		kern_return_t RetCode;

  934. 		client_name_t client_name_res;

  935. 		int status;

  936. 		int result;

  937. 		mach_msg_trailer_t trailer;

  938. 	} Reply;

  939. #ifdef  __MigPackStructs

  940. #pragma pack()

  941. #endif

  942. 

  943. #ifdef  __MigPackStructs

  944. #pragma pack(4)

  945. #endif

  946. 	typedef struct {

  947. 		mach_msg_header_t Head;

  948. 		NDR_record_t NDR;

  949. 		kern_return_t RetCode;

  950. 		client_name_t client_name_res;

  951. 		int status;

  952. 		int result;

  953. 	} __Reply;

  954. #ifdef  __MigPackStructs

  955. #pragma pack()

  956. #endif

  957. 	/*

  958. 	 * typedef struct {

  959. 	 * 	mach_msg_header_t Head;

  960. 	 * 	NDR_record_t NDR;

  961. 	 * 	kern_return_t RetCode;

  962. 	 * } mig_reply_error_t;

  963. 	 */

  964. 

  965. 	union {

  966. 		Request In;

  967. 		Reply Out;

  968. 	} Mess;

  969. 

  970. 	Request *InP = &Mess.In;

  971. 	Reply *Out0P = &Mess.Out;

  972. 

  973. 	mach_msg_return_t msg_result;

  974. 

  975. #ifdef	__MIG_check__Reply__rpc_jack_client_check_t__defined

  976. 	kern_return_t check_result;

  977. #endif	/* __MIG_check__Reply__rpc_jack_client_check_t__defined */

  978. 

  979. 	__DeclareSendRpc(1001, "rpc_jack_client_check")

  980. 

  981. 	InP->NDR = NDR_record;

  982. 

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

  984. 

  985. 	InP->options = options;

  986. 

  987. 	InP->Head.msgh_bits =

  988. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  989. 	/* msgh_size passed as argument */

  990. 	InP->Head.msgh_request_port = server_port;

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

  992. 	InP->Head.msgh_id = 1001;

  993. 

  994. 	__BeforeSendRpc(1001, "rpc_jack_client_check")

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

  996. 	__AfterSendRpc(1001, "rpc_jack_client_check")

  997. 	if (msg_result != MACH_MSG_SUCCESS) {

  998. 		__MachMsgErrorWithoutTimeout(msg_result);

  999. 		{ return msg_result; }

  1000. 	}

  1001. 

  1002. 

  1003. #if	defined(__MIG_check__Reply__rpc_jack_client_check_t__defined)

  1004. 	check_result = __MIG_check__Reply__rpc_jack_client_check_t((__Reply__rpc_jack_client_check_t *)Out0P);

  1005. 	if (check_result != MACH_MSG_SUCCESS)

  1006. 		{ return check_result; }

  1007. #endif	/* defined(__MIG_check__Reply__rpc_jack_client_check_t__defined) */

  1008. 

  1009. 	(void) mig_strncpy(client_name_res, Out0P->client_name_res, 128);

  1010. 

  1011. 	*status = Out0P->status;

  1012. 

  1013. 	*result = Out0P->result;

  1014. 

  1015. 	return KERN_SUCCESS;

  1016.     }

  1017. }

  1018. 

  1019. #if ( __MigTypeCheck || __NDR_convert__ )

  1020. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1021. #if !defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)

  1022. #define __MIG_check__Reply__rpc_jack_client_close_t__defined

  1023. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  1024. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1025. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  1026. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \

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

  1028. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1029. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined

  1030. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode(a, f) \

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

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

  1033. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */

  1034. 

  1035. 

  1036. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  1037. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1038. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  1039. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1041. #elif	defined(__NDR_convert__int_rep__int__defined)

  1042. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  1043. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1045. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1046. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  1047. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1049. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1050. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined

  1051. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

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

  1054. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */

  1055. 

  1056. 

  1057. 

  1058. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  1059. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1060. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  1061. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1063. #elif	defined(__NDR_convert__char_rep__int__defined)

  1064. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  1065. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1067. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1068. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  1069. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1071. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1072. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined

  1073. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

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

  1076. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */

  1077. 

  1078. 

  1079. 

  1080. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  1081. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1082. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  1083. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1085. #elif	defined(__NDR_convert__float_rep__int__defined)

  1086. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  1087. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1089. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1090. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  1091. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

  1093. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1094. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined

  1095. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result(a, f) \

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

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

  1098. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */

  1099. 

  1100. 

  1101. 

  1102. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_close_t(__Reply__rpc_jack_client_close_t *Out0P)

  1103. {

  1104. 

  1105. 	typedef __Reply__rpc_jack_client_close_t __Reply;

  1106. #if	__MigTypeCheck

  1107. 	unsigned int msgh_size;

  1108. #endif	/* __MigTypeCheck */

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

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

  1111. 		{ return MIG_SERVER_DIED; }

  1112. 	    else

  1113. 		{ return MIG_REPLY_MISMATCH; }

  1114. 	}

  1115. 

  1116. #if	__MigTypeCheck

  1117. 	msgh_size = Out0P->Head.msgh_size;

  1118. 

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

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

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

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

  1123. 		{ return MIG_TYPE_ERROR ; }

  1124. #endif	/* __MigTypeCheck */

  1125. 

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

  1127. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1128. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1129. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  1131. 	}

  1132. 

  1133. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined) || \

  1134. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1136. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined)

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

  1138. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__RetCode__defined */

  1139. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1141. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_close_t__result__defined */

  1142. 	}

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

  1144. 

  1145. #if	0 || \

  1146. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1148. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1150. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_close_t__result__defined */

  1151. 	}

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

  1153. 

  1154. #if	0 || \

  1155. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1157. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined)

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

  1159. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_close_t__result__defined */

  1160. 	}

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

  1162. 

  1163. 	return MACH_MSG_SUCCESS;

  1164. }

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

  1166. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  1168. 

  1169. 

  1170. /* Routine rpc_jack_client_close */

  1171. mig_external kern_return_t rpc_jack_client_close

  1172. (

  1173. 	mach_port_t server_port,

  1174. 	int refnum,

  1175. 	int *result

  1176. )

  1177. {

  1178.     {

  1179. 

  1180. #ifdef  __MigPackStructs

  1181. #pragma pack(4)

  1182. #endif

  1183. 	typedef struct {

  1184. 		mach_msg_header_t Head;

  1185. 		NDR_record_t NDR;

  1186. 		int refnum;

  1187. 	} Request;

  1188. #ifdef  __MigPackStructs

  1189. #pragma pack()

  1190. #endif

  1191. 

  1192. #ifdef  __MigPackStructs

  1193. #pragma pack(4)

  1194. #endif

  1195. 	typedef struct {

  1196. 		mach_msg_header_t Head;

  1197. 		NDR_record_t NDR;

  1198. 		kern_return_t RetCode;

  1199. 		int result;

  1200. 		mach_msg_trailer_t trailer;

  1201. 	} Reply;

  1202. #ifdef  __MigPackStructs

  1203. #pragma pack()

  1204. #endif

  1205. 

  1206. #ifdef  __MigPackStructs

  1207. #pragma pack(4)

  1208. #endif

  1209. 	typedef struct {

  1210. 		mach_msg_header_t Head;

  1211. 		NDR_record_t NDR;

  1212. 		kern_return_t RetCode;

  1213. 		int result;

  1214. 	} __Reply;

  1215. #ifdef  __MigPackStructs

  1216. #pragma pack()

  1217. #endif

  1218. 	/*

  1219. 	 * typedef struct {

  1220. 	 * 	mach_msg_header_t Head;

  1221. 	 * 	NDR_record_t NDR;

  1222. 	 * 	kern_return_t RetCode;

  1223. 	 * } mig_reply_error_t;

  1224. 	 */

  1225. 

  1226. 	union {

  1227. 		Request In;

  1228. 		Reply Out;

  1229. 	} Mess;

  1230. 

  1231. 	Request *InP = &Mess.In;

  1232. 	Reply *Out0P = &Mess.Out;

  1233. 

  1234. 	mach_msg_return_t msg_result;

  1235. 

  1236. #ifdef	__MIG_check__Reply__rpc_jack_client_close_t__defined

  1237. 	kern_return_t check_result;

  1238. #endif	/* __MIG_check__Reply__rpc_jack_client_close_t__defined */

  1239. 

  1240. 	__DeclareSendRpc(1002, "rpc_jack_client_close")

  1241. 

  1242. 	InP->NDR = NDR_record;

  1243. 

  1244. 	InP->refnum = refnum;

  1245. 

  1246. 	InP->Head.msgh_bits =

  1247. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1248. 	/* msgh_size passed as argument */

  1249. 	InP->Head.msgh_request_port = server_port;

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

  1251. 	InP->Head.msgh_id = 1002;

  1252. 

  1253. 	__BeforeSendRpc(1002, "rpc_jack_client_close")

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

  1255. 	__AfterSendRpc(1002, "rpc_jack_client_close")

  1256. 	if (msg_result != MACH_MSG_SUCCESS) {

  1257. 		__MachMsgErrorWithoutTimeout(msg_result);

  1258. 		{ return msg_result; }

  1259. 	}

  1260. 

  1261. 

  1262. #if	defined(__MIG_check__Reply__rpc_jack_client_close_t__defined)

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

  1264. 	if (check_result != MACH_MSG_SUCCESS)

  1265. 		{ return check_result; }

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

  1267. 

  1268. 	*result = Out0P->result;

  1269. 

  1270. 	return KERN_SUCCESS;

  1271.     }

  1272. }

  1273. 

  1274. #if ( __MigTypeCheck || __NDR_convert__ )

  1275. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1276. #if !defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)

  1277. #define __MIG_check__Reply__rpc_jack_client_activate_t__defined

  1278. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  1279. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1280. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  1281. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \

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

  1283. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1284. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined

  1285. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode(a, f) \

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

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

  1288. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */

  1289. 

  1290. 

  1291. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  1292. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1293. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  1294. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1296. #elif	defined(__NDR_convert__int_rep__int__defined)

  1297. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  1298. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1300. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1301. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  1302. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1304. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1305. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined

  1306. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

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

  1309. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1310. 

  1311. 

  1312. 

  1313. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  1314. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1315. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  1316. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1318. #elif	defined(__NDR_convert__char_rep__int__defined)

  1319. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  1320. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1322. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1323. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  1324. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1326. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1327. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined

  1328. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

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

  1331. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1332. 

  1333. 

  1334. 

  1335. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  1336. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1337. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  1338. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1340. #elif	defined(__NDR_convert__float_rep__int__defined)

  1341. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  1342. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1344. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1345. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  1346. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

  1348. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1349. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined

  1350. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result(a, f) \

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

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

  1353. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1354. 

  1355. 

  1356. 

  1357. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_activate_t(__Reply__rpc_jack_client_activate_t *Out0P)

  1358. {

  1359. 

  1360. 	typedef __Reply__rpc_jack_client_activate_t __Reply;

  1361. #if	__MigTypeCheck

  1362. 	unsigned int msgh_size;

  1363. #endif	/* __MigTypeCheck */

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

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

  1366. 		{ return MIG_SERVER_DIED; }

  1367. 	    else

  1368. 		{ return MIG_REPLY_MISMATCH; }

  1369. 	}

  1370. 

  1371. #if	__MigTypeCheck

  1372. 	msgh_size = Out0P->Head.msgh_size;

  1373. 

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

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

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

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

  1378. 		{ return MIG_TYPE_ERROR ; }

  1379. #endif	/* __MigTypeCheck */

  1380. 

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

  1382. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1383. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1384. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  1386. 	}

  1387. 

  1388. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined) || \

  1389. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1391. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined)

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

  1393. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__RetCode__defined */

  1394. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1396. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1397. 	}

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

  1399. 

  1400. #if	0 || \

  1401. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1403. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1405. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1406. 	}

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

  1408. 

  1409. #if	0 || \

  1410. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1412. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined)

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

  1414. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_activate_t__result__defined */

  1415. 	}

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

  1417. 

  1418. 	return MACH_MSG_SUCCESS;

  1419. }

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

  1421. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  1423. 

  1424. 

  1425. /* Routine rpc_jack_client_activate */

  1426. mig_external kern_return_t rpc_jack_client_activate

  1427. (

  1428. 	mach_port_t server_port,

  1429. 	int refnum,

  1430. 	int *result

  1431. )

  1432. {

  1433.     {

  1434. 

  1435. #ifdef  __MigPackStructs

  1436. #pragma pack(4)

  1437. #endif

  1438. 	typedef struct {

  1439. 		mach_msg_header_t Head;

  1440. 		NDR_record_t NDR;

  1441. 		int refnum;

  1442. 	} Request;

  1443. #ifdef  __MigPackStructs

  1444. #pragma pack()

  1445. #endif

  1446. 

  1447. #ifdef  __MigPackStructs

  1448. #pragma pack(4)

  1449. #endif

  1450. 	typedef struct {

  1451. 		mach_msg_header_t Head;

  1452. 		NDR_record_t NDR;

  1453. 		kern_return_t RetCode;

  1454. 		int result;

  1455. 		mach_msg_trailer_t trailer;

  1456. 	} Reply;

  1457. #ifdef  __MigPackStructs

  1458. #pragma pack()

  1459. #endif

  1460. 

  1461. #ifdef  __MigPackStructs

  1462. #pragma pack(4)

  1463. #endif

  1464. 	typedef struct {

  1465. 		mach_msg_header_t Head;

  1466. 		NDR_record_t NDR;

  1467. 		kern_return_t RetCode;

  1468. 		int result;

  1469. 	} __Reply;

  1470. #ifdef  __MigPackStructs

  1471. #pragma pack()

  1472. #endif

  1473. 	/*

  1474. 	 * typedef struct {

  1475. 	 * 	mach_msg_header_t Head;

  1476. 	 * 	NDR_record_t NDR;

  1477. 	 * 	kern_return_t RetCode;

  1478. 	 * } mig_reply_error_t;

  1479. 	 */

  1480. 

  1481. 	union {

  1482. 		Request In;

  1483. 		Reply Out;

  1484. 	} Mess;

  1485. 

  1486. 	Request *InP = &Mess.In;

  1487. 	Reply *Out0P = &Mess.Out;

  1488. 

  1489. 	mach_msg_return_t msg_result;

  1490. 

  1491. #ifdef	__MIG_check__Reply__rpc_jack_client_activate_t__defined

  1492. 	kern_return_t check_result;

  1493. #endif	/* __MIG_check__Reply__rpc_jack_client_activate_t__defined */

  1494. 

  1495. 	__DeclareSendRpc(1003, "rpc_jack_client_activate")

  1496. 

  1497. 	InP->NDR = NDR_record;

  1498. 

  1499. 	InP->refnum = refnum;

  1500. 

  1501. 	InP->Head.msgh_bits =

  1502. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1503. 	/* msgh_size passed as argument */

  1504. 	InP->Head.msgh_request_port = server_port;

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

  1506. 	InP->Head.msgh_id = 1003;

  1507. 

  1508. 	__BeforeSendRpc(1003, "rpc_jack_client_activate")

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

  1510. 	__AfterSendRpc(1003, "rpc_jack_client_activate")

  1511. 	if (msg_result != MACH_MSG_SUCCESS) {

  1512. 		__MachMsgErrorWithoutTimeout(msg_result);

  1513. 		{ return msg_result; }

  1514. 	}

  1515. 

  1516. 

  1517. #if	defined(__MIG_check__Reply__rpc_jack_client_activate_t__defined)

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

  1519. 	if (check_result != MACH_MSG_SUCCESS)

  1520. 		{ return check_result; }

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

  1522. 

  1523. 	*result = Out0P->result;

  1524. 

  1525. 	return KERN_SUCCESS;

  1526.     }

  1527. }

  1528. 

  1529. #if ( __MigTypeCheck || __NDR_convert__ )

  1530. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1531. #if !defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)

  1532. #define __MIG_check__Reply__rpc_jack_client_deactivate_t__defined

  1533. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1534. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1535. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1536. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \

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

  1538. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1539. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined

  1540. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode(a, f) \

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

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

  1543. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */

  1544. 

  1545. 

  1546. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1547. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1548. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1549. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1551. #elif	defined(__NDR_convert__int_rep__int__defined)

  1552. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1553. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1555. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1556. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1557. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1559. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1560. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1561. #define	__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

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

  1564. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1565. 

  1566. 

  1567. 

  1568. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1569. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1570. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1571. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1573. #elif	defined(__NDR_convert__char_rep__int__defined)

  1574. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1575. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1577. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1578. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1579. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1581. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1582. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1583. #define	__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

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

  1586. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1587. 

  1588. 

  1589. 

  1590. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1591. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1592. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1593. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1595. #elif	defined(__NDR_convert__float_rep__int__defined)

  1596. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1597. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1599. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1600. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1601. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

  1603. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1604. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined

  1605. #define	__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result(a, f) \

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

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

  1608. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1609. 

  1610. 

  1611. 

  1612. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_deactivate_t(__Reply__rpc_jack_client_deactivate_t *Out0P)

  1613. {

  1614. 

  1615. 	typedef __Reply__rpc_jack_client_deactivate_t __Reply;

  1616. #if	__MigTypeCheck

  1617. 	unsigned int msgh_size;

  1618. #endif	/* __MigTypeCheck */

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

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

  1621. 		{ return MIG_SERVER_DIED; }

  1622. 	    else

  1623. 		{ return MIG_REPLY_MISMATCH; }

  1624. 	}

  1625. 

  1626. #if	__MigTypeCheck

  1627. 	msgh_size = Out0P->Head.msgh_size;

  1628. 

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

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

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

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

  1633. 		{ return MIG_TYPE_ERROR ; }

  1634. #endif	/* __MigTypeCheck */

  1635. 

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

  1637. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1638. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1639. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  1641. 	}

  1642. 

  1643. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined) || \

  1644. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1646. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined)

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

  1648. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__RetCode__defined */

  1649. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1651. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1652. 	}

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

  1654. 

  1655. #if	0 || \

  1656. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1658. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1660. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1661. 	}

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

  1663. 

  1664. #if	0 || \

  1665. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1667. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined)

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

  1669. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_deactivate_t__result__defined */

  1670. 	}

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

  1672. 

  1673. 	return MACH_MSG_SUCCESS;

  1674. }

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

  1676. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  1678. 

  1679. 

  1680. /* Routine rpc_jack_client_deactivate */

  1681. mig_external kern_return_t rpc_jack_client_deactivate

  1682. (

  1683. 	mach_port_t server_port,

  1684. 	int refnum,

  1685. 	int *result

  1686. )

  1687. {

  1688.     {

  1689. 

  1690. #ifdef  __MigPackStructs

  1691. #pragma pack(4)

  1692. #endif

  1693. 	typedef struct {

  1694. 		mach_msg_header_t Head;

  1695. 		NDR_record_t NDR;

  1696. 		int refnum;

  1697. 	} Request;

  1698. #ifdef  __MigPackStructs

  1699. #pragma pack()

  1700. #endif

  1701. 

  1702. #ifdef  __MigPackStructs

  1703. #pragma pack(4)

  1704. #endif

  1705. 	typedef struct {

  1706. 		mach_msg_header_t Head;

  1707. 		NDR_record_t NDR;

  1708. 		kern_return_t RetCode;

  1709. 		int result;

  1710. 		mach_msg_trailer_t trailer;

  1711. 	} Reply;

  1712. #ifdef  __MigPackStructs

  1713. #pragma pack()

  1714. #endif

  1715. 

  1716. #ifdef  __MigPackStructs

  1717. #pragma pack(4)

  1718. #endif

  1719. 	typedef struct {

  1720. 		mach_msg_header_t Head;

  1721. 		NDR_record_t NDR;

  1722. 		kern_return_t RetCode;

  1723. 		int result;

  1724. 	} __Reply;

  1725. #ifdef  __MigPackStructs

  1726. #pragma pack()

  1727. #endif

  1728. 	/*

  1729. 	 * typedef struct {

  1730. 	 * 	mach_msg_header_t Head;

  1731. 	 * 	NDR_record_t NDR;

  1732. 	 * 	kern_return_t RetCode;

  1733. 	 * } mig_reply_error_t;

  1734. 	 */

  1735. 

  1736. 	union {

  1737. 		Request In;

  1738. 		Reply Out;

  1739. 	} Mess;

  1740. 

  1741. 	Request *InP = &Mess.In;

  1742. 	Reply *Out0P = &Mess.Out;

  1743. 

  1744. 	mach_msg_return_t msg_result;

  1745. 

  1746. #ifdef	__MIG_check__Reply__rpc_jack_client_deactivate_t__defined

  1747. 	kern_return_t check_result;

  1748. #endif	/* __MIG_check__Reply__rpc_jack_client_deactivate_t__defined */

  1749. 

  1750. 	__DeclareSendRpc(1004, "rpc_jack_client_deactivate")

  1751. 

  1752. 	InP->NDR = NDR_record;

  1753. 

  1754. 	InP->refnum = refnum;

  1755. 

  1756. 	InP->Head.msgh_bits =

  1757. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  1758. 	/* msgh_size passed as argument */

  1759. 	InP->Head.msgh_request_port = server_port;

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

  1761. 	InP->Head.msgh_id = 1004;

  1762. 

  1763. 	__BeforeSendRpc(1004, "rpc_jack_client_deactivate")

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

  1765. 	__AfterSendRpc(1004, "rpc_jack_client_deactivate")

  1766. 	if (msg_result != MACH_MSG_SUCCESS) {

  1767. 		__MachMsgErrorWithoutTimeout(msg_result);

  1768. 		{ return msg_result; }

  1769. 	}

  1770. 

  1771. 

  1772. #if	defined(__MIG_check__Reply__rpc_jack_client_deactivate_t__defined)

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

  1774. 	if (check_result != MACH_MSG_SUCCESS)

  1775. 		{ return check_result; }

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

  1777. 

  1778. 	*result = Out0P->result;

  1779. 

  1780. 	return KERN_SUCCESS;

  1781.     }

  1782. }

  1783. 

  1784. #if ( __MigTypeCheck || __NDR_convert__ )

  1785. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  1786. #if !defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)

  1787. #define __MIG_check__Reply__rpc_jack_port_register_t__defined

  1788. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1789. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  1790. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1791. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \

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

  1793. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  1794. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined

  1795. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode(a, f) \

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

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

  1798. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */

  1799. 

  1800. 

  1801. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1802. #if	defined(__NDR_convert__int_rep__JackRPCEngine__unsigned__defined)

  1803. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1804. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1806. #elif	defined(__NDR_convert__int_rep__unsigned__defined)

  1807. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1808. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1810. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__uint32_t__defined)

  1811. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1812. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1814. #elif	defined(__NDR_convert__int_rep__uint32_t__defined)

  1815. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1816. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

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

  1819. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1820. 

  1821. 

  1822. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1823. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  1824. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1825. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1827. #elif	defined(__NDR_convert__int_rep__int__defined)

  1828. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1829. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1831. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  1832. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1833. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1835. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  1836. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined

  1837. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

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

  1840. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */

  1841. 

  1842. 

  1843. 

  1844. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1845. #if	defined(__NDR_convert__char_rep__JackRPCEngine__unsigned__defined)

  1846. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1847. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1849. #elif	defined(__NDR_convert__char_rep__unsigned__defined)

  1850. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1851. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1853. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__uint32_t__defined)

  1854. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1855. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1857. #elif	defined(__NDR_convert__char_rep__uint32_t__defined)

  1858. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1859. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

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

  1862. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1863. 

  1864. 

  1865. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1866. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  1867. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1868. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1870. #elif	defined(__NDR_convert__char_rep__int__defined)

  1871. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1872. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1874. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  1875. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1876. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1878. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  1879. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined

  1880. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

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

  1883. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */

  1884. 

  1885. 

  1886. 

  1887. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1888. #if	defined(__NDR_convert__float_rep__JackRPCEngine__unsigned__defined)

  1889. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1890. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1892. #elif	defined(__NDR_convert__float_rep__unsigned__defined)

  1893. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1894. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1896. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__uint32_t__defined)

  1897. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1898. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

  1900. #elif	defined(__NDR_convert__float_rep__uint32_t__defined)

  1901. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined

  1902. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index(a, f) \

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

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

  1905. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1906. 

  1907. 

  1908. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1909. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  1910. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1911. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1913. #elif	defined(__NDR_convert__float_rep__int__defined)

  1914. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1915. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1917. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  1918. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1919. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

  1921. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  1922. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined

  1923. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result(a, f) \

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

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

  1926. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */

  1927. 

  1928. 

  1929. 

  1930. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_register_t(__Reply__rpc_jack_port_register_t *Out0P)

  1931. {

  1932. 

  1933. 	typedef __Reply__rpc_jack_port_register_t __Reply;

  1934. #if	__MigTypeCheck

  1935. 	unsigned int msgh_size;

  1936. #endif	/* __MigTypeCheck */

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

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

  1939. 		{ return MIG_SERVER_DIED; }

  1940. 	    else

  1941. 		{ return MIG_REPLY_MISMATCH; }

  1942. 	}

  1943. 

  1944. #if	__MigTypeCheck

  1945. 	msgh_size = Out0P->Head.msgh_size;

  1946. 

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

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

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

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

  1951. 		{ return MIG_TYPE_ERROR ; }

  1952. #endif	/* __MigTypeCheck */

  1953. 

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

  1955. #ifdef	__NDR_convert__mig_reply_error_t__defined

  1956. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  1957. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  1959. 	}

  1960. 

  1961. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined) || \

  1962. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1963. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1965. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined)

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

  1967. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__RetCode__defined */

  1968. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined)

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

  1970. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1971. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1973. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_register_t__result__defined */

  1974. 	}

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

  1976. 

  1977. #if	0 || \

  1978. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1979. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1981. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined)

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

  1983. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1984. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1986. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_register_t__result__defined */

  1987. 	}

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

  1989. 

  1990. #if	0 || \

  1991. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined) || \

  1992. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1994. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined)

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

  1996. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__port_index__defined */

  1997. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined)

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

  1999. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_register_t__result__defined */

  2000. 	}

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

  2002. 

  2003. 	return MACH_MSG_SUCCESS;

  2004. }

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

  2006. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  2008. 

  2009. 

  2010. /* Routine rpc_jack_port_register */

  2011. mig_external kern_return_t rpc_jack_port_register

  2012. (

  2013. 	mach_port_t server_port,

  2014. 	int refnum,

  2015. 	client_port_name_t name,

  2016. 	unsigned flags,

  2017. 	unsigned buffer_size,

  2018. 	unsigned *port_index,

  2019. 	int *result

  2020. )

  2021. {

  2022.     {

  2023. 

  2024. #ifdef  __MigPackStructs

  2025. #pragma pack(4)

  2026. #endif

  2027. 	typedef struct {

  2028. 		mach_msg_header_t Head;

  2029. 		NDR_record_t NDR;

  2030. 		int refnum;

  2031. 		client_port_name_t name;

  2032. 		unsigned flags;

  2033. 		unsigned buffer_size;

  2034. 	} Request;

  2035. #ifdef  __MigPackStructs

  2036. #pragma pack()

  2037. #endif

  2038. 

  2039. #ifdef  __MigPackStructs

  2040. #pragma pack(4)

  2041. #endif

  2042. 	typedef struct {

  2043. 		mach_msg_header_t Head;

  2044. 		NDR_record_t NDR;

  2045. 		kern_return_t RetCode;

  2046. 		unsigned port_index;

  2047. 		int result;

  2048. 		mach_msg_trailer_t trailer;

  2049. 	} Reply;

  2050. #ifdef  __MigPackStructs

  2051. #pragma pack()

  2052. #endif

  2053. 

  2054. #ifdef  __MigPackStructs

  2055. #pragma pack(4)

  2056. #endif

  2057. 	typedef struct {

  2058. 		mach_msg_header_t Head;

  2059. 		NDR_record_t NDR;

  2060. 		kern_return_t RetCode;

  2061. 		unsigned port_index;

  2062. 		int result;

  2063. 	} __Reply;

  2064. #ifdef  __MigPackStructs

  2065. #pragma pack()

  2066. #endif

  2067. 	/*

  2068. 	 * typedef struct {

  2069. 	 * 	mach_msg_header_t Head;

  2070. 	 * 	NDR_record_t NDR;

  2071. 	 * 	kern_return_t RetCode;

  2072. 	 * } mig_reply_error_t;

  2073. 	 */

  2074. 

  2075. 	union {

  2076. 		Request In;

  2077. 		Reply Out;

  2078. 	} Mess;

  2079. 

  2080. 	Request *InP = &Mess.In;

  2081. 	Reply *Out0P = &Mess.Out;

  2082. 

  2083. 	mach_msg_return_t msg_result;

  2084. 

  2085. #ifdef	__MIG_check__Reply__rpc_jack_port_register_t__defined

  2086. 	kern_return_t check_result;

  2087. #endif	/* __MIG_check__Reply__rpc_jack_port_register_t__defined */

  2088. 

  2089. 	__DeclareSendRpc(1005, "rpc_jack_port_register")

  2090. 

  2091. 	InP->NDR = NDR_record;

  2092. 

  2093. 	InP->refnum = refnum;

  2094. 

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

  2096. 

  2097. 	InP->flags = flags;

  2098. 

  2099. 	InP->buffer_size = buffer_size;

  2100. 

  2101. 	InP->Head.msgh_bits =

  2102. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2103. 	/* msgh_size passed as argument */

  2104. 	InP->Head.msgh_request_port = server_port;

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

  2106. 	InP->Head.msgh_id = 1005;

  2107. 

  2108. 	__BeforeSendRpc(1005, "rpc_jack_port_register")

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

  2110. 	__AfterSendRpc(1005, "rpc_jack_port_register")

  2111. 	if (msg_result != MACH_MSG_SUCCESS) {

  2112. 		__MachMsgErrorWithoutTimeout(msg_result);

  2113. 		{ return msg_result; }

  2114. 	}

  2115. 

  2116. 

  2117. #if	defined(__MIG_check__Reply__rpc_jack_port_register_t__defined)

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

  2119. 	if (check_result != MACH_MSG_SUCCESS)

  2120. 		{ return check_result; }

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

  2122. 

  2123. 	*port_index = Out0P->port_index;

  2124. 

  2125. 	*result = Out0P->result;

  2126. 

  2127. 	return KERN_SUCCESS;

  2128.     }

  2129. }

  2130. 

  2131. #if ( __MigTypeCheck || __NDR_convert__ )

  2132. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2133. #if !defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)

  2134. #define __MIG_check__Reply__rpc_jack_port_unregister_t__defined

  2135. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  2136. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2137. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  2138. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \

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

  2140. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2141. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined

  2142. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode(a, f) \

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

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

  2145. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */

  2146. 

  2147. 

  2148. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2149. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2150. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2151. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2153. #elif	defined(__NDR_convert__int_rep__int__defined)

  2154. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2155. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2157. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2158. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2159. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2161. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2162. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2163. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

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

  2166. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2167. 

  2168. 

  2169. 

  2170. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2171. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2172. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2173. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2175. #elif	defined(__NDR_convert__char_rep__int__defined)

  2176. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2177. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2179. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2180. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2181. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2183. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2184. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2185. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

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

  2188. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2189. 

  2190. 

  2191. 

  2192. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2193. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2194. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2195. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2197. #elif	defined(__NDR_convert__float_rep__int__defined)

  2198. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2199. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2201. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2202. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2203. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

  2205. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2206. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined

  2207. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result(a, f) \

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

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

  2210. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2211. 

  2212. 

  2213. 

  2214. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_unregister_t(__Reply__rpc_jack_port_unregister_t *Out0P)

  2215. {

  2216. 

  2217. 	typedef __Reply__rpc_jack_port_unregister_t __Reply;

  2218. #if	__MigTypeCheck

  2219. 	unsigned int msgh_size;

  2220. #endif	/* __MigTypeCheck */

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

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

  2223. 		{ return MIG_SERVER_DIED; }

  2224. 	    else

  2225. 		{ return MIG_REPLY_MISMATCH; }

  2226. 	}

  2227. 

  2228. #if	__MigTypeCheck

  2229. 	msgh_size = Out0P->Head.msgh_size;

  2230. 

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

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

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

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

  2235. 		{ return MIG_TYPE_ERROR ; }

  2236. #endif	/* __MigTypeCheck */

  2237. 

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

  2239. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2240. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2241. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  2243. 	}

  2244. 

  2245. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined) || \

  2246. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2248. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined)

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

  2250. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__RetCode__defined */

  2251. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2253. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2254. 	}

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

  2256. 

  2257. #if	0 || \

  2258. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2260. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2262. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2263. 	}

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

  2265. 

  2266. #if	0 || \

  2267. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2269. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined)

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

  2271. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_unregister_t__result__defined */

  2272. 	}

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

  2274. 

  2275. 	return MACH_MSG_SUCCESS;

  2276. }

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

  2278. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  2280. 

  2281. 

  2282. /* Routine rpc_jack_port_unregister */

  2283. mig_external kern_return_t rpc_jack_port_unregister

  2284. (

  2285. 	mach_port_t server_port,

  2286. 	int refnum,

  2287. 	int port,

  2288. 	int *result

  2289. )

  2290. {

  2291.     {

  2292. 

  2293. #ifdef  __MigPackStructs

  2294. #pragma pack(4)

  2295. #endif

  2296. 	typedef struct {

  2297. 		mach_msg_header_t Head;

  2298. 		NDR_record_t NDR;

  2299. 		int refnum;

  2300. 		int port;

  2301. 	} Request;

  2302. #ifdef  __MigPackStructs

  2303. #pragma pack()

  2304. #endif

  2305. 

  2306. #ifdef  __MigPackStructs

  2307. #pragma pack(4)

  2308. #endif

  2309. 	typedef struct {

  2310. 		mach_msg_header_t Head;

  2311. 		NDR_record_t NDR;

  2312. 		kern_return_t RetCode;

  2313. 		int result;

  2314. 		mach_msg_trailer_t trailer;

  2315. 	} Reply;

  2316. #ifdef  __MigPackStructs

  2317. #pragma pack()

  2318. #endif

  2319. 

  2320. #ifdef  __MigPackStructs

  2321. #pragma pack(4)

  2322. #endif

  2323. 	typedef struct {

  2324. 		mach_msg_header_t Head;

  2325. 		NDR_record_t NDR;

  2326. 		kern_return_t RetCode;

  2327. 		int result;

  2328. 	} __Reply;

  2329. #ifdef  __MigPackStructs

  2330. #pragma pack()

  2331. #endif

  2332. 	/*

  2333. 	 * typedef struct {

  2334. 	 * 	mach_msg_header_t Head;

  2335. 	 * 	NDR_record_t NDR;

  2336. 	 * 	kern_return_t RetCode;

  2337. 	 * } mig_reply_error_t;

  2338. 	 */

  2339. 

  2340. 	union {

  2341. 		Request In;

  2342. 		Reply Out;

  2343. 	} Mess;

  2344. 

  2345. 	Request *InP = &Mess.In;

  2346. 	Reply *Out0P = &Mess.Out;

  2347. 

  2348. 	mach_msg_return_t msg_result;

  2349. 

  2350. #ifdef	__MIG_check__Reply__rpc_jack_port_unregister_t__defined

  2351. 	kern_return_t check_result;

  2352. #endif	/* __MIG_check__Reply__rpc_jack_port_unregister_t__defined */

  2353. 

  2354. 	__DeclareSendRpc(1006, "rpc_jack_port_unregister")

  2355. 

  2356. 	InP->NDR = NDR_record;

  2357. 

  2358. 	InP->refnum = refnum;

  2359. 

  2360. 	InP->port = port;

  2361. 

  2362. 	InP->Head.msgh_bits =

  2363. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2364. 	/* msgh_size passed as argument */

  2365. 	InP->Head.msgh_request_port = server_port;

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

  2367. 	InP->Head.msgh_id = 1006;

  2368. 

  2369. 	__BeforeSendRpc(1006, "rpc_jack_port_unregister")

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

  2371. 	__AfterSendRpc(1006, "rpc_jack_port_unregister")

  2372. 	if (msg_result != MACH_MSG_SUCCESS) {

  2373. 		__MachMsgErrorWithoutTimeout(msg_result);

  2374. 		{ return msg_result; }

  2375. 	}

  2376. 

  2377. 

  2378. #if	defined(__MIG_check__Reply__rpc_jack_port_unregister_t__defined)

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

  2380. 	if (check_result != MACH_MSG_SUCCESS)

  2381. 		{ return check_result; }

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

  2383. 

  2384. 	*result = Out0P->result;

  2385. 

  2386. 	return KERN_SUCCESS;

  2387.     }

  2388. }

  2389. 

  2390. #if ( __MigTypeCheck || __NDR_convert__ )

  2391. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2392. #if !defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)

  2393. #define __MIG_check__Reply__rpc_jack_port_connect_t__defined

  2394. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  2395. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2396. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  2397. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \

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

  2399. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2400. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined

  2401. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode(a, f) \

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

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

  2404. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */

  2405. 

  2406. 

  2407. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2408. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2409. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2410. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2412. #elif	defined(__NDR_convert__int_rep__int__defined)

  2413. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2414. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2416. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2417. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2418. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2420. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2421. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined

  2422. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

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

  2425. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2426. 

  2427. 

  2428. 

  2429. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2430. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2431. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2432. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2434. #elif	defined(__NDR_convert__char_rep__int__defined)

  2435. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2436. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2438. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2439. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2440. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2442. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2443. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined

  2444. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

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

  2447. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2448. 

  2449. 

  2450. 

  2451. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2452. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2453. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2454. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2456. #elif	defined(__NDR_convert__float_rep__int__defined)

  2457. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2458. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2460. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2461. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2462. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

  2464. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2465. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined

  2466. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result(a, f) \

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

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

  2469. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2470. 

  2471. 

  2472. 

  2473. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_t(__Reply__rpc_jack_port_connect_t *Out0P)

  2474. {

  2475. 

  2476. 	typedef __Reply__rpc_jack_port_connect_t __Reply;

  2477. #if	__MigTypeCheck

  2478. 	unsigned int msgh_size;

  2479. #endif	/* __MigTypeCheck */

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

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

  2482. 		{ return MIG_SERVER_DIED; }

  2483. 	    else

  2484. 		{ return MIG_REPLY_MISMATCH; }

  2485. 	}

  2486. 

  2487. #if	__MigTypeCheck

  2488. 	msgh_size = Out0P->Head.msgh_size;

  2489. 

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

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

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

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

  2494. 		{ return MIG_TYPE_ERROR ; }

  2495. #endif	/* __MigTypeCheck */

  2496. 

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

  2498. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2499. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2500. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  2502. 	}

  2503. 

  2504. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined) || \

  2505. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2507. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined)

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

  2509. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__RetCode__defined */

  2510. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2512. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2513. 	}

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

  2515. 

  2516. #if	0 || \

  2517. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2519. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2521. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2522. 	}

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

  2524. 

  2525. #if	0 || \

  2526. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2528. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined)

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

  2530. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_t__result__defined */

  2531. 	}

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

  2533. 

  2534. 	return MACH_MSG_SUCCESS;

  2535. }

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

  2537. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  2539. 

  2540. 

  2541. /* Routine rpc_jack_port_connect */

  2542. mig_external kern_return_t rpc_jack_port_connect

  2543. (

  2544. 	mach_port_t server_port,

  2545. 	int refnum,

  2546. 	int src,

  2547. 	int dst,

  2548. 	int *result

  2549. )

  2550. {

  2551.     {

  2552. 

  2553. #ifdef  __MigPackStructs

  2554. #pragma pack(4)

  2555. #endif

  2556. 	typedef struct {

  2557. 		mach_msg_header_t Head;

  2558. 		NDR_record_t NDR;

  2559. 		int refnum;

  2560. 		int src;

  2561. 		int dst;

  2562. 	} Request;

  2563. #ifdef  __MigPackStructs

  2564. #pragma pack()

  2565. #endif

  2566. 

  2567. #ifdef  __MigPackStructs

  2568. #pragma pack(4)

  2569. #endif

  2570. 	typedef struct {

  2571. 		mach_msg_header_t Head;

  2572. 		NDR_record_t NDR;

  2573. 		kern_return_t RetCode;

  2574. 		int result;

  2575. 		mach_msg_trailer_t trailer;

  2576. 	} Reply;

  2577. #ifdef  __MigPackStructs

  2578. #pragma pack()

  2579. #endif

  2580. 

  2581. #ifdef  __MigPackStructs

  2582. #pragma pack(4)

  2583. #endif

  2584. 	typedef struct {

  2585. 		mach_msg_header_t Head;

  2586. 		NDR_record_t NDR;

  2587. 		kern_return_t RetCode;

  2588. 		int result;

  2589. 	} __Reply;

  2590. #ifdef  __MigPackStructs

  2591. #pragma pack()

  2592. #endif

  2593. 	/*

  2594. 	 * typedef struct {

  2595. 	 * 	mach_msg_header_t Head;

  2596. 	 * 	NDR_record_t NDR;

  2597. 	 * 	kern_return_t RetCode;

  2598. 	 * } mig_reply_error_t;

  2599. 	 */

  2600. 

  2601. 	union {

  2602. 		Request In;

  2603. 		Reply Out;

  2604. 	} Mess;

  2605. 

  2606. 	Request *InP = &Mess.In;

  2607. 	Reply *Out0P = &Mess.Out;

  2608. 

  2609. 	mach_msg_return_t msg_result;

  2610. 

  2611. #ifdef	__MIG_check__Reply__rpc_jack_port_connect_t__defined

  2612. 	kern_return_t check_result;

  2613. #endif	/* __MIG_check__Reply__rpc_jack_port_connect_t__defined */

  2614. 

  2615. 	__DeclareSendRpc(1007, "rpc_jack_port_connect")

  2616. 

  2617. 	InP->NDR = NDR_record;

  2618. 

  2619. 	InP->refnum = refnum;

  2620. 

  2621. 	InP->src = src;

  2622. 

  2623. 	InP->dst = dst;

  2624. 

  2625. 	InP->Head.msgh_bits =

  2626. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2627. 	/* msgh_size passed as argument */

  2628. 	InP->Head.msgh_request_port = server_port;

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

  2630. 	InP->Head.msgh_id = 1007;

  2631. 

  2632. 	__BeforeSendRpc(1007, "rpc_jack_port_connect")

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

  2634. 	__AfterSendRpc(1007, "rpc_jack_port_connect")

  2635. 	if (msg_result != MACH_MSG_SUCCESS) {

  2636. 		__MachMsgErrorWithoutTimeout(msg_result);

  2637. 		{ return msg_result; }

  2638. 	}

  2639. 

  2640. 

  2641. #if	defined(__MIG_check__Reply__rpc_jack_port_connect_t__defined)

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

  2643. 	if (check_result != MACH_MSG_SUCCESS)

  2644. 		{ return check_result; }

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

  2646. 

  2647. 	*result = Out0P->result;

  2648. 

  2649. 	return KERN_SUCCESS;

  2650.     }

  2651. }

  2652. 

  2653. #if ( __MigTypeCheck || __NDR_convert__ )

  2654. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2655. #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)

  2656. #define __MIG_check__Reply__rpc_jack_port_disconnect_t__defined

  2657. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2658. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2659. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2660. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \

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

  2662. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2663. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined

  2664. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode(a, f) \

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

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

  2667. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */

  2668. 

  2669. 

  2670. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2671. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2672. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2673. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2675. #elif	defined(__NDR_convert__int_rep__int__defined)

  2676. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2677. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2679. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2680. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2681. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2683. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2684. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2685. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

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

  2688. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2689. 

  2690. 

  2691. 

  2692. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2693. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2694. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2695. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2697. #elif	defined(__NDR_convert__char_rep__int__defined)

  2698. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2699. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2701. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2702. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2703. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2705. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2706. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2707. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

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

  2710. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2711. 

  2712. 

  2713. 

  2714. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2715. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2716. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2717. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2719. #elif	defined(__NDR_convert__float_rep__int__defined)

  2720. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2721. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2723. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2724. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2725. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

  2727. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2728. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined

  2729. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result(a, f) \

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

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

  2732. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2733. 

  2734. 

  2735. 

  2736. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_t(__Reply__rpc_jack_port_disconnect_t *Out0P)

  2737. {

  2738. 

  2739. 	typedef __Reply__rpc_jack_port_disconnect_t __Reply;

  2740. #if	__MigTypeCheck

  2741. 	unsigned int msgh_size;

  2742. #endif	/* __MigTypeCheck */

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

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

  2745. 		{ return MIG_SERVER_DIED; }

  2746. 	    else

  2747. 		{ return MIG_REPLY_MISMATCH; }

  2748. 	}

  2749. 

  2750. #if	__MigTypeCheck

  2751. 	msgh_size = Out0P->Head.msgh_size;

  2752. 

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

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

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

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

  2757. 		{ return MIG_TYPE_ERROR ; }

  2758. #endif	/* __MigTypeCheck */

  2759. 

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

  2761. #ifdef	__NDR_convert__mig_reply_error_t__defined

  2762. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  2763. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  2765. 	}

  2766. 

  2767. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined) || \

  2768. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2770. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined)

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

  2772. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__RetCode__defined */

  2773. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2775. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2776. 	}

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

  2778. 

  2779. #if	0 || \

  2780. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2782. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2784. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2785. 	}

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

  2787. 

  2788. #if	0 || \

  2789. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2791. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined)

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

  2793. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_t__result__defined */

  2794. 	}

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

  2796. 

  2797. 	return MACH_MSG_SUCCESS;

  2798. }

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

  2800. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  2802. 

  2803. 

  2804. /* Routine rpc_jack_port_disconnect */

  2805. mig_external kern_return_t rpc_jack_port_disconnect

  2806. (

  2807. 	mach_port_t server_port,

  2808. 	int refnum,

  2809. 	int src,

  2810. 	int dst,

  2811. 	int *result

  2812. )

  2813. {

  2814.     {

  2815. 

  2816. #ifdef  __MigPackStructs

  2817. #pragma pack(4)

  2818. #endif

  2819. 	typedef struct {

  2820. 		mach_msg_header_t Head;

  2821. 		NDR_record_t NDR;

  2822. 		int refnum;

  2823. 		int src;

  2824. 		int dst;

  2825. 	} Request;

  2826. #ifdef  __MigPackStructs

  2827. #pragma pack()

  2828. #endif

  2829. 

  2830. #ifdef  __MigPackStructs

  2831. #pragma pack(4)

  2832. #endif

  2833. 	typedef struct {

  2834. 		mach_msg_header_t Head;

  2835. 		NDR_record_t NDR;

  2836. 		kern_return_t RetCode;

  2837. 		int result;

  2838. 		mach_msg_trailer_t trailer;

  2839. 	} Reply;

  2840. #ifdef  __MigPackStructs

  2841. #pragma pack()

  2842. #endif

  2843. 

  2844. #ifdef  __MigPackStructs

  2845. #pragma pack(4)

  2846. #endif

  2847. 	typedef struct {

  2848. 		mach_msg_header_t Head;

  2849. 		NDR_record_t NDR;

  2850. 		kern_return_t RetCode;

  2851. 		int result;

  2852. 	} __Reply;

  2853. #ifdef  __MigPackStructs

  2854. #pragma pack()

  2855. #endif

  2856. 	/*

  2857. 	 * typedef struct {

  2858. 	 * 	mach_msg_header_t Head;

  2859. 	 * 	NDR_record_t NDR;

  2860. 	 * 	kern_return_t RetCode;

  2861. 	 * } mig_reply_error_t;

  2862. 	 */

  2863. 

  2864. 	union {

  2865. 		Request In;

  2866. 		Reply Out;

  2867. 	} Mess;

  2868. 

  2869. 	Request *InP = &Mess.In;

  2870. 	Reply *Out0P = &Mess.Out;

  2871. 

  2872. 	mach_msg_return_t msg_result;

  2873. 

  2874. #ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_t__defined

  2875. 	kern_return_t check_result;

  2876. #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_t__defined */

  2877. 

  2878. 	__DeclareSendRpc(1008, "rpc_jack_port_disconnect")

  2879. 

  2880. 	InP->NDR = NDR_record;

  2881. 

  2882. 	InP->refnum = refnum;

  2883. 

  2884. 	InP->src = src;

  2885. 

  2886. 	InP->dst = dst;

  2887. 

  2888. 	InP->Head.msgh_bits =

  2889. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  2890. 	/* msgh_size passed as argument */

  2891. 	InP->Head.msgh_request_port = server_port;

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

  2893. 	InP->Head.msgh_id = 1008;

  2894. 

  2895. 	__BeforeSendRpc(1008, "rpc_jack_port_disconnect")

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

  2897. 	__AfterSendRpc(1008, "rpc_jack_port_disconnect")

  2898. 	if (msg_result != MACH_MSG_SUCCESS) {

  2899. 		__MachMsgErrorWithoutTimeout(msg_result);

  2900. 		{ return msg_result; }

  2901. 	}

  2902. 

  2903. 

  2904. #if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_t__defined)

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

  2906. 	if (check_result != MACH_MSG_SUCCESS)

  2907. 		{ return check_result; }

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

  2909. 

  2910. 	*result = Out0P->result;

  2911. 

  2912. 	return KERN_SUCCESS;

  2913.     }

  2914. }

  2915. 

  2916. #if ( __MigTypeCheck || __NDR_convert__ )

  2917. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  2918. #if !defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)

  2919. #define __MIG_check__Reply__rpc_jack_port_connect_name_t__defined

  2920. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2921. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  2922. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2923. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \

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

  2925. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  2926. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined

  2927. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode(a, f) \

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

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

  2930. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */

  2931. 

  2932. 

  2933. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2934. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  2935. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2936. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2938. #elif	defined(__NDR_convert__int_rep__int__defined)

  2939. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2940. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2942. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  2943. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2944. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2946. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  2947. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2948. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

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

  2951. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2952. 

  2953. 

  2954. 

  2955. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2956. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  2957. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2958. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2960. #elif	defined(__NDR_convert__char_rep__int__defined)

  2961. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2962. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2964. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  2965. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2966. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2968. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  2969. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2970. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

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

  2973. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2974. 

  2975. 

  2976. 

  2977. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2978. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  2979. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2980. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2982. #elif	defined(__NDR_convert__float_rep__int__defined)

  2983. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2984. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2986. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  2987. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2988. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

  2990. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  2991. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined

  2992. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result(a, f) \

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

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

  2995. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  2996. 

  2997. 

  2998. 

  2999. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_connect_name_t(__Reply__rpc_jack_port_connect_name_t *Out0P)

  3000. {

  3001. 

  3002. 	typedef __Reply__rpc_jack_port_connect_name_t __Reply;

  3003. #if	__MigTypeCheck

  3004. 	unsigned int msgh_size;

  3005. #endif	/* __MigTypeCheck */

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

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

  3008. 		{ return MIG_SERVER_DIED; }

  3009. 	    else

  3010. 		{ return MIG_REPLY_MISMATCH; }

  3011. 	}

  3012. 

  3013. #if	__MigTypeCheck

  3014. 	msgh_size = Out0P->Head.msgh_size;

  3015. 

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

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

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

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

  3020. 		{ return MIG_TYPE_ERROR ; }

  3021. #endif	/* __MigTypeCheck */

  3022. 

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

  3024. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3025. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3026. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  3028. 	}

  3029. 

  3030. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined) || \

  3031. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3033. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined)

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

  3035. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__RetCode__defined */

  3036. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3038. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  3039. 	}

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

  3041. 

  3042. #if	0 || \

  3043. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3045. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3047. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  3048. 	}

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

  3050. 

  3051. #if	0 || \

  3052. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3054. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined)

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

  3056. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_connect_name_t__result__defined */

  3057. 	}

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

  3059. 

  3060. 	return MACH_MSG_SUCCESS;

  3061. }

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

  3063. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  3065. 

  3066. 

  3067. /* Routine rpc_jack_port_connect_name */

  3068. mig_external kern_return_t rpc_jack_port_connect_name

  3069. (

  3070. 	mach_port_t server_port,

  3071. 	int refnum,

  3072. 	client_port_name_t src,

  3073. 	client_port_name_t dst,

  3074. 	int *result

  3075. )

  3076. {

  3077.     {

  3078. 

  3079. #ifdef  __MigPackStructs

  3080. #pragma pack(4)

  3081. #endif

  3082. 	typedef struct {

  3083. 		mach_msg_header_t Head;

  3084. 		NDR_record_t NDR;

  3085. 		int refnum;

  3086. 		client_port_name_t src;

  3087. 		client_port_name_t dst;

  3088. 	} Request;

  3089. #ifdef  __MigPackStructs

  3090. #pragma pack()

  3091. #endif

  3092. 

  3093. #ifdef  __MigPackStructs

  3094. #pragma pack(4)

  3095. #endif

  3096. 	typedef struct {

  3097. 		mach_msg_header_t Head;

  3098. 		NDR_record_t NDR;

  3099. 		kern_return_t RetCode;

  3100. 		int result;

  3101. 		mach_msg_trailer_t trailer;

  3102. 	} Reply;

  3103. #ifdef  __MigPackStructs

  3104. #pragma pack()

  3105. #endif

  3106. 

  3107. #ifdef  __MigPackStructs

  3108. #pragma pack(4)

  3109. #endif

  3110. 	typedef struct {

  3111. 		mach_msg_header_t Head;

  3112. 		NDR_record_t NDR;

  3113. 		kern_return_t RetCode;

  3114. 		int result;

  3115. 	} __Reply;

  3116. #ifdef  __MigPackStructs

  3117. #pragma pack()

  3118. #endif

  3119. 	/*

  3120. 	 * typedef struct {

  3121. 	 * 	mach_msg_header_t Head;

  3122. 	 * 	NDR_record_t NDR;

  3123. 	 * 	kern_return_t RetCode;

  3124. 	 * } mig_reply_error_t;

  3125. 	 */

  3126. 

  3127. 	union {

  3128. 		Request In;

  3129. 		Reply Out;

  3130. 	} Mess;

  3131. 

  3132. 	Request *InP = &Mess.In;

  3133. 	Reply *Out0P = &Mess.Out;

  3134. 

  3135. 	mach_msg_return_t msg_result;

  3136. 

  3137. #ifdef	__MIG_check__Reply__rpc_jack_port_connect_name_t__defined

  3138. 	kern_return_t check_result;

  3139. #endif	/* __MIG_check__Reply__rpc_jack_port_connect_name_t__defined */

  3140. 

  3141. 	__DeclareSendRpc(1009, "rpc_jack_port_connect_name")

  3142. 

  3143. 	InP->NDR = NDR_record;

  3144. 

  3145. 	InP->refnum = refnum;

  3146. 

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

  3148. 

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

  3150. 

  3151. 	InP->Head.msgh_bits =

  3152. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3153. 	/* msgh_size passed as argument */

  3154. 	InP->Head.msgh_request_port = server_port;

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

  3156. 	InP->Head.msgh_id = 1009;

  3157. 

  3158. 	__BeforeSendRpc(1009, "rpc_jack_port_connect_name")

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

  3160. 	__AfterSendRpc(1009, "rpc_jack_port_connect_name")

  3161. 	if (msg_result != MACH_MSG_SUCCESS) {

  3162. 		__MachMsgErrorWithoutTimeout(msg_result);

  3163. 		{ return msg_result; }

  3164. 	}

  3165. 

  3166. 

  3167. #if	defined(__MIG_check__Reply__rpc_jack_port_connect_name_t__defined)

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

  3169. 	if (check_result != MACH_MSG_SUCCESS)

  3170. 		{ return check_result; }

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

  3172. 

  3173. 	*result = Out0P->result;

  3174. 

  3175. 	return KERN_SUCCESS;

  3176.     }

  3177. }

  3178. 

  3179. #if ( __MigTypeCheck || __NDR_convert__ )

  3180. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3181. #if !defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)

  3182. #define __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined

  3183. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  3184. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3185. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  3186. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \

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

  3188. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3189. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined

  3190. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode(a, f) \

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

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

  3193. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */

  3194. 

  3195. 

  3196. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3197. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3198. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3199. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3201. #elif	defined(__NDR_convert__int_rep__int__defined)

  3202. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3203. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3205. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3206. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3207. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3209. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3210. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3211. #define	__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

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

  3214. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3215. 

  3216. 

  3217. 

  3218. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3219. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3220. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3221. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3223. #elif	defined(__NDR_convert__char_rep__int__defined)

  3224. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3225. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3227. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3228. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3229. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3231. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3232. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3233. #define	__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

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

  3236. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3237. 

  3238. 

  3239. 

  3240. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3241. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3242. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3243. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3245. #elif	defined(__NDR_convert__float_rep__int__defined)

  3246. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3247. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3249. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3250. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3251. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

  3253. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3254. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined

  3255. #define	__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result(a, f) \

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

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

  3258. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3259. 

  3260. 

  3261. 

  3262. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_disconnect_name_t(__Reply__rpc_jack_port_disconnect_name_t *Out0P)

  3263. {

  3264. 

  3265. 	typedef __Reply__rpc_jack_port_disconnect_name_t __Reply;

  3266. #if	__MigTypeCheck

  3267. 	unsigned int msgh_size;

  3268. #endif	/* __MigTypeCheck */

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

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

  3271. 		{ return MIG_SERVER_DIED; }

  3272. 	    else

  3273. 		{ return MIG_REPLY_MISMATCH; }

  3274. 	}

  3275. 

  3276. #if	__MigTypeCheck

  3277. 	msgh_size = Out0P->Head.msgh_size;

  3278. 

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

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

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

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

  3283. 		{ return MIG_TYPE_ERROR ; }

  3284. #endif	/* __MigTypeCheck */

  3285. 

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

  3287. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3288. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3289. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  3291. 	}

  3292. 

  3293. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined) || \

  3294. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3296. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined)

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

  3298. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__RetCode__defined */

  3299. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3301. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3302. 	}

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

  3304. 

  3305. #if	0 || \

  3306. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3308. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3310. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3311. 	}

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

  3313. 

  3314. #if	0 || \

  3315. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3317. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined)

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

  3319. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_disconnect_name_t__result__defined */

  3320. 	}

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

  3322. 

  3323. 	return MACH_MSG_SUCCESS;

  3324. }

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

  3326. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  3328. 

  3329. 

  3330. /* Routine rpc_jack_port_disconnect_name */

  3331. mig_external kern_return_t rpc_jack_port_disconnect_name

  3332. (

  3333. 	mach_port_t server_port,

  3334. 	int refnum,

  3335. 	client_port_name_t src,

  3336. 	client_port_name_t dst,

  3337. 	int *result

  3338. )

  3339. {

  3340.     {

  3341. 

  3342. #ifdef  __MigPackStructs

  3343. #pragma pack(4)

  3344. #endif

  3345. 	typedef struct {

  3346. 		mach_msg_header_t Head;

  3347. 		NDR_record_t NDR;

  3348. 		int refnum;

  3349. 		client_port_name_t src;

  3350. 		client_port_name_t dst;

  3351. 	} Request;

  3352. #ifdef  __MigPackStructs

  3353. #pragma pack()

  3354. #endif

  3355. 

  3356. #ifdef  __MigPackStructs

  3357. #pragma pack(4)

  3358. #endif

  3359. 	typedef struct {

  3360. 		mach_msg_header_t Head;

  3361. 		NDR_record_t NDR;

  3362. 		kern_return_t RetCode;

  3363. 		int result;

  3364. 		mach_msg_trailer_t trailer;

  3365. 	} Reply;

  3366. #ifdef  __MigPackStructs

  3367. #pragma pack()

  3368. #endif

  3369. 

  3370. #ifdef  __MigPackStructs

  3371. #pragma pack(4)

  3372. #endif

  3373. 	typedef struct {

  3374. 		mach_msg_header_t Head;

  3375. 		NDR_record_t NDR;

  3376. 		kern_return_t RetCode;

  3377. 		int result;

  3378. 	} __Reply;

  3379. #ifdef  __MigPackStructs

  3380. #pragma pack()

  3381. #endif

  3382. 	/*

  3383. 	 * typedef struct {

  3384. 	 * 	mach_msg_header_t Head;

  3385. 	 * 	NDR_record_t NDR;

  3386. 	 * 	kern_return_t RetCode;

  3387. 	 * } mig_reply_error_t;

  3388. 	 */

  3389. 

  3390. 	union {

  3391. 		Request In;

  3392. 		Reply Out;

  3393. 	} Mess;

  3394. 

  3395. 	Request *InP = &Mess.In;

  3396. 	Reply *Out0P = &Mess.Out;

  3397. 

  3398. 	mach_msg_return_t msg_result;

  3399. 

  3400. #ifdef	__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined

  3401. 	kern_return_t check_result;

  3402. #endif	/* __MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined */

  3403. 

  3404. 	__DeclareSendRpc(1010, "rpc_jack_port_disconnect_name")

  3405. 

  3406. 	InP->NDR = NDR_record;

  3407. 

  3408. 	InP->refnum = refnum;

  3409. 

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

  3411. 

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

  3413. 

  3414. 	InP->Head.msgh_bits =

  3415. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3416. 	/* msgh_size passed as argument */

  3417. 	InP->Head.msgh_request_port = server_port;

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

  3419. 	InP->Head.msgh_id = 1010;

  3420. 

  3421. 	__BeforeSendRpc(1010, "rpc_jack_port_disconnect_name")

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

  3423. 	__AfterSendRpc(1010, "rpc_jack_port_disconnect_name")

  3424. 	if (msg_result != MACH_MSG_SUCCESS) {

  3425. 		__MachMsgErrorWithoutTimeout(msg_result);

  3426. 		{ return msg_result; }

  3427. 	}

  3428. 

  3429. 

  3430. #if	defined(__MIG_check__Reply__rpc_jack_port_disconnect_name_t__defined)

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

  3432. 	if (check_result != MACH_MSG_SUCCESS)

  3433. 		{ return check_result; }

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

  3435. 

  3436. 	*result = Out0P->result;

  3437. 

  3438. 	return KERN_SUCCESS;

  3439.     }

  3440. }

  3441. 

  3442. #if ( __MigTypeCheck || __NDR_convert__ )

  3443. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3444. #if !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)

  3445. #define __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined

  3446. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3447. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3448. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3449. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \

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

  3451. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3452. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined

  3453. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode(a, f) \

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

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

  3456. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */

  3457. 

  3458. 

  3459. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3460. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3461. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3462. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3464. #elif	defined(__NDR_convert__int_rep__int__defined)

  3465. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3466. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3468. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3469. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3470. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3472. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3473. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3474. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

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

  3477. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3478. 

  3479. 

  3480. 

  3481. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3482. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3483. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3484. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3486. #elif	defined(__NDR_convert__char_rep__int__defined)

  3487. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3488. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3490. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3491. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3492. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3494. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3495. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3496. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

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

  3499. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3500. 

  3501. 

  3502. 

  3503. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3504. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3505. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3506. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3508. #elif	defined(__NDR_convert__float_rep__int__defined)

  3509. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3510. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3512. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3513. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3514. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

  3516. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3517. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined

  3518. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result(a, f) \

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

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

  3521. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3522. 

  3523. 

  3524. 

  3525. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Reply__rpc_jack_set_buffer_size_t *Out0P)

  3526. {

  3527. 

  3528. 	typedef __Reply__rpc_jack_set_buffer_size_t __Reply;

  3529. #if	__MigTypeCheck

  3530. 	unsigned int msgh_size;

  3531. #endif	/* __MigTypeCheck */

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

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

  3534. 		{ return MIG_SERVER_DIED; }

  3535. 	    else

  3536. 		{ return MIG_REPLY_MISMATCH; }

  3537. 	}

  3538. 

  3539. #if	__MigTypeCheck

  3540. 	msgh_size = Out0P->Head.msgh_size;

  3541. 

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

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

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

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

  3546. 		{ return MIG_TYPE_ERROR ; }

  3547. #endif	/* __MigTypeCheck */

  3548. 

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

  3550. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3551. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3552. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  3554. 	}

  3555. 

  3556. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined) || \

  3557. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3559. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined)

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

  3561. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__RetCode__defined */

  3562. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3564. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3565. 	}

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

  3567. 

  3568. #if	0 || \

  3569. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3571. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3573. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3574. 	}

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

  3576. 

  3577. #if	0 || \

  3578. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3580. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined)

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

  3582. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_buffer_size_t__result__defined */

  3583. 	}

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

  3585. 

  3586. 	return MACH_MSG_SUCCESS;

  3587. }

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

  3589. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  3591. 

  3592. 

  3593. /* Routine rpc_jack_set_buffer_size */

  3594. mig_external kern_return_t rpc_jack_set_buffer_size

  3595. (

  3596. 	mach_port_t server_port,

  3597. 	int buffer_size,

  3598. 	int *result

  3599. )

  3600. {

  3601.     {

  3602. 

  3603. #ifdef  __MigPackStructs

  3604. #pragma pack(4)

  3605. #endif

  3606. 	typedef struct {

  3607. 		mach_msg_header_t Head;

  3608. 		NDR_record_t NDR;

  3609. 		int buffer_size;

  3610. 	} Request;

  3611. #ifdef  __MigPackStructs

  3612. #pragma pack()

  3613. #endif

  3614. 

  3615. #ifdef  __MigPackStructs

  3616. #pragma pack(4)

  3617. #endif

  3618. 	typedef struct {

  3619. 		mach_msg_header_t Head;

  3620. 		NDR_record_t NDR;

  3621. 		kern_return_t RetCode;

  3622. 		int result;

  3623. 		mach_msg_trailer_t trailer;

  3624. 	} Reply;

  3625. #ifdef  __MigPackStructs

  3626. #pragma pack()

  3627. #endif

  3628. 

  3629. #ifdef  __MigPackStructs

  3630. #pragma pack(4)

  3631. #endif

  3632. 	typedef struct {

  3633. 		mach_msg_header_t Head;

  3634. 		NDR_record_t NDR;

  3635. 		kern_return_t RetCode;

  3636. 		int result;

  3637. 	} __Reply;

  3638. #ifdef  __MigPackStructs

  3639. #pragma pack()

  3640. #endif

  3641. 	/*

  3642. 	 * typedef struct {

  3643. 	 * 	mach_msg_header_t Head;

  3644. 	 * 	NDR_record_t NDR;

  3645. 	 * 	kern_return_t RetCode;

  3646. 	 * } mig_reply_error_t;

  3647. 	 */

  3648. 

  3649. 	union {

  3650. 		Request In;

  3651. 		Reply Out;

  3652. 	} Mess;

  3653. 

  3654. 	Request *InP = &Mess.In;

  3655. 	Reply *Out0P = &Mess.Out;

  3656. 

  3657. 	mach_msg_return_t msg_result;

  3658. 

  3659. #ifdef	__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined

  3660. 	kern_return_t check_result;

  3661. #endif	/* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */

  3662. 

  3663. 	__DeclareSendRpc(1011, "rpc_jack_set_buffer_size")

  3664. 

  3665. 	InP->NDR = NDR_record;

  3666. 

  3667. 	InP->buffer_size = buffer_size;

  3668. 

  3669. 	InP->Head.msgh_bits =

  3670. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3671. 	/* msgh_size passed as argument */

  3672. 	InP->Head.msgh_request_port = server_port;

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

  3674. 	InP->Head.msgh_id = 1011;

  3675. 

  3676. 	__BeforeSendRpc(1011, "rpc_jack_set_buffer_size")

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

  3678. 	__AfterSendRpc(1011, "rpc_jack_set_buffer_size")

  3679. 	if (msg_result != MACH_MSG_SUCCESS) {

  3680. 		__MachMsgErrorWithoutTimeout(msg_result);

  3681. 		{ return msg_result; }

  3682. 	}

  3683. 

  3684. 

  3685. #if	defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)

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

  3687. 	if (check_result != MACH_MSG_SUCCESS)

  3688. 		{ return check_result; }

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

  3690. 

  3691. 	*result = Out0P->result;

  3692. 

  3693. 	return KERN_SUCCESS;

  3694.     }

  3695. }

  3696. 

  3697. #if ( __MigTypeCheck || __NDR_convert__ )

  3698. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3699. #if !defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)

  3700. #define __MIG_check__Reply__rpc_jack_set_freewheel_t__defined

  3701. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3702. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3703. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3704. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \

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

  3706. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3707. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined

  3708. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode(a, f) \

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

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

  3711. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */

  3712. 

  3713. 

  3714. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3715. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3716. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3717. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3719. #elif	defined(__NDR_convert__int_rep__int__defined)

  3720. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3721. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3723. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3724. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3725. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3727. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3728. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3729. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

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

  3732. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3733. 

  3734. 

  3735. 

  3736. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3737. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3738. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3739. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3741. #elif	defined(__NDR_convert__char_rep__int__defined)

  3742. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3743. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3745. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  3746. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3747. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3749. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  3750. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3751. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

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

  3754. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3755. 

  3756. 

  3757. 

  3758. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3759. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  3760. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3761. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3763. #elif	defined(__NDR_convert__float_rep__int__defined)

  3764. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3765. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3767. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  3768. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3769. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

  3771. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  3772. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined

  3773. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result(a, f) \

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

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

  3776. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3777. 

  3778. 

  3779. 

  3780. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply__rpc_jack_set_freewheel_t *Out0P)

  3781. {

  3782. 

  3783. 	typedef __Reply__rpc_jack_set_freewheel_t __Reply;

  3784. #if	__MigTypeCheck

  3785. 	unsigned int msgh_size;

  3786. #endif	/* __MigTypeCheck */

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

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

  3789. 		{ return MIG_SERVER_DIED; }

  3790. 	    else

  3791. 		{ return MIG_REPLY_MISMATCH; }

  3792. 	}

  3793. 

  3794. #if	__MigTypeCheck

  3795. 	msgh_size = Out0P->Head.msgh_size;

  3796. 

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

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

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

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

  3801. 		{ return MIG_TYPE_ERROR ; }

  3802. #endif	/* __MigTypeCheck */

  3803. 

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

  3805. #ifdef	__NDR_convert__mig_reply_error_t__defined

  3806. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  3807. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  3809. 	}

  3810. 

  3811. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined) || \

  3812. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3814. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined)

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

  3816. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__RetCode__defined */

  3817. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3819. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3820. 	}

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

  3822. 

  3823. #if	0 || \

  3824. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3826. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3828. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3829. 	}

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

  3831. 

  3832. #if	0 || \

  3833. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3835. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined)

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

  3837. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_freewheel_t__result__defined */

  3838. 	}

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

  3840. 

  3841. 	return MACH_MSG_SUCCESS;

  3842. }

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

  3844. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  3846. 

  3847. 

  3848. /* Routine rpc_jack_set_freewheel */

  3849. mig_external kern_return_t rpc_jack_set_freewheel

  3850. (

  3851. 	mach_port_t server_port,

  3852. 	int onoff,

  3853. 	int *result

  3854. )

  3855. {

  3856.     {

  3857. 

  3858. #ifdef  __MigPackStructs

  3859. #pragma pack(4)

  3860. #endif

  3861. 	typedef struct {

  3862. 		mach_msg_header_t Head;

  3863. 		NDR_record_t NDR;

  3864. 		int onoff;

  3865. 	} Request;

  3866. #ifdef  __MigPackStructs

  3867. #pragma pack()

  3868. #endif

  3869. 

  3870. #ifdef  __MigPackStructs

  3871. #pragma pack(4)

  3872. #endif

  3873. 	typedef struct {

  3874. 		mach_msg_header_t Head;

  3875. 		NDR_record_t NDR;

  3876. 		kern_return_t RetCode;

  3877. 		int result;

  3878. 		mach_msg_trailer_t trailer;

  3879. 	} Reply;

  3880. #ifdef  __MigPackStructs

  3881. #pragma pack()

  3882. #endif

  3883. 

  3884. #ifdef  __MigPackStructs

  3885. #pragma pack(4)

  3886. #endif

  3887. 	typedef struct {

  3888. 		mach_msg_header_t Head;

  3889. 		NDR_record_t NDR;

  3890. 		kern_return_t RetCode;

  3891. 		int result;

  3892. 	} __Reply;

  3893. #ifdef  __MigPackStructs

  3894. #pragma pack()

  3895. #endif

  3896. 	/*

  3897. 	 * typedef struct {

  3898. 	 * 	mach_msg_header_t Head;

  3899. 	 * 	NDR_record_t NDR;

  3900. 	 * 	kern_return_t RetCode;

  3901. 	 * } mig_reply_error_t;

  3902. 	 */

  3903. 

  3904. 	union {

  3905. 		Request In;

  3906. 		Reply Out;

  3907. 	} Mess;

  3908. 

  3909. 	Request *InP = &Mess.In;

  3910. 	Reply *Out0P = &Mess.Out;

  3911. 

  3912. 	mach_msg_return_t msg_result;

  3913. 

  3914. #ifdef	__MIG_check__Reply__rpc_jack_set_freewheel_t__defined

  3915. 	kern_return_t check_result;

  3916. #endif	/* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */

  3917. 

  3918. 	__DeclareSendRpc(1012, "rpc_jack_set_freewheel")

  3919. 

  3920. 	InP->NDR = NDR_record;

  3921. 

  3922. 	InP->onoff = onoff;

  3923. 

  3924. 	InP->Head.msgh_bits =

  3925. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  3926. 	/* msgh_size passed as argument */

  3927. 	InP->Head.msgh_request_port = server_port;

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

  3929. 	InP->Head.msgh_id = 1012;

  3930. 

  3931. 	__BeforeSendRpc(1012, "rpc_jack_set_freewheel")

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

  3933. 	__AfterSendRpc(1012, "rpc_jack_set_freewheel")

  3934. 	if (msg_result != MACH_MSG_SUCCESS) {

  3935. 		__MachMsgErrorWithoutTimeout(msg_result);

  3936. 		{ return msg_result; }

  3937. 	}

  3938. 

  3939. 

  3940. #if	defined(__MIG_check__Reply__rpc_jack_set_freewheel_t__defined)

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

  3942. 	if (check_result != MACH_MSG_SUCCESS)

  3943. 		{ return check_result; }

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

  3945. 

  3946. 	*result = Out0P->result;

  3947. 

  3948. 	return KERN_SUCCESS;

  3949.     }

  3950. }

  3951. 

  3952. #if ( __MigTypeCheck || __NDR_convert__ )

  3953. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  3954. #if !defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)

  3955. #define __MIG_check__Reply__rpc_jack_release_timebase_t__defined

  3956. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3957. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  3958. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3959. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \

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

  3961. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  3962. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined

  3963. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode(a, f) \

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

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

  3966. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */

  3967. 

  3968. 

  3969. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3970. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  3971. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3972. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  3974. #elif	defined(__NDR_convert__int_rep__int__defined)

  3975. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3976. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  3978. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  3979. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3980. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  3982. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  3983. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3984. #define	__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

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

  3987. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  3988. 

  3989. 

  3990. 

  3991. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3992. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  3993. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3994. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  3996. #elif	defined(__NDR_convert__char_rep__int__defined)

  3997. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  3998. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  4000. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  4001. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4002. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  4004. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  4005. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4006. #define	__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

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

  4009. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  4010. 

  4011. 

  4012. 

  4013. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4014. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  4015. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4016. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  4018. #elif	defined(__NDR_convert__float_rep__int__defined)

  4019. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4020. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  4022. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  4023. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4024. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

  4026. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  4027. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined

  4028. #define	__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result(a, f) \

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

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

  4031. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  4032. 

  4033. 

  4034. 

  4035. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Reply__rpc_jack_release_timebase_t *Out0P)

  4036. {

  4037. 

  4038. 	typedef __Reply__rpc_jack_release_timebase_t __Reply;

  4039. #if	__MigTypeCheck

  4040. 	unsigned int msgh_size;

  4041. #endif	/* __MigTypeCheck */

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

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

  4044. 		{ return MIG_SERVER_DIED; }

  4045. 	    else

  4046. 		{ return MIG_REPLY_MISMATCH; }

  4047. 	}

  4048. 

  4049. #if	__MigTypeCheck

  4050. 	msgh_size = Out0P->Head.msgh_size;

  4051. 

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

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

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

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

  4056. 		{ return MIG_TYPE_ERROR ; }

  4057. #endif	/* __MigTypeCheck */

  4058. 

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

  4060. #ifdef	__NDR_convert__mig_reply_error_t__defined

  4061. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  4062. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  4064. 	}

  4065. 

  4066. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined) || \

  4067. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4069. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined)

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

  4071. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__RetCode__defined */

  4072. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4074. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  4075. 	}

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

  4077. 

  4078. #if	0 || \

  4079. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4081. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4083. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  4084. 	}

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

  4086. 

  4087. #if	0 || \

  4088. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4090. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined)

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

  4092. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_release_timebase_t__result__defined */

  4093. 	}

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

  4095. 

  4096. 	return MACH_MSG_SUCCESS;

  4097. }

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

  4099. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  4101. 

  4102. 

  4103. /* Routine rpc_jack_release_timebase */

  4104. mig_external kern_return_t rpc_jack_release_timebase

  4105. (

  4106. 	mach_port_t server_port,

  4107. 	int refnum,

  4108. 	int *result

  4109. )

  4110. {

  4111.     {

  4112. 

  4113. #ifdef  __MigPackStructs

  4114. #pragma pack(4)

  4115. #endif

  4116. 	typedef struct {

  4117. 		mach_msg_header_t Head;

  4118. 		NDR_record_t NDR;

  4119. 		int refnum;

  4120. 	} Request;

  4121. #ifdef  __MigPackStructs

  4122. #pragma pack()

  4123. #endif

  4124. 

  4125. #ifdef  __MigPackStructs

  4126. #pragma pack(4)

  4127. #endif

  4128. 	typedef struct {

  4129. 		mach_msg_header_t Head;

  4130. 		NDR_record_t NDR;

  4131. 		kern_return_t RetCode;

  4132. 		int result;

  4133. 		mach_msg_trailer_t trailer;

  4134. 	} Reply;

  4135. #ifdef  __MigPackStructs

  4136. #pragma pack()

  4137. #endif

  4138. 

  4139. #ifdef  __MigPackStructs

  4140. #pragma pack(4)

  4141. #endif

  4142. 	typedef struct {

  4143. 		mach_msg_header_t Head;

  4144. 		NDR_record_t NDR;

  4145. 		kern_return_t RetCode;

  4146. 		int result;

  4147. 	} __Reply;

  4148. #ifdef  __MigPackStructs

  4149. #pragma pack()

  4150. #endif

  4151. 	/*

  4152. 	 * typedef struct {

  4153. 	 * 	mach_msg_header_t Head;

  4154. 	 * 	NDR_record_t NDR;

  4155. 	 * 	kern_return_t RetCode;

  4156. 	 * } mig_reply_error_t;

  4157. 	 */

  4158. 

  4159. 	union {

  4160. 		Request In;

  4161. 		Reply Out;

  4162. 	} Mess;

  4163. 

  4164. 	Request *InP = &Mess.In;

  4165. 	Reply *Out0P = &Mess.Out;

  4166. 

  4167. 	mach_msg_return_t msg_result;

  4168. 

  4169. #ifdef	__MIG_check__Reply__rpc_jack_release_timebase_t__defined

  4170. 	kern_return_t check_result;

  4171. #endif	/* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */

  4172. 

  4173. 	__DeclareSendRpc(1013, "rpc_jack_release_timebase")

  4174. 

  4175. 	InP->NDR = NDR_record;

  4176. 

  4177. 	InP->refnum = refnum;

  4178. 

  4179. 	InP->Head.msgh_bits =

  4180. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  4181. 	/* msgh_size passed as argument */

  4182. 	InP->Head.msgh_request_port = server_port;

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

  4184. 	InP->Head.msgh_id = 1013;

  4185. 

  4186. 	__BeforeSendRpc(1013, "rpc_jack_release_timebase")

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

  4188. 	__AfterSendRpc(1013, "rpc_jack_release_timebase")

  4189. 	if (msg_result != MACH_MSG_SUCCESS) {

  4190. 		__MachMsgErrorWithoutTimeout(msg_result);

  4191. 		{ return msg_result; }

  4192. 	}

  4193. 

  4194. 

  4195. #if	defined(__MIG_check__Reply__rpc_jack_release_timebase_t__defined)

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

  4197. 	if (check_result != MACH_MSG_SUCCESS)

  4198. 		{ return check_result; }

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

  4200. 

  4201. 	*result = Out0P->result;

  4202. 

  4203. 	return KERN_SUCCESS;

  4204.     }

  4205. }

  4206. 

  4207. #if ( __MigTypeCheck || __NDR_convert__ )

  4208. #if __MIG_check__Reply__JackRPCEngine_subsystem__

  4209. #if !defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)

  4210. #define __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined

  4211. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  4212. #if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)

  4213. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  4214. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \

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

  4216. #elif	defined(__NDR_convert__int_rep__kern_return_t__defined)

  4217. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined

  4218. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode(a, f) \

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

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

  4221. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */

  4222. 

  4223. 

  4224. #ifndef __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4225. #if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)

  4226. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4227. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4229. #elif	defined(__NDR_convert__int_rep__int__defined)

  4230. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4231. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4233. #elif	defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined)

  4234. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4235. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4237. #elif	defined(__NDR_convert__int_rep__int32_t__defined)

  4238. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4239. #define	__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

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

  4242. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4243. 

  4244. 

  4245. 

  4246. #ifndef __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4247. #if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)

  4248. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4249. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4251. #elif	defined(__NDR_convert__char_rep__int__defined)

  4252. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4253. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4255. #elif	defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined)

  4256. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4257. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4259. #elif	defined(__NDR_convert__char_rep__int32_t__defined)

  4260. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4261. #define	__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

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

  4264. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4265. 

  4266. 

  4267. 

  4268. #ifndef __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4269. #if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)

  4270. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4271. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4273. #elif	defined(__NDR_convert__float_rep__int__defined)

  4274. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4275. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4277. #elif	defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined)

  4278. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4279. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

  4281. #elif	defined(__NDR_convert__float_rep__int32_t__defined)

  4282. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined

  4283. #define	__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result(a, f) \

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

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

  4286. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4287. 

  4288. 

  4289. 

  4290. mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(__Reply__rpc_jack_set_timebase_callback_t *Out0P)

  4291. {

  4292. 

  4293. 	typedef __Reply__rpc_jack_set_timebase_callback_t __Reply;

  4294. #if	__MigTypeCheck

  4295. 	unsigned int msgh_size;

  4296. #endif	/* __MigTypeCheck */

  4297. 	if (Out0P->Head.msgh_id != 1114) {

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

  4299. 		{ return MIG_SERVER_DIED; }

  4300. 	    else

  4301. 		{ return MIG_REPLY_MISMATCH; }

  4302. 	}

  4303. 

  4304. #if	__MigTypeCheck

  4305. 	msgh_size = Out0P->Head.msgh_size;

  4306. 

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

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

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

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

  4311. 		{ return MIG_TYPE_ERROR ; }

  4312. #endif	/* __MigTypeCheck */

  4313. 

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

  4315. #ifdef	__NDR_convert__mig_reply_error_t__defined

  4316. 		__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);

  4317. #endif	/* __NDR_convert__mig_reply_error_t__defined */

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

  4319. 	}

  4320. 

  4321. #if	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined) || \

  4322. 	defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4324. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined)

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

  4326. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__RetCode__defined */

  4327. #if defined(__NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4329. #endif /* __NDR_convert__int_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4330. 	}

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

  4332. 

  4333. #if	0 || \

  4334. 	defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4336. #if defined(__NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4338. #endif /* __NDR_convert__char_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4339. 	}

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

  4341. 

  4342. #if	0 || \

  4343. 	defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4345. #if defined(__NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined)

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

  4347. #endif /* __NDR_convert__float_rep__Reply__rpc_jack_set_timebase_callback_t__result__defined */

  4348. 	}

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

  4350. 

  4351. 	return MACH_MSG_SUCCESS;

  4352. }

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

  4354. #endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */

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

  4356. 

  4357. 

  4358. /* Routine rpc_jack_set_timebase_callback */

  4359. mig_external kern_return_t rpc_jack_set_timebase_callback

  4360. (

  4361. 	mach_port_t server_port,

  4362. 	int refnum,

  4363. 	int conditional,

  4364. 	int *result

  4365. )

  4366. {

  4367.     {

  4368. 

  4369. #ifdef  __MigPackStructs

  4370. #pragma pack(4)

  4371. #endif

  4372. 	typedef struct {

  4373. 		mach_msg_header_t Head;

  4374. 		NDR_record_t NDR;

  4375. 		int refnum;

  4376. 		int conditional;

  4377. 	} Request;

  4378. #ifdef  __MigPackStructs

  4379. #pragma pack()

  4380. #endif

  4381. 

  4382. #ifdef  __MigPackStructs

  4383. #pragma pack(4)

  4384. #endif

  4385. 	typedef struct {

  4386. 		mach_msg_header_t Head;

  4387. 		NDR_record_t NDR;

  4388. 		kern_return_t RetCode;

  4389. 		int result;

  4390. 		mach_msg_trailer_t trailer;

  4391. 	} Reply;

  4392. #ifdef  __MigPackStructs

  4393. #pragma pack()

  4394. #endif

  4395. 

  4396. #ifdef  __MigPackStructs

  4397. #pragma pack(4)

  4398. #endif

  4399. 	typedef struct {

  4400. 		mach_msg_header_t Head;

  4401. 		NDR_record_t NDR;

  4402. 		kern_return_t RetCode;

  4403. 		int result;

  4404. 	} __Reply;

  4405. #ifdef  __MigPackStructs

  4406. #pragma pack()

  4407. #endif

  4408. 	/*

  4409. 	 * typedef struct {

  4410. 	 * 	mach_msg_header_t Head;

  4411. 	 * 	NDR_record_t NDR;

  4412. 	 * 	kern_return_t RetCode;

  4413. 	 * } mig_reply_error_t;

  4414. 	 */

  4415. 

  4416. 	union {

  4417. 		Request In;

  4418. 		Reply Out;

  4419. 	} Mess;

  4420. 

  4421. 	Request *InP = &Mess.In;

  4422. 	Reply *Out0P = &Mess.Out;

  4423. 

  4424. 	mach_msg_return_t msg_result;

  4425. 

  4426. #ifdef	__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined

  4427. 	kern_return_t check_result;

  4428. #endif	/* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */

  4429. 

  4430. 	__DeclareSendRpc(1014, "rpc_jack_set_timebase_callback")

  4431. 

  4432. 	InP->NDR = NDR_record;

  4433. 

  4434. 	InP->refnum = refnum;

  4435. 

  4436. 	InP->conditional = conditional;

  4437. 

  4438. 	InP->Head.msgh_bits =

  4439. 		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);

  4440. 	/* msgh_size passed as argument */

  4441. 	InP->Head.msgh_request_port = server_port;

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

  4443. 	InP->Head.msgh_id = 1014;

  4444. 

  4445. 	__BeforeSendRpc(1014, "rpc_jack_set_timebase_callback")

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

  4447. 	__AfterSendRpc(1014, "rpc_jack_set_timebase_callback")

  4448. 	if (msg_result != MACH_MSG_SUCCESS) {

  4449. 		__MachMsgErrorWithoutTimeout(msg_result);

  4450. 		{ return msg_result; }

  4451. 	}

  4452. 

  4453. 

  4454. #if	defined(__MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined)

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

  4456. 	if (check_result != MACH_MSG_SUCCESS)

  4457. 		{ return check_result; }

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

  4459. 

  4460. 	*result = Out0P->result;

  4461. 

  4462. 	return KERN_SUCCESS;

  4463.     }

  4464. }

  4465. 

  4466. /* SimpleRoutine rpc_jack_client_rt_notify */

  4467. mig_external kern_return_t rpc_jack_client_rt_notify

  4468. (

  4469. 	mach_port_t client_port,

  4470. 	int refnum,

  4471. 	int notify,

  4472. 	int value,

  4473. 	int timeout

  4474. )

  4475. {

  4476.     {

  4477. 

  4478. #ifdef  __MigPackStructs

  4479. #pragma pack(4)

  4480. #endif

  4481. 	typedef struct {

  4482. 		mach_msg_header_t Head;

  4483. 		NDR_record_t NDR;

  4484. 		int refnum;

  4485. 		int notify;

  4486. 		int value;

  4487. 	} Request;

  4488. #ifdef  __MigPackStructs

  4489. #pragma pack()

  4490. #endif

  4491. 	/*

  4492. 	 * typedef struct {

  4493. 	 * 	mach_msg_header_t Head;

  4494. 	 * 	NDR_record_t NDR;

  4495. 	 * 	kern_return_t RetCode;

  4496. 	 * } mig_reply_error_t;

  4497. 	 */

  4498. 

  4499. 	union {

  4500. 		Request In;

  4501. 	} Mess;

  4502. 

  4503. 	Request *InP = &Mess.In;

  4504. 

  4505. 	mach_msg_return_t msg_result;

  4506. 

  4507. #ifdef	__MIG_check__Reply__rpc_jack_client_rt_notify_t__defined

  4508. 	kern_return_t check_result;

  4509. #endif	/* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */

  4510. 

  4511. 	__DeclareSendSimple(1015, "rpc_jack_client_rt_notify")

  4512. 

  4513. 	InP->NDR = NDR_record;

  4514. 

  4515. 	InP->refnum = refnum;

  4516. 

  4517. 	InP->notify = notify;

  4518. 

  4519. 	InP->value = value;

  4520. 

  4521. 	InP->Head.msgh_bits =

  4522. 		MACH_MSGH_BITS(19, 0);

  4523. 	/* msgh_size passed as argument */

  4524. 	InP->Head.msgh_request_port = client_port;

  4525. 	InP->Head.msgh_reply_port = MACH_PORT_NULL;

  4526. 	InP->Head.msgh_id = 1015;

  4527. 

  4528. 	__BeforeSendSimple(1015, "rpc_jack_client_rt_notify")

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

  4530. 	__AfterSendSimple(1015, "rpc_jack_client_rt_notify")

  4531. 		return msg_result;

  4532. 	return KERN_SUCCESS;

  4533.     }

  4534. }