home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / mach / doc / unpublished / mig_example / randomServer.c.Z / randomServer.c
Encoding:
C/C++ Source or Header  |  1989-11-01  |  16.9 KB  |  697 lines
  1. /* Module random */
  2.  
  3. #define EXPORT_BOOLEAN
  4. #include <mach/boolean.h>
  5. #include <mach/message.h>
  6. #include <mach/mig_errors.h>
  7.  
  8. #ifndef    mig_internal
  9. #define    mig_internal    static
  10. #endif
  11.  
  12. #ifndef    TypeCheck
  13. #define    TypeCheck 1
  14. #endif
  15.  
  16. #ifndef    UseExternRCSId
  17. #ifdef    hc
  18. #define    UseExternRCSId        1
  19. #endif
  20. #endif
  21.  
  22. #ifndef    UseStaticMsgType
  23. #if    !defined(hc) || defined(__STDC__)
  24. #define    UseStaticMsgType    1
  25. #endif
  26. #endif
  27.  
  28. /* Due to pcc compiler bug, cannot use void */
  29. #if    (defined(__STDC__) || defined(c_plusplus)) || defined(hc)
  30. #define novalue void
  31. #else
  32. #define novalue int
  33. #endif
  34.  
  35. #define msg_request_port    msg_local_port
  36. #define msg_reply_port        msg_remote_port
  37. #include <mach/std_types.h>
  38. #include "random_types.h"
  39.  
  40. /* Procedure init_seed */
  41. mig_internal novalue _Xinit_seed
  42. #if    (defined(__STDC__) || defined(c_plusplus))
  43.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  44. #else
  45.     (InHeadP, OutHeadP)
  46.     msg_header_t *InHeadP, *OutHeadP;
  47. #endif
  48. {
  49.     typedef struct {
  50.         msg_header_t Head;
  51.         msg_type_t seedType;
  52.         dbl seed;
  53.     } Request;
  54.  
  55.     typedef struct {
  56.         msg_header_t Head;
  57.         msg_type_t RetCodeType;
  58.         kern_return_t RetCode;
  59.     } Reply;
  60.  
  61.     register Request *In0P = (Request *) InHeadP;
  62.     register Reply *OutP = (Reply *) OutHeadP;
  63.     extern void init_seed
  64. #if    (defined(__STDC__) || defined(c_plusplus))
  65.         (port_t server_port, dbl seed);
  66. #else
  67.         ();
  68. #endif
  69.  
  70. #if    TypeCheck
  71.     boolean_t msg_simple;
  72. #endif    TypeCheck
  73.  
  74.     unsigned int msg_size;
  75.  
  76. #if    UseStaticMsgType
  77.     static msg_type_t seedCheck = {
  78.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  79.         /* msg_type_size = */        32,
  80.         /* msg_type_number = */        2,
  81.         /* msg_type_inline = */        TRUE,
  82.         /* msg_type_longform = */    FALSE,
  83.         /* msg_type_deallocate = */    FALSE,
  84.         /* msg_type_unused = */    0,
  85.     };
  86. #endif    UseStaticMsgType
  87.  
  88. #if    TypeCheck
  89.     msg_size = In0P->Head.msg_size;
  90.     msg_simple = In0P->Head.msg_simple;
  91.     if ((msg_size != 36) || (msg_simple != TRUE))
  92.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  93. #endif    TypeCheck
  94.  
  95. #if    TypeCheck
  96. #if    UseStaticMsgType
  97.     if (* (int *) &In0P->seedType != * (int *) &seedCheck)
  98. #else    UseStaticMsgType
  99.     if ((In0P->seedType.msg_type_inline != TRUE) ||
  100.         (In0P->seedType.msg_type_longform != FALSE) ||
  101.         (In0P->seedType.msg_type_name != MSG_TYPE_INTEGER_32) ||
  102.         (In0P->seedType.msg_type_number != 2) ||
  103.         (In0P->seedType.msg_type_size != 32))
  104. #endif    UseStaticMsgType
  105.         { OutP->RetCode = MIG_BAD_ARGUMENTS; goto punt0; }
  106. #endif    TypeCheck
  107.  
  108.     init_seed(In0P->Head.msg_request_port, In0P->seed);
  109.     OutP->RetCode = KERN_SUCCESS;
  110. punt0:
  111.     if (OutP->RetCode != KERN_SUCCESS)
  112.         return;
  113.  
  114.     msg_size = 32;
  115.  
  116.     OutP->Head.msg_simple = TRUE;
  117.     OutP->Head.msg_size = msg_size;
  118. }
  119.  
  120. /* Function get_randomf */
  121. mig_internal novalue _Xget_randomf
  122. #if    (defined(__STDC__) || defined(c_plusplus))
  123.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  124. #else
  125.     (InHeadP, OutHeadP)
  126.     msg_header_t *InHeadP, *OutHeadP;
  127. #endif
  128. {
  129.     typedef struct {
  130.         msg_header_t Head;
  131.     } Request;
  132.  
  133.     typedef struct {
  134.         msg_header_t Head;
  135.         msg_type_t RetCodeType;
  136.         kern_return_t RetCode;
  137.         msg_type_t get_randomfType;
  138.         int get_randomf;
  139.     } Reply;
  140.  
  141.     register Request *In0P = (Request *) InHeadP;
  142.     register Reply *OutP = (Reply *) OutHeadP;
  143.     extern int get_randomf
  144. #if    (defined(__STDC__) || defined(c_plusplus))
  145.         (port_t server_port);
  146. #else
  147.         ();
  148. #endif
  149.  
  150. #if    TypeCheck
  151.     boolean_t msg_simple;
  152. #endif    TypeCheck
  153.  
  154.     unsigned int msg_size;
  155.  
  156. #if    UseStaticMsgType
  157.     static msg_type_t get_randomfType = {
  158.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  159.         /* msg_type_size = */        32,
  160.         /* msg_type_number = */        1,
  161.         /* msg_type_inline = */        TRUE,
  162.         /* msg_type_longform = */    FALSE,
  163.         /* msg_type_deallocate = */    FALSE,
  164.         /* msg_type_unused = */    0,
  165.     };
  166. #endif    UseStaticMsgType
  167.  
  168. #if    TypeCheck
  169.     msg_size = In0P->Head.msg_size;
  170.     msg_simple = In0P->Head.msg_simple;
  171.     if ((msg_size != 24) || (msg_simple != TRUE))
  172.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  173. #endif    TypeCheck
  174.  
  175.     OutP->get_randomf = get_randomf(In0P->Head.msg_request_port);
  176.     OutP->RetCode = KERN_SUCCESS;
  177. punt0:
  178.     if (OutP->RetCode != KERN_SUCCESS)
  179.         return;
  180.  
  181.     msg_size = 40;
  182.  
  183. #if    UseStaticMsgType
  184.     OutP->get_randomfType = get_randomfType;
  185. #else    UseStaticMsgType
  186.     OutP->get_randomfType.msg_type_name = MSG_TYPE_INTEGER_32;
  187.     OutP->get_randomfType.msg_type_size = 32;
  188.     OutP->get_randomfType.msg_type_number = 1;
  189.     OutP->get_randomfType.msg_type_inline = TRUE;
  190.     OutP->get_randomfType.msg_type_longform = FALSE;
  191.     OutP->get_randomfType.msg_type_deallocate = FALSE;
  192.     OutP->get_randomfType.msg_type_unused = 0;
  193. #endif    UseStaticMsgType
  194.  
  195.     OutP->Head.msg_simple = TRUE;
  196.     OutP->Head.msg_size = msg_size;
  197. }
  198.  
  199. /* Routine get_random */
  200. mig_internal novalue _Xget_random
  201. #if    (defined(__STDC__) || defined(c_plusplus))
  202.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  203. #else
  204.     (InHeadP, OutHeadP)
  205.     msg_header_t *InHeadP, *OutHeadP;
  206. #endif
  207. {
  208.     typedef struct {
  209.         msg_header_t Head;
  210.     } Request;
  211.  
  212.     typedef struct {
  213.         msg_header_t Head;
  214.         msg_type_t RetCodeType;
  215.         kern_return_t RetCode;
  216.         msg_type_t numType;
  217.         int num;
  218.     } Reply;
  219.  
  220.     register Request *In0P = (Request *) InHeadP;
  221.     register Reply *OutP = (Reply *) OutHeadP;
  222.     extern kern_return_t get_random
  223. #if    (defined(__STDC__) || defined(c_plusplus))
  224.         (port_t server_port, int *num);
  225. #else
  226.         ();
  227. #endif
  228.  
  229. #if    TypeCheck
  230.     boolean_t msg_simple;
  231. #endif    TypeCheck
  232.  
  233.     unsigned int msg_size;
  234.  
  235. #if    UseStaticMsgType
  236.     static msg_type_t numType = {
  237.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  238.         /* msg_type_size = */        32,
  239.         /* msg_type_number = */        1,
  240.         /* msg_type_inline = */        TRUE,
  241.         /* msg_type_longform = */    FALSE,
  242.         /* msg_type_deallocate = */    FALSE,
  243.         /* msg_type_unused = */    0,
  244.     };
  245. #endif    UseStaticMsgType
  246.  
  247. #if    TypeCheck
  248.     msg_size = In0P->Head.msg_size;
  249.     msg_simple = In0P->Head.msg_simple;
  250.     if ((msg_size != 24) || (msg_simple != TRUE))
  251.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  252. #endif    TypeCheck
  253.  
  254.     OutP->RetCode = get_random(In0P->Head.msg_request_port, &OutP->num);
  255. punt0:
  256.     if (OutP->RetCode != KERN_SUCCESS)
  257.         return;
  258.  
  259.     msg_size = 40;
  260.  
  261. #if    UseStaticMsgType
  262.     OutP->numType = numType;
  263. #else    UseStaticMsgType
  264.     OutP->numType.msg_type_name = MSG_TYPE_INTEGER_32;
  265.     OutP->numType.msg_type_size = 32;
  266.     OutP->numType.msg_type_number = 1;
  267.     OutP->numType.msg_type_inline = TRUE;
  268.     OutP->numType.msg_type_longform = FALSE;
  269.     OutP->numType.msg_type_deallocate = FALSE;
  270.     OutP->numType.msg_type_unused = 0;
  271. #endif    UseStaticMsgType
  272.  
  273.     OutP->Head.msg_simple = TRUE;
  274.     OutP->Head.msg_size = msg_size;
  275. }
  276.  
  277. /* Routine get_secret */
  278. mig_internal novalue _Xget_secret
  279. #if    (defined(__STDC__) || defined(c_plusplus))
  280.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  281. #else
  282.     (InHeadP, OutHeadP)
  283.     msg_header_t *InHeadP, *OutHeadP;
  284. #endif
  285. {
  286.     typedef struct {
  287.         msg_header_t Head;
  288.         msg_type_t passwordType;
  289.         string25 password;
  290.         char passwordPad[3];
  291.     } Request;
  292.  
  293.     typedef struct {
  294.         msg_header_t Head;
  295.         msg_type_t RetCodeType;
  296.         kern_return_t RetCode;
  297.         msg_type_t passwordType;
  298.         string25 password;
  299.         char passwordPad[3];
  300.     } Reply;
  301.  
  302.     register Request *In0P = (Request *) InHeadP;
  303.     register Reply *OutP = (Reply *) OutHeadP;
  304.     extern kern_return_t get_secret
  305. #if    (defined(__STDC__) || defined(c_plusplus))
  306.         (port_t server_port, string25 password);
  307. #else
  308.         ();
  309. #endif
  310.  
  311. #if    TypeCheck
  312.     boolean_t msg_simple;
  313. #endif    TypeCheck
  314.  
  315.     unsigned int msg_size;
  316.  
  317. #if    UseStaticMsgType
  318.     static msg_type_t passwordCheck = {
  319.         /* msg_type_name = */        MSG_TYPE_STRING,
  320.         /* msg_type_size = */        200,
  321.         /* msg_type_number = */        1,
  322.         /* msg_type_inline = */        TRUE,
  323.         /* msg_type_longform = */    FALSE,
  324.         /* msg_type_deallocate = */    FALSE,
  325.         /* msg_type_unused = */    0,
  326.     };
  327. #endif    UseStaticMsgType
  328.  
  329. #if    UseStaticMsgType
  330.     static msg_type_t passwordType = {
  331.         /* msg_type_name = */        MSG_TYPE_STRING,
  332.         /* msg_type_size = */        200,
  333.         /* msg_type_number = */        1,
  334.         /* msg_type_inline = */        TRUE,
  335.         /* msg_type_longform = */    FALSE,
  336.         /* msg_type_deallocate = */    FALSE,
  337.         /* msg_type_unused = */    0,
  338.     };
  339. #endif    UseStaticMsgType
  340.  
  341. #if    TypeCheck
  342.     msg_size = In0P->Head.msg_size;
  343.     msg_simple = In0P->Head.msg_simple;
  344.     if ((msg_size != 56) || (msg_simple != TRUE))
  345.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  346. #endif    TypeCheck
  347.  
  348. #if    TypeCheck
  349. #if    UseStaticMsgType
  350.     if (* (int *) &In0P->passwordType != * (int *) &passwordCheck)
  351. #else    UseStaticMsgType
  352.     if ((In0P->passwordType.msg_type_inline != TRUE) ||
  353.         (In0P->passwordType.msg_type_longform != FALSE) ||
  354.         (In0P->passwordType.msg_type_name != MSG_TYPE_STRING) ||
  355.         (In0P->passwordType.msg_type_number != 1) ||
  356.         (In0P->passwordType.msg_type_size != 200))
  357. #endif    UseStaticMsgType
  358.         { OutP->RetCode = MIG_BAD_ARGUMENTS; goto punt0; }
  359. #endif    TypeCheck
  360.  
  361.     OutP->RetCode = get_secret(In0P->Head.msg_request_port, In0P->password);
  362. punt0:
  363.     if (OutP->RetCode != KERN_SUCCESS)
  364.         return;
  365.  
  366.     msg_size = 64;
  367.  
  368. #if    UseStaticMsgType
  369.     OutP->passwordType = passwordType;
  370. #else    UseStaticMsgType
  371.     OutP->passwordType.msg_type_name = MSG_TYPE_STRING;
  372.     OutP->passwordType.msg_type_size = 200;
  373.     OutP->passwordType.msg_type_number = 1;
  374.     OutP->passwordType.msg_type_inline = TRUE;
  375.     OutP->passwordType.msg_type_longform = FALSE;
  376.     OutP->passwordType.msg_type_deallocate = FALSE;
  377.     OutP->passwordType.msg_type_unused = 0;
  378. #endif    UseStaticMsgType
  379.  
  380.     (void) mig_strncpy(/* 0 */ OutP->password, In0P->password, 25);
  381.     /* 0 */ OutP->password[24] = '\0';
  382.  
  383.     OutP->Head.msg_simple = TRUE;
  384.     OutP->Head.msg_size = msg_size;
  385. }
  386.  
  387. /* Routine get_confidential */
  388. mig_internal novalue _Xget_confidential
  389. #if    (defined(__STDC__) || defined(c_plusplus))
  390.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  391. #else
  392.     (InHeadP, OutHeadP)
  393.     msg_header_t *InHeadP, *OutHeadP;
  394. #endif
  395. {
  396.     typedef struct {
  397.         msg_header_t Head;
  398.     } Request;
  399.  
  400.     typedef struct {
  401.         msg_header_t Head;
  402.         msg_type_t RetCodeType;
  403.         kern_return_t RetCode;
  404.         msg_type_long_t dataType;
  405.         page_ptr data;
  406.     } Reply;
  407.  
  408.     register Request *In0P = (Request *) InHeadP;
  409.     register Reply *OutP = (Reply *) OutHeadP;
  410.     extern kern_return_t get_confidential
  411. #if    (defined(__STDC__) || defined(c_plusplus))
  412.         (port_t server_port, page_ptr *data);
  413. #else
  414.         ();
  415. #endif
  416.  
  417. #if    TypeCheck
  418.     boolean_t msg_simple;
  419. #endif    TypeCheck
  420.  
  421.     unsigned int msg_size;
  422.  
  423. #if    UseStaticMsgType
  424.     static msg_type_long_t dataType = {
  425.     {
  426.         /* msg_type_name = */        0,
  427.         /* msg_type_size = */        0,
  428.         /* msg_type_number = */        0,
  429.         /* msg_type_inline = */        FALSE,
  430.         /* msg_type_longform = */    TRUE,
  431.         /* msg_type_deallocate = */    TRUE,
  432.         /* msg_type_unused = */    0,
  433.     },
  434.         /* msg_type_long_name = */    MSG_TYPE_INTEGER_32,
  435.         /* msg_type_long_size = */    32,
  436.         /* msg_type_long_number = */    4096,
  437.     };
  438. #endif    UseStaticMsgType
  439.  
  440. #if    TypeCheck
  441.     msg_size = In0P->Head.msg_size;
  442.     msg_simple = In0P->Head.msg_simple;
  443.     if ((msg_size != 24) || (msg_simple != TRUE))
  444.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  445. #endif    TypeCheck
  446.  
  447.     OutP->RetCode = get_confidential(In0P->Head.msg_request_port, &OutP->data);
  448. punt0:
  449.     if (OutP->RetCode != KERN_SUCCESS)
  450.         return;
  451.  
  452.     msg_size = 48;
  453.  
  454. #if    UseStaticMsgType
  455.     OutP->dataType = dataType;
  456. #else    UseStaticMsgType
  457.     OutP->dataType.msg_type_long_name = MSG_TYPE_INTEGER_32;
  458.     OutP->dataType.msg_type_long_size = 32;
  459.     OutP->dataType.msg_type_long_number = 4096;
  460.     OutP->dataType.msg_type_header.msg_type_inline = FALSE;
  461.     OutP->dataType.msg_type_header.msg_type_longform = TRUE;
  462.     OutP->dataType.msg_type_header.msg_type_deallocate = TRUE;
  463.     OutP->dataType.msg_type_header.msg_type_unused = 0;
  464. #endif    UseStaticMsgType
  465.  
  466.     OutP->Head.msg_simple = FALSE;
  467.     OutP->Head.msg_size = msg_size;
  468. }
  469.  
  470. /* SimpleRoutine use_random */
  471. mig_internal novalue _Xuse_random
  472. #if    (defined(__STDC__) || defined(c_plusplus))
  473.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  474. #else
  475.     (InHeadP, OutHeadP)
  476.     msg_header_t *InHeadP, *OutHeadP;
  477. #endif
  478. {
  479.     typedef struct {
  480.         msg_header_t Head;
  481.         msg_type_t info_seedType;
  482.         string80 info_seed;
  483.         msg_type_t infoType;
  484.         comp_arr info;
  485.         msg_type_long_t info_1Type;
  486.         words info_1;
  487.     } Request;
  488.  
  489.     typedef struct {
  490.         msg_header_t Head;
  491.         msg_type_t RetCodeType;
  492.         kern_return_t RetCode;
  493.     } Reply;
  494.  
  495.     register Request *In0P = (Request *) InHeadP;
  496.     register Reply *OutP = (Reply *) OutHeadP;
  497.     extern kern_return_t use_random
  498. #if    (defined(__STDC__) || defined(c_plusplus))
  499.         (port_t server_port, string80 info_seed, comp_arr info, words info_1, unsigned int info_1Cnt);
  500. #else
  501.         ();
  502. #endif
  503.  
  504. #if    TypeCheck
  505.     boolean_t msg_simple;
  506. #endif    TypeCheck
  507.  
  508.     unsigned int msg_size;
  509.  
  510. #if    UseStaticMsgType
  511.     static msg_type_t info_seedCheck = {
  512.         /* msg_type_name = */        MSG_TYPE_CHAR,
  513.         /* msg_type_size = */        8,
  514.         /* msg_type_number = */        80,
  515.         /* msg_type_inline = */        TRUE,
  516.         /* msg_type_longform = */    FALSE,
  517.         /* msg_type_deallocate = */    FALSE,
  518.         /* msg_type_unused = */    0,
  519.     };
  520. #endif    UseStaticMsgType
  521.  
  522. #if    UseStaticMsgType
  523.     static msg_type_t infoCheck = {
  524.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  525.         /* msg_type_size = */        32,
  526.         /* msg_type_number = */        2560,
  527.         /* msg_type_inline = */        TRUE,
  528.         /* msg_type_longform = */    FALSE,
  529.         /* msg_type_deallocate = */    FALSE,
  530.         /* msg_type_unused = */    0,
  531.     };
  532. #endif    UseStaticMsgType
  533.  
  534. #if    TypeCheck
  535.     msg_size = In0P->Head.msg_size;
  536.     msg_simple = In0P->Head.msg_simple;
  537.     if ((msg_size != 10368) || (msg_simple != FALSE))
  538.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  539. #endif    TypeCheck
  540.  
  541. #if    TypeCheck
  542. #if    UseStaticMsgType
  543.     if (* (int *) &In0P->info_seedType != * (int *) &info_seedCheck)
  544. #else    UseStaticMsgType
  545.     if ((In0P->info_seedType.msg_type_inline != TRUE) ||
  546.         (In0P->info_seedType.msg_type_longform != FALSE) ||
  547.         (In0P->info_seedType.msg_type_name != MSG_TYPE_CHAR) ||
  548.         (In0P->info_seedType.msg_type_number != 80) ||
  549.         (In0P->info_seedType.msg_type_size != 8))
  550. #endif    UseStaticMsgType
  551.         { OutP->RetCode = MIG_BAD_ARGUMENTS; goto punt0; }
  552. #endif    TypeCheck
  553.  
  554. #if    TypeCheck
  555. #if    UseStaticMsgType
  556.     if (* (int *) &In0P->infoType != * (int *) &infoCheck)
  557. #else    UseStaticMsgType
  558.     if ((In0P->infoType.msg_type_inline != TRUE) ||
  559.         (In0P->infoType.msg_type_longform != FALSE) ||
  560.         (In0P->infoType.msg_type_name != MSG_TYPE_INTEGER_32) ||
  561.         (In0P->infoType.msg_type_number != 2560) ||
  562.         (In0P->infoType.msg_type_size != 32))
  563. #endif    UseStaticMsgType
  564.         { OutP->RetCode = MIG_BAD_ARGUMENTS; goto punt0; }
  565. #endif    TypeCheck
  566.  
  567. #if    TypeCheck
  568.     if ((In0P->info_1Type.msg_type_header.msg_type_inline != FALSE) ||
  569.         (In0P->info_1Type.msg_type_header.msg_type_longform != TRUE) ||
  570.         (In0P->info_1Type.msg_type_long_name != MSG_TYPE_INTEGER_32) ||
  571.         (In0P->info_1Type.msg_type_long_size != 32))
  572.         { OutP->RetCode = MIG_BAD_ARGUMENTS; goto punt0; }
  573. #endif    TypeCheck
  574.  
  575.     (void) use_random(In0P->Head.msg_request_port, In0P->info_seed, In0P->info, In0P->info_1, In0P->info_1Type.msg_type_long_number);
  576.     OutP->RetCode = MIG_NO_REPLY;
  577. punt0:
  578.     ;
  579. }
  580.  
  581. /* SimpleProcedure exit */
  582. mig_internal novalue _Xexit
  583. #if    (defined(__STDC__) || defined(c_plusplus))
  584.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  585. #else
  586.     (InHeadP, OutHeadP)
  587.     msg_header_t *InHeadP, *OutHeadP;
  588. #endif
  589. {
  590.     typedef struct {
  591.         msg_header_t Head;
  592.     } Request;
  593.  
  594.     typedef struct {
  595.         msg_header_t Head;
  596.         msg_type_t RetCodeType;
  597.         kern_return_t RetCode;
  598.     } Reply;
  599.  
  600.     register Request *In0P = (Request *) InHeadP;
  601.     register Reply *OutP = (Reply *) OutHeadP;
  602.     extern void exit
  603. #if    (defined(__STDC__) || defined(c_plusplus))
  604.         (port_t server_port);
  605. #else
  606.         ();
  607. #endif
  608.  
  609. #if    TypeCheck
  610.     boolean_t msg_simple;
  611. #endif    TypeCheck
  612.  
  613.     unsigned int msg_size;
  614.  
  615. #if    TypeCheck
  616.     msg_size = In0P->Head.msg_size;
  617.     msg_simple = In0P->Head.msg_simple;
  618.     if ((msg_size != 24) || (msg_simple != TRUE))
  619.         { OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
  620. #endif    TypeCheck
  621.  
  622.     exit(In0P->Head.msg_request_port);
  623.     OutP->RetCode = MIG_NO_REPLY;
  624. punt0:
  625.     ;
  626. }
  627.  
  628. boolean_t random_server
  629. #if    (defined(__STDC__) || defined(c_plusplus))
  630.     (msg_header_t *InHeadP, msg_header_t *OutHeadP)
  631. #else
  632.     (InHeadP, OutHeadP)
  633.     msg_header_t *InHeadP, *OutHeadP;
  634. #endif
  635. {
  636.     register msg_header_t *InP =  InHeadP;
  637.     register death_pill_t *OutP = (death_pill_t *) OutHeadP;
  638.  
  639. #if    UseStaticMsgType
  640.     static msg_type_t RetCodeType = {
  641.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  642.         /* msg_type_size = */        32,
  643.         /* msg_type_number = */        1,
  644.         /* msg_type_inline = */        TRUE,
  645.         /* msg_type_longform = */    FALSE,
  646.         /* msg_type_deallocate = */    FALSE,
  647.         /* msg_type_unused = */    0,
  648.     };
  649. #endif    UseStaticMsgType
  650.  
  651.     OutP->Head.msg_simple = TRUE;
  652.     OutP->Head.msg_size = sizeof *OutP;
  653.     OutP->Head.msg_type = InP->msg_type;
  654.     OutP->Head.msg_local_port = PORT_NULL;
  655.     OutP->Head.msg_remote_port = InP->msg_reply_port;
  656.     OutP->Head.msg_id = InP->msg_id + 100;
  657.  
  658. #if    UseStaticMsgType
  659.     OutP->RetCodeType = RetCodeType;
  660. #else    UseStaticMsgType
  661.     OutP->RetCodeType.msg_type_name = MSG_TYPE_INTEGER_32;
  662.     OutP->RetCodeType.msg_type_size = 32;
  663.     OutP->RetCodeType.msg_type_number = 1;
  664.     OutP->RetCodeType.msg_type_inline = TRUE;
  665.     OutP->RetCodeType.msg_type_longform = FALSE;
  666.     OutP->RetCodeType.msg_type_deallocate = FALSE;
  667.     OutP->RetCodeType.msg_type_unused = 0;
  668. #endif    UseStaticMsgType
  669.     OutP->RetCode = MIG_BAD_ID;
  670.  
  671.     if ((InP->msg_id > 506) || (InP->msg_id < 500))
  672.         return FALSE;
  673.     else {
  674.         typedef novalue (*SERVER_STUB_PROC)
  675. #if    (defined(__STDC__) || defined(c_plusplus))
  676.             (msg_header_t *, msg_header_t *);
  677. #else
  678.             ();
  679. #endif
  680.         static SERVER_STUB_PROC routines[] = {
  681.             _Xinit_seed,
  682.             _Xget_randomf,
  683.             _Xget_random,
  684.             _Xget_secret,
  685.             _Xget_confidential,
  686.             _Xuse_random,
  687.             _Xexit,
  688.         };
  689.  
  690.         if (routines[InP->msg_id - 500])
  691.             (routines[InP->msg_id - 500]) (InP, &OutP->Head);
  692.          else
  693.             return FALSE;
  694.     }
  695.     return TRUE;
  696. }
  697.