1 /*
2 * IDENTIFICATION:
3 * stub generated Thu Jun 11 18:17:44 2015
4 * with a MiG generated Thu Jun 11 16:16:11 PDT 2015 by kmacy@serenity
5 * OPTIONS:
6 * KernelServer
7 */
8
9 /* Module clock */
10
11 #define __MIG_check__Request__clock_subsystem__ 1
12
13 #include <sys/cdefs.h>
14 #include <sys/types.h>
15 #ifdef _KERNEL
16 #include <sys/mach/ndr.h>
17 #include <sys/mach/kern_return.h>
18 #include <sys/mach/notify.h>
19 #include <sys/mach/mach_types.h>
20 #include <sys/mach/message.h>
21 #include <sys/mach/mig_errors.h>
22 #else /* !_KERNEL */
23 #include <string.h>
24 #include <mach/ndr.h>
25 #include <mach/boolean.h>
26 #include <mach/kern_return.h>
27 #include <mach/notify.h>
28 #include <mach/mach_types.h>
29 #include <mach/message.h>
30 #include <mach/mig_errors.h>
31 #endif /*_KERNEL */
32
33 #include <sys/mach/std_types.h>
34 #include <sys/mach/mig.h>
35 #include <sys/mach/ipc_sync.h>
36 #include <sys/mach/ipc/ipc_voucher.h>
37 #include <sys/mach/ipc_host.h>
38 #include <sys/mach/ipc_tt.h>
39 #include <sys/mach/ipc_mig.h>
40 #include <sys/mach/mig.h>
41 #include <sys/mach/mach_types.h>
42 #include <sys/mach/mach_types.h>
43
44 #ifndef mig_internal
45 #define mig_internal static __inline__
46 #endif /* mig_internal */
47
48 #ifndef mig_external
49 #define mig_external
50 #endif /* mig_external */
51
52 #if !defined(__MigTypeCheck) && defined(TypeCheck)
53 #define __MigTypeCheck TypeCheck /* Legacy setting */
54 #endif /* !defined(__MigTypeCheck) */
55
56 #if !defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
57 #define __MigKernelSpecificCode _MIG_KERNEL_SPECIFIC_CODE_ /* Legacy setting */
58 #endif /* !defined(__MigKernelSpecificCode) */
59
60 #ifndef LimitCheck
61 #define LimitCheck 0
62 #endif /* LimitCheck */
63
64 #ifndef min
65 #define min(a,b) ( ((a) < (b))? (a): (b) )
66 #endif /* min */
67
68 #if !defined(_WALIGN_)
69 #define _WALIGN_(x) (((x) + 7) & ~7)
70 #endif /* !defined(_WALIGN_) */
71
72 #if !defined(_WALIGNSZ_)
73 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
74 #endif /* !defined(_WALIGNSZ_) */
75
76 #ifndef UseStaticTemplates
77 #define UseStaticTemplates 1
78 #endif /* UseStaticTemplates */
79
80 #define _WALIGN_(x) (((x) + 7) & ~7)
81 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
82 #ifndef __DeclareRcvRpc
83 #define __DeclareRcvRpc(_NUM_, _NAME_)
84 #endif /* __DeclareRcvRpc */
85
86 #ifndef __BeforeRcvRpc
87 #define __BeforeRcvRpc(_NUM_, _NAME_)
88 #endif /* __BeforeRcvRpc */
89
90 #ifndef __AfterRcvRpc
91 #define __AfterRcvRpc(_NUM_, _NAME_)
92 #endif /* __AfterRcvRpc */
93
94 #ifndef __DeclareRcvSimple
95 #define __DeclareRcvSimple(_NUM_, _NAME_)
96 #endif /* __DeclareRcvSimple */
97
98 #ifndef __BeforeRcvSimple
99 #define __BeforeRcvSimple(_NUM_, _NAME_)
100 #endif /* __BeforeRcvSimple */
101
102 #ifndef __AfterRcvSimple
103 #define __AfterRcvSimple(_NUM_, _NAME_)
104 #endif /* __AfterRcvSimple */
105
106 #define novalue void
107 #if __MigKernelSpecificCode
108 #define msgh_request_port msgh_remote_port
109 #define MACH_MSGH_BITS_REQUEST(bits) MACH_MSGH_BITS_REMOTE(bits)
110 #define msgh_reply_port msgh_local_port
111 #define MACH_MSGH_BITS_REPLY(bits) MACH_MSGH_BITS_LOCAL(bits)
112 #else
113 #define msgh_request_port msgh_local_port
114 #define MACH_MSGH_BITS_REQUEST(bits) MACH_MSGH_BITS_LOCAL(bits)
115 #define msgh_reply_port msgh_remote_port
116 #define MACH_MSGH_BITS_REPLY(bits) MACH_MSGH_BITS_REMOTE(bits)
117 #endif /* __MigKernelSpecificCode */
118
119 #define MIG_RETURN_ERROR(X, code) {\
120 ((mig_reply_error_t *)X)->RetCode = code;\
121 ((mig_reply_error_t *)X)->NDR = NDR_record;\
122 return;\
123 }
124
125 /* typedefs for all requests */
126
127 #ifndef __Request__clock_subsystem__defined
128 #define __Request__clock_subsystem__defined
129
130 #ifdef __MigPackStructs
131 #pragma pack(4)
132 #endif
133 typedef struct {
134 mach_msg_header_t Head;
135 /* start of the kernel processed data */
136 mach_msg_body_t msgh_body;
137 /* end of the kernel processed data */
138 } __Request__clock_get_time_t;
139 #ifdef __MigPackStructs
140 #pragma pack()
141 #endif
142
143 #ifdef __MigPackStructs
144 #pragma pack(4)
145 #endif
146 typedef struct {
147 mach_msg_header_t Head;
148 /* start of the kernel processed data */
149 mach_msg_body_t msgh_body;
150 /* end of the kernel processed data */
151 NDR_record_t NDR;
152 clock_flavor_t flavor;
153 mach_msg_type_number_t clock_attrCnt;
154 } __Request__clock_get_attributes_t;
155 #ifdef __MigPackStructs
156 #pragma pack()
157 #endif
158
159 #ifdef __MigPackStructs
160 #pragma pack(4)
161 #endif
162 typedef struct {
163 mach_msg_header_t Head;
164 /* start of the kernel processed data */
165 mach_msg_body_t msgh_body;
166 mach_msg_port_descriptor_t alarm_port;
167 /* end of the kernel processed data */
168 NDR_record_t NDR;
169 alarm_type_t alarm_type;
170 mach_timespec_t alarm_time;
171 } __Request__clock_alarm_t;
172 #ifdef __MigPackStructs
173 #pragma pack()
174 #endif
175 #endif /* !__Request__clock_subsystem__defined */
176
177 /* typedefs for all replies */
178
179 #ifndef __Reply__clock_subsystem__defined
180 #define __Reply__clock_subsystem__defined
181
182 #ifdef __MigPackStructs
183 #pragma pack(4)
184 #endif
185 typedef struct {
186 mach_msg_header_t Head;
187 NDR_record_t NDR;
188 kern_return_t RetCode;
189 mach_timespec_t cur_time;
190 } __Reply__clock_get_time_t;
191 #ifdef __MigPackStructs
192 #pragma pack()
193 #endif
194
195 #ifdef __MigPackStructs
196 #pragma pack(4)
197 #endif
198 typedef struct {
199 mach_msg_header_t Head;
200 NDR_record_t NDR;
201 kern_return_t RetCode;
202 mach_msg_type_number_t clock_attrCnt;
203 int clock_attr[1];
204 } __Reply__clock_get_attributes_t;
205 #ifdef __MigPackStructs
206 #pragma pack()
207 #endif
208
209 #ifdef __MigPackStructs
210 #pragma pack(4)
211 #endif
212 typedef struct {
213 mach_msg_header_t Head;
214 NDR_record_t NDR;
215 kern_return_t RetCode;
216 } __Reply__clock_alarm_t;
217 #ifdef __MigPackStructs
218 #pragma pack()
219 #endif
220 #endif /* !__Reply__clock_subsystem__defined */
221
222
223 /* union of all replies */
224
225 #ifndef __ReplyUnion__clock_subsystem__defined
226 #define __ReplyUnion__clock_subsystem__defined
227 union __ReplyUnion__clock_subsystem {
228 __Reply__clock_get_time_t Reply_clock_get_time;
229 __Reply__clock_get_attributes_t Reply_clock_get_attributes;
230 __Reply__clock_alarm_t Reply_clock_alarm;
231 };
232 #endif /* __RequestUnion__clock_subsystem__defined */
233 /* Forward Declarations */
234
235
236 mig_internal novalue _Xclock_get_time
237 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
238
239 mig_internal novalue _Xclock_get_attributes
240 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
241
242 mig_internal novalue _Xclock_alarm
243 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
244
245
246 #if ( __MigTypeCheck )
247 #if __MIG_check__Request__clock_subsystem__
248 #if !defined(__MIG_check__Request__clock_get_time_t__defined)
249 #define __MIG_check__Request__clock_get_time_t__defined
250
__MIG_check__Request__clock_get_time_t(__Request__clock_get_time_t * In0P)251 mig_internal kern_return_t __MIG_check__Request__clock_get_time_t(__attribute__((__unused__)) __Request__clock_get_time_t *In0P)
252 {
253
254 typedef __Request__clock_get_time_t __Request;
255 #if __MigTypeCheck
256 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
257 (In0P->msgh_body.msgh_descriptor_count != 0) ||
258 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
259 return MIG_BAD_ARGUMENTS;
260 #endif /* __MigTypeCheck */
261
262 return MACH_MSG_SUCCESS;
263 }
264 #endif /* !defined(__MIG_check__Request__clock_get_time_t__defined) */
265 #endif /* __MIG_check__Request__clock_subsystem__ */
266 #endif /* ( __MigTypeCheck ) */
267
268
269 /* Routine clock_get_time */
270 #ifdef mig_external
271 mig_external
272 #else
273 extern
274 #endif /* mig_external */
clock_get_time(clock_serv,cur_time)275 kern_return_t clock_get_time
276 #if defined(LINTLIBRARY)
277 (clock_serv, cur_time)
278 clock_serv_t clock_serv;
279 mach_timespec_t *cur_time;
280 { return clock_get_time(clock_serv, cur_time); }
281 #else
282 (
283 clock_serv_t clock_serv,
284 mach_timespec_t *cur_time
285 );
286 #endif /* defined(LINTLIBRARY) */
287
288 /* Routine clock_get_time */
_Xclock_get_time(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)289 mig_internal novalue _Xclock_get_time
290 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
291 {
292
293 #ifdef __MigPackStructs
294 #pragma pack(4)
295 #endif
296 typedef struct {
297 mach_msg_header_t Head;
298 /* start of the kernel processed data */
299 mach_msg_body_t msgh_body;
300 /* end of the kernel processed data */
301 mach_msg_trailer_t trailer;
302 } Request;
303 #ifdef __MigPackStructs
304 #pragma pack()
305 #endif
306 typedef __Request__clock_get_time_t __Request;
307 typedef __Reply__clock_get_time_t Reply;
308
309 /*
310 * typedef struct {
311 * mach_msg_header_t Head;
312 * NDR_record_t NDR;
313 * kern_return_t RetCode;
314 * } mig_reply_error_t;
315 */
316
317 Request *In0P = (Request *) InHeadP;
318 Reply *OutP = (Reply *) OutHeadP;
319 #ifdef __MIG_check__Request__clock_get_time_t__defined
320 kern_return_t check_result;
321 #endif /* __MIG_check__Request__clock_get_time_t__defined */
322
323 #if __MigKernelSpecificCode
324 #else
325 #endif /* __MigKernelSpecificCode */
326 __DeclareRcvRpc(1000, "clock_get_time")
327 __BeforeRcvRpc(1000, "clock_get_time")
328 /* RetCArg=0x0 rtSimpleRequest=0 */
329
330 #if defined(__MIG_check__Request__clock_get_time_t__defined)
331 check_result = __MIG_check__Request__clock_get_time_t((__Request *)In0P);
332 if (check_result != MACH_MSG_SUCCESS)
333 { MIG_RETURN_ERROR(OutP, check_result); }
334 #endif /* defined(__MIG_check__Request__clock_get_time_t__defined) */
335
336 OutP->RetCode = clock_get_time(convert_port_to_clock(In0P->Head.msgh_request_port), &OutP->cur_time);
337 if (OutP->RetCode != KERN_SUCCESS) {
338 MIG_RETURN_ERROR(OutP, OutP->RetCode);
339 }
340 #if __MigKernelSpecificCode
341 #endif /* __MigKernelSpecificCode */
342
343 OutP->NDR = NDR_record;
344
345
346 OutP->Head.msgh_size = (sizeof(Reply));
347 __AfterRcvRpc(1000, "clock_get_time")
348 }
349
350 #if ( __MigTypeCheck )
351 #if __MIG_check__Request__clock_subsystem__
352 #if !defined(__MIG_check__Request__clock_get_attributes_t__defined)
353 #define __MIG_check__Request__clock_get_attributes_t__defined
354
__MIG_check__Request__clock_get_attributes_t(__Request__clock_get_attributes_t * In0P)355 mig_internal kern_return_t __MIG_check__Request__clock_get_attributes_t(__attribute__((__unused__)) __Request__clock_get_attributes_t *In0P)
356 {
357
358 typedef __Request__clock_get_attributes_t __Request;
359 #if __MigTypeCheck
360 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
361 (In0P->msgh_body.msgh_descriptor_count != 0) ||
362 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
363 return MIG_BAD_ARGUMENTS;
364 #endif /* __MigTypeCheck */
365
366 return MACH_MSG_SUCCESS;
367 }
368 #endif /* !defined(__MIG_check__Request__clock_get_attributes_t__defined) */
369 #endif /* __MIG_check__Request__clock_subsystem__ */
370 #endif /* ( __MigTypeCheck ) */
371
372
373 /* Routine clock_get_attributes */
374 #ifdef mig_external
375 mig_external
376 #else
377 extern
378 #endif /* mig_external */
clock_get_attributes(clock_serv,flavor,clock_attr,clock_attrCnt)379 kern_return_t clock_get_attributes
380 #if defined(LINTLIBRARY)
381 (clock_serv, flavor, clock_attr, clock_attrCnt)
382 clock_serv_t clock_serv;
383 clock_flavor_t flavor;
384 clock_attr_t clock_attr;
385 mach_msg_type_number_t *clock_attrCnt;
386 { return clock_get_attributes(clock_serv, flavor, clock_attr, clock_attrCnt); }
387 #else
388 (
389 clock_serv_t clock_serv,
390 clock_flavor_t flavor,
391 clock_attr_t clock_attr,
392 mach_msg_type_number_t *clock_attrCnt
393 );
394 #endif /* defined(LINTLIBRARY) */
395
396 /* Routine clock_get_attributes */
_Xclock_get_attributes(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)397 mig_internal novalue _Xclock_get_attributes
398 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
399 {
400
401 #ifdef __MigPackStructs
402 #pragma pack(4)
403 #endif
404 typedef struct {
405 mach_msg_header_t Head;
406 /* start of the kernel processed data */
407 mach_msg_body_t msgh_body;
408 /* end of the kernel processed data */
409 NDR_record_t NDR;
410 clock_flavor_t flavor;
411 mach_msg_type_number_t clock_attrCnt;
412 mach_msg_trailer_t trailer;
413 } Request;
414 #ifdef __MigPackStructs
415 #pragma pack()
416 #endif
417 typedef __Request__clock_get_attributes_t __Request;
418 typedef __Reply__clock_get_attributes_t Reply;
419
420 /*
421 * typedef struct {
422 * mach_msg_header_t Head;
423 * NDR_record_t NDR;
424 * kern_return_t RetCode;
425 * } mig_reply_error_t;
426 */
427
428 Request *In0P = (Request *) InHeadP;
429 Reply *OutP = (Reply *) OutHeadP;
430 #ifdef __MIG_check__Request__clock_get_attributes_t__defined
431 kern_return_t check_result;
432 #endif /* __MIG_check__Request__clock_get_attributes_t__defined */
433
434 #if __MigKernelSpecificCode
435 #else
436 #endif /* __MigKernelSpecificCode */
437 __DeclareRcvRpc(1001, "clock_get_attributes")
438 __BeforeRcvRpc(1001, "clock_get_attributes")
439 /* RetCArg=0x0 rtSimpleRequest=0 */
440
441 #if defined(__MIG_check__Request__clock_get_attributes_t__defined)
442 check_result = __MIG_check__Request__clock_get_attributes_t((__Request *)In0P);
443 if (check_result != MACH_MSG_SUCCESS)
444 { MIG_RETURN_ERROR(OutP, check_result); }
445 #endif /* defined(__MIG_check__Request__clock_get_attributes_t__defined) */
446
447 OutP->clock_attrCnt = 1;
448 if (In0P->clock_attrCnt < OutP->clock_attrCnt)
449 OutP->clock_attrCnt = In0P->clock_attrCnt;
450
451 OutP->RetCode = clock_get_attributes(convert_port_to_clock(In0P->Head.msgh_request_port), In0P->flavor, OutP->clock_attr, &OutP->clock_attrCnt);
452 if (OutP->RetCode != KERN_SUCCESS) {
453 MIG_RETURN_ERROR(OutP, OutP->RetCode);
454 }
455 #if __MigKernelSpecificCode
456 #endif /* __MigKernelSpecificCode */
457
458 OutP->NDR = NDR_record;
459
460 OutP->Head.msgh_size = (sizeof(Reply) - 4) + (_WALIGN_((4 * OutP->clock_attrCnt)));
461
462 __AfterRcvRpc(1001, "clock_get_attributes")
463 }
464
465 #if ( __MigTypeCheck )
466 #if __MIG_check__Request__clock_subsystem__
467 #if !defined(__MIG_check__Request__clock_alarm_t__defined)
468 #define __MIG_check__Request__clock_alarm_t__defined
469
__MIG_check__Request__clock_alarm_t(__Request__clock_alarm_t * In0P)470 mig_internal kern_return_t __MIG_check__Request__clock_alarm_t(__attribute__((__unused__)) __Request__clock_alarm_t *In0P)
471 {
472
473 typedef __Request__clock_alarm_t __Request;
474 #if __MigTypeCheck
475 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
476 (In0P->msgh_body.msgh_descriptor_count != 1) ||
477 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
478 return MIG_BAD_ARGUMENTS;
479 #endif /* __MigTypeCheck */
480
481 #if __MigTypeCheck
482 if (In0P->alarm_port.type != MACH_MSG_PORT_DESCRIPTOR)
483 return MIG_TYPE_ERROR;
484 #endif /* __MigTypeCheck */
485
486 return MACH_MSG_SUCCESS;
487 }
488 #endif /* !defined(__MIG_check__Request__clock_alarm_t__defined) */
489 #endif /* __MIG_check__Request__clock_subsystem__ */
490 #endif /* ( __MigTypeCheck ) */
491
492
493 /* Routine clock_alarm */
494 #ifdef mig_external
495 mig_external
496 #else
497 extern
498 #endif /* mig_external */
clock_alarm(clock_serv,alarm_type,alarm_time,alarm_port,alarm_portPoly)499 kern_return_t clock_alarm
500 #if defined(LINTLIBRARY)
501 (clock_serv, alarm_type, alarm_time, alarm_port, alarm_portPoly)
502 clock_serv_t clock_serv;
503 alarm_type_t alarm_type;
504 mach_timespec_t alarm_time;
505 clock_reply_t alarm_port;
506 mach_msg_type_name_t alarm_portPoly;
507 { return clock_alarm(clock_serv, alarm_type, alarm_time, alarm_port, alarm_portPoly); }
508 #else
509 (
510 clock_serv_t clock_serv,
511 alarm_type_t alarm_type,
512 mach_timespec_t alarm_time,
513 clock_reply_t alarm_port,
514 mach_msg_type_name_t alarm_portPoly
515 );
516 #endif /* defined(LINTLIBRARY) */
517
518 /* Routine clock_alarm */
_Xclock_alarm(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)519 mig_internal novalue _Xclock_alarm
520 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
521 {
522
523 #ifdef __MigPackStructs
524 #pragma pack(4)
525 #endif
526 typedef struct {
527 mach_msg_header_t Head;
528 /* start of the kernel processed data */
529 mach_msg_body_t msgh_body;
530 mach_msg_port_descriptor_t alarm_port;
531 /* end of the kernel processed data */
532 NDR_record_t NDR;
533 alarm_type_t alarm_type;
534 mach_timespec_t alarm_time;
535 mach_msg_trailer_t trailer;
536 } Request;
537 #ifdef __MigPackStructs
538 #pragma pack()
539 #endif
540 typedef __Request__clock_alarm_t __Request;
541 typedef __Reply__clock_alarm_t Reply;
542
543 /*
544 * typedef struct {
545 * mach_msg_header_t Head;
546 * NDR_record_t NDR;
547 * kern_return_t RetCode;
548 * } mig_reply_error_t;
549 */
550
551 Request *In0P = (Request *) InHeadP;
552 Reply *OutP = (Reply *) OutHeadP;
553 #ifdef __MIG_check__Request__clock_alarm_t__defined
554 kern_return_t check_result;
555 #endif /* __MIG_check__Request__clock_alarm_t__defined */
556
557 #if __MigKernelSpecificCode
558 #else
559 #endif /* __MigKernelSpecificCode */
560 __DeclareRcvRpc(1002, "clock_alarm")
561 __BeforeRcvRpc(1002, "clock_alarm")
562 /* RetCArg=0x0 rtSimpleRequest=0 */
563
564 #if defined(__MIG_check__Request__clock_alarm_t__defined)
565 check_result = __MIG_check__Request__clock_alarm_t((__Request *)In0P);
566 if (check_result != MACH_MSG_SUCCESS)
567 { MIG_RETURN_ERROR(OutP, check_result); }
568 #endif /* defined(__MIG_check__Request__clock_alarm_t__defined) */
569
570 OutP->RetCode = clock_alarm(convert_port_to_clock(In0P->Head.msgh_request_port), In0P->alarm_type, In0P->alarm_time, In0P->alarm_port.name, In0P->alarm_port.disposition);
571 #if __MigKernelSpecificCode
572 #endif /* __MigKernelSpecificCode */
573
574 OutP->NDR = NDR_record;
575
576
577 __AfterRcvRpc(1002, "clock_alarm")
578 }
579
580
581 #ifdef mig_external
582 mig_external
583 #else
584 extern
585 #endif /* mig_external */
586 boolean_t clock_server(
587 mach_msg_header_t *InHeadP,
588 mach_msg_header_t *OutHeadP);
589
590 #ifdef mig_external
591 mig_external
592 #else
593 extern
594 #endif /* mig_external */
595 mig_routine_t clock_server_routine(
596 mach_msg_header_t *InHeadP);
597
598
599 /* Description of this subsystem, for use in direct RPC */
600 extern const struct clock_subsystem clock_subsystem;
601 const struct clock_subsystem {
602 mig_server_routine_t server; /* Server routine */
603 mach_msg_id_t start; /* Min routine number */
604 mach_msg_id_t end; /* Max routine number + 1 */
605 unsigned int maxsize; /* Max msg size */
606 vm_address_t reserved; /* Reserved */
607 struct routine_descriptor /*Array of routine descriptors */
608 routine[3];
609 } clock_subsystem = {
610 clock_server_routine,
611 1000,
612 1003,
613 (mach_msg_size_t)sizeof(union __ReplyUnion__clock_subsystem),
614 (vm_address_t)0,
615 {
616 { (mig_impl_routine_t) 0,
617 (mig_stub_routine_t) _Xclock_get_time, 2, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__clock_get_time_t) },
618 { (mig_impl_routine_t) 0,
619 (mig_stub_routine_t) _Xclock_get_attributes, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__clock_get_attributes_t) },
620 { (mig_impl_routine_t) 0,
621 (mig_stub_routine_t) _Xclock_alarm, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__clock_alarm_t) },
622 }
623 };
624
clock_server(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)625 mig_external boolean_t clock_server
626 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
627 {
628 /*
629 * typedef struct {
630 * mach_msg_header_t Head;
631 * NDR_record_t NDR;
632 * kern_return_t RetCode;
633 * } mig_reply_error_t;
634 */
635
636 register mig_routine_t routine;
637
638 OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
639 OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
640 /* Minimal size: routine() will update it if different */
641 OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
642 OutHeadP->msgh_local_port = MACH_PORT_NULL;
643 OutHeadP->msgh_id = InHeadP->msgh_id + 100;
644
645 if ((InHeadP->msgh_id > 1002) || (InHeadP->msgh_id < 1000) ||
646 ((routine = clock_subsystem.routine[InHeadP->msgh_id - 1000].stub_routine) == 0)) {
647 ((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
648 ((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
649 return FALSE;
650 }
651 (*routine) (InHeadP, OutHeadP);
652 return TRUE;
653 }
654
clock_server_routine(mach_msg_header_t * InHeadP)655 mig_external mig_routine_t clock_server_routine
656 (mach_msg_header_t *InHeadP)
657 {
658 register int msgh_id;
659
660 msgh_id = InHeadP->msgh_id - 1000;
661
662 if ((msgh_id > 2) || (msgh_id < 0))
663 return 0;
664
665 return clock_subsystem.routine[msgh_id].stub_routine;
666 }
667