home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / GNUSRC.Z / makeUser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-14  |  12.7 KB  |  462 lines
  1. #include "config.h"
  2. #include "next/make.h"
  3. #include <mach/mach_types.h>
  4. #include <mach/message.h>
  5. #include <mach/mig_errors.h>
  6. #include <mach/msg_type.h>
  7. #if    !defined(KERNEL) && !defined(MIG_NO_STRINGS)
  8. #if defined (NEXT_PDO) && !defined (_WIN32)
  9. #include <string.h>
  10. #else
  11. #include <strings.h>
  12. #endif
  13. #endif
  14. /* LINTLIBRARY */
  15.  
  16. extern port_t mig_get_reply_port();
  17. extern void mig_dealloc_reply_port();
  18.  
  19. #ifndef    mig_internal
  20. #define    mig_internal    static
  21. #endif
  22.  
  23. #ifndef    TypeCheck
  24. #define    TypeCheck 1
  25. #endif
  26.  
  27. #ifndef    UseExternRCSId
  28. #ifdef    hc
  29. #define    UseExternRCSId        1
  30. #endif
  31. #endif
  32.  
  33. #ifndef    UseStaticMsgType
  34. #if    !defined(hc) || defined(__STDC__)
  35. #define    UseStaticMsgType    1
  36. #endif
  37. #endif
  38.  
  39. #define msg_request_port    msg_remote_port
  40. #define msg_reply_port        msg_local_port
  41.  
  42.  
  43. /* SimpleRoutine alert_old */
  44. mig_external kern_return_t make_alert_old (
  45.     port_t makePort,
  46.     int eventType,
  47.     make_string_t functionName,
  48.     unsigned int functionNameCnt,
  49.     make_string_t fileName,
  50.     unsigned int fileNameCnt,
  51.     int line,
  52.     make_string_t message,
  53.     unsigned int messageCnt)
  54. {
  55.     typedef struct {
  56.         msg_header_t Head;
  57.         msg_type_t eventTypeType;
  58.         int eventType;
  59.         msg_type_t functionNameType;
  60.         char functionName[1024];
  61.         msg_type_t fileNameType;
  62.         char fileName[1024];
  63.         msg_type_t lineType;
  64.         int line;
  65.         msg_type_t messageType;
  66.         char message[1024];
  67.     } Request;
  68.  
  69.     union {
  70.         Request In;
  71.     } Mess;
  72.  
  73.     register Request *InP = &Mess.In;
  74.  
  75.     unsigned int msg_size = 52;
  76.     /* Maximum request size 3124 */
  77.     unsigned int msg_size_delta;
  78.  
  79. #if    UseStaticMsgType
  80.     static const msg_type_t eventTypeType = {
  81.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  82.         /* msg_type_size = */        32,
  83.         /* msg_type_number = */        1,
  84.         /* msg_type_inline = */        TRUE,
  85.         /* msg_type_longform = */    FALSE,
  86.         /* msg_type_deallocate = */    FALSE,
  87.         /* msg_type_unused = */        0,
  88.     };
  89. #endif    UseStaticMsgType
  90.  
  91. #if    UseStaticMsgType
  92.     static const msg_type_t functionNameType = {
  93.         /* msg_type_name = */        MSG_TYPE_CHAR,
  94.         /* msg_type_size = */        8,
  95.         /* msg_type_number = */        1024,
  96.         /* msg_type_inline = */        TRUE,
  97.         /* msg_type_longform = */    FALSE,
  98.         /* msg_type_deallocate = */    FALSE,
  99.         /* msg_type_unused = */        0,
  100.     };
  101. #endif    UseStaticMsgType
  102.  
  103. #if    UseStaticMsgType
  104.     static const msg_type_t fileNameType = {
  105.         /* msg_type_name = */        MSG_TYPE_CHAR,
  106.         /* msg_type_size = */        8,
  107.         /* msg_type_number = */        1024,
  108.         /* msg_type_inline = */        TRUE,
  109.         /* msg_type_longform = */    FALSE,
  110.         /* msg_type_deallocate = */    FALSE,
  111.         /* msg_type_unused = */        0,
  112.     };
  113. #endif    UseStaticMsgType
  114.  
  115. #if    UseStaticMsgType
  116.     static const msg_type_t lineType = {
  117.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  118.         /* msg_type_size = */        32,
  119.         /* msg_type_number = */        1,
  120.         /* msg_type_inline = */        TRUE,
  121.         /* msg_type_longform = */    FALSE,
  122.         /* msg_type_deallocate = */    FALSE,
  123.         /* msg_type_unused = */        0,
  124.     };
  125. #endif    UseStaticMsgType
  126.  
  127. #if    UseStaticMsgType
  128.     static const msg_type_t messageType = {
  129.         /* msg_type_name = */        MSG_TYPE_CHAR,
  130.         /* msg_type_size = */        8,
  131.         /* msg_type_number = */        1024,
  132.         /* msg_type_inline = */        TRUE,
  133.         /* msg_type_longform = */    FALSE,
  134.         /* msg_type_deallocate = */    FALSE,
  135.         /* msg_type_unused = */        0,
  136.     };
  137. #endif    UseStaticMsgType
  138.  
  139. #if    UseStaticMsgType
  140.     InP->eventTypeType = eventTypeType;
  141. #else    UseStaticMsgType
  142.     InP->eventTypeType.msg_type_name = MSG_TYPE_INTEGER_32;
  143.     InP->eventTypeType.msg_type_size = 32;
  144.     InP->eventTypeType.msg_type_number = 1;
  145.     InP->eventTypeType.msg_type_inline = TRUE;
  146.     InP->eventTypeType.msg_type_longform = FALSE;
  147.     InP->eventTypeType.msg_type_deallocate = FALSE;
  148. #endif    UseStaticMsgType
  149.  
  150.     InP->eventType /* eventType */ = /* eventType */ eventType;
  151.  
  152. #if    UseStaticMsgType
  153.     InP->functionNameType = functionNameType;
  154. #else    UseStaticMsgType
  155.     InP->functionNameType.msg_type_name = MSG_TYPE_CHAR;
  156.     InP->functionNameType.msg_type_size = 8;
  157.     InP->functionNameType.msg_type_inline = TRUE;
  158.     InP->functionNameType.msg_type_longform = FALSE;
  159.     InP->functionNameType.msg_type_deallocate = FALSE;
  160. #endif    UseStaticMsgType
  161.  
  162.     if (functionNameCnt > 1024)
  163.         return MIG_ARRAY_TOO_LARGE;
  164.     bcopy((char *) functionName, (char *) InP->functionName, 1 * functionNameCnt);
  165.  
  166.     InP->functionNameType.msg_type_number /* functionNameCnt */ = /* functionNameType.msg_type_number */ functionNameCnt;
  167.  
  168.     msg_size_delta = (1 * functionNameCnt + 3) & ~3;
  169.     msg_size += msg_size_delta;
  170.     InP = (Request *) ((char *) InP + msg_size_delta - 1024);
  171.  
  172. #if    UseStaticMsgType
  173.     InP->fileNameType = fileNameType;
  174. #else    UseStaticMsgType
  175.     InP->fileNameType.msg_type_name = MSG_TYPE_CHAR;
  176.     InP->fileNameType.msg_type_size = 8;
  177.     InP->fileNameType.msg_type_inline = TRUE;
  178.     InP->fileNameType.msg_type_longform = FALSE;
  179.     InP->fileNameType.msg_type_deallocate = FALSE;
  180. #endif    UseStaticMsgType
  181.  
  182.     if (fileNameCnt > 1024)
  183.         return MIG_ARRAY_TOO_LARGE;
  184.     bcopy((char *) fileName, (char *) InP->fileName, 1 * fileNameCnt);
  185.  
  186.     InP->fileNameType.msg_type_number /* fileNameCnt */ = /* fileNameType.msg_type_number */ fileNameCnt;
  187.  
  188.     msg_size_delta = (1 * fileNameCnt + 3) & ~3;
  189.     msg_size += msg_size_delta;
  190.     InP = (Request *) ((char *) InP + msg_size_delta - 1024);
  191.  
  192. #if    UseStaticMsgType
  193.     InP->lineType = lineType;
  194. #else    UseStaticMsgType
  195.     InP->lineType.msg_type_name = MSG_TYPE_INTEGER_32;
  196.     InP->lineType.msg_type_size = 32;
  197.     InP->lineType.msg_type_number = 1;
  198.     InP->lineType.msg_type_inline = TRUE;
  199.     InP->lineType.msg_type_longform = FALSE;
  200.     InP->lineType.msg_type_deallocate = FALSE;
  201. #endif    UseStaticMsgType
  202.  
  203.     InP->line /* line */ = /* line */ line;
  204.  
  205. #if    UseStaticMsgType
  206.     InP->messageType = messageType;
  207. #else    UseStaticMsgType
  208.     InP->messageType.msg_type_name = MSG_TYPE_CHAR;
  209.     InP->messageType.msg_type_size = 8;
  210.     InP->messageType.msg_type_inline = TRUE;
  211.     InP->messageType.msg_type_longform = FALSE;
  212.     InP->messageType.msg_type_deallocate = FALSE;
  213. #endif    UseStaticMsgType
  214.  
  215.     if (messageCnt > 1024)
  216.         return MIG_ARRAY_TOO_LARGE;
  217.     bcopy((char *) message, (char *) InP->message, 1 * messageCnt);
  218.  
  219.     InP->messageType.msg_type_number /* messageCnt */ = /* messageType.msg_type_number */ messageCnt;
  220.  
  221.     msg_size_delta = (1 * messageCnt + 3) & ~3;
  222.     msg_size += msg_size_delta;
  223.  
  224.     InP = &Mess.In;
  225.     InP->Head.msg_simple = TRUE;
  226.     InP->Head.msg_size = msg_size;
  227.     InP->Head.msg_type = MSG_TYPE_NORMAL;
  228.     InP->Head.msg_request_port = makePort;
  229.     InP->Head.msg_reply_port = PORT_NULL;
  230.     InP->Head.msg_id = 100;
  231.  
  232.     return msg_send(&InP->Head, MSG_OPTION_NONE, 0);
  233. }
  234.  
  235. /* SimpleRoutine alert */
  236. mig_external kern_return_t make_alert (
  237.     port_t makePort,
  238.     int eventType,
  239.     make_string_t functionName,
  240.     unsigned int functionNameCnt,
  241.     make_string_t fileName,
  242.     unsigned int fileNameCnt,
  243.     make_string_t directory,
  244.     unsigned int directoryCnt,
  245.     int line,
  246.     make_string_t message,
  247.     unsigned int messageCnt)
  248. {
  249.     typedef struct {
  250.         msg_header_t Head;
  251.         msg_type_t eventTypeType;
  252.         int eventType;
  253.         msg_type_t functionNameType;
  254.         char functionName[1024];
  255.         msg_type_t fileNameType;
  256.         char fileName[1024];
  257.         msg_type_t directoryType;
  258.         char directory[1024];
  259.         msg_type_t lineType;
  260.         int line;
  261.         msg_type_t messageType;
  262.         char message[1024];
  263.     } Request;
  264.  
  265.     union {
  266.         Request In;
  267.     } Mess;
  268.  
  269.     register Request *InP = &Mess.In;
  270.  
  271.     unsigned int msg_size = 56;
  272.     /* Maximum request size 4152 */
  273.     unsigned int msg_size_delta;
  274.  
  275. #if    UseStaticMsgType
  276.     static const msg_type_t eventTypeType = {
  277.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  278.         /* msg_type_size = */        32,
  279.         /* msg_type_number = */        1,
  280.         /* msg_type_inline = */        TRUE,
  281.         /* msg_type_longform = */    FALSE,
  282.         /* msg_type_deallocate = */    FALSE,
  283.         /* msg_type_unused = */        0,
  284.     };
  285. #endif    UseStaticMsgType
  286.  
  287. #if    UseStaticMsgType
  288.     static const msg_type_t functionNameType = {
  289.         /* msg_type_name = */        MSG_TYPE_CHAR,
  290.         /* msg_type_size = */        8,
  291.         /* msg_type_number = */        1024,
  292.         /* msg_type_inline = */        TRUE,
  293.         /* msg_type_longform = */    FALSE,
  294.         /* msg_type_deallocate = */    FALSE,
  295.         /* msg_type_unused = */        0,
  296.     };
  297. #endif    UseStaticMsgType
  298.  
  299. #if    UseStaticMsgType
  300.     static const msg_type_t fileNameType = {
  301.         /* msg_type_name = */        MSG_TYPE_CHAR,
  302.         /* msg_type_size = */        8,
  303.         /* msg_type_number = */        1024,
  304.         /* msg_type_inline = */        TRUE,
  305.         /* msg_type_longform = */    FALSE,
  306.         /* msg_type_deallocate = */    FALSE,
  307.         /* msg_type_unused = */        0,
  308.     };
  309. #endif    UseStaticMsgType
  310.  
  311. #if    UseStaticMsgType
  312.     static const msg_type_t directoryType = {
  313.         /* msg_type_name = */        MSG_TYPE_CHAR,
  314.         /* msg_type_size = */        8,
  315.         /* msg_type_number = */        1024,
  316.         /* msg_type_inline = */        TRUE,
  317.         /* msg_type_longform = */    FALSE,
  318.         /* msg_type_deallocate = */    FALSE,
  319.         /* msg_type_unused = */        0,
  320.     };
  321. #endif    UseStaticMsgType
  322.  
  323. #if    UseStaticMsgType
  324.     static const msg_type_t lineType = {
  325.         /* msg_type_name = */        MSG_TYPE_INTEGER_32,
  326.         /* msg_type_size = */        32,
  327.         /* msg_type_number = */        1,
  328.         /* msg_type_inline = */        TRUE,
  329.         /* msg_type_longform = */    FALSE,
  330.         /* msg_type_deallocate = */    FALSE,
  331.         /* msg_type_unused = */        0,
  332.     };
  333. #endif    UseStaticMsgType
  334.  
  335. #if    UseStaticMsgType
  336.     static const msg_type_t messageType = {
  337.         /* msg_type_name = */        MSG_TYPE_CHAR,
  338.         /* msg_type_size = */        8,
  339.         /* msg_type_number = */        1024,
  340.         /* msg_type_inline = */        TRUE,
  341.         /* msg_type_longform = */    FALSE,
  342.         /* msg_type_deallocate = */    FALSE,
  343.         /* msg_type_unused = */        0,
  344.     };
  345. #endif    UseStaticMsgType
  346.  
  347. #if    UseStaticMsgType
  348.     InP->eventTypeType = eventTypeType;
  349. #else    UseStaticMsgType
  350.     InP->eventTypeType.msg_type_name = MSG_TYPE_INTEGER_32;
  351.     InP->eventTypeType.msg_type_size = 32;
  352.     InP->eventTypeType.msg_type_number = 1;
  353.     InP->eventTypeType.msg_type_inline = TRUE;
  354.     InP->eventTypeType.msg_type_longform = FALSE;
  355.     InP->eventTypeType.msg_type_deallocate = FALSE;
  356. #endif    UseStaticMsgType
  357.  
  358.     InP->eventType /* eventType */ = /* eventType */ eventType;
  359.  
  360. #if    UseStaticMsgType
  361.     InP->functionNameType = functionNameType;
  362. #else    UseStaticMsgType
  363.     InP->functionNameType.msg_type_name = MSG_TYPE_CHAR;
  364.     InP->functionNameType.msg_type_size = 8;
  365.     InP->functionNameType.msg_type_inline = TRUE;
  366.     InP->functionNameType.msg_type_longform = FALSE;
  367.     InP->functionNameType.msg_type_deallocate = FALSE;
  368. #endif    UseStaticMsgType
  369.  
  370.     if (functionNameCnt > 1024)
  371.         return MIG_ARRAY_TOO_LARGE;
  372.     bcopy((char *) functionName, (char *) InP->functionName, 1 * functionNameCnt);
  373.  
  374.     InP->functionNameType.msg_type_number /* functionNameCnt */ = /* functionNameType.msg_type_number */ functionNameCnt;
  375.  
  376.     msg_size_delta = (1 * functionNameCnt + 3) & ~3;
  377.     msg_size += msg_size_delta;
  378.     InP = (Request *) ((char *) InP + msg_size_delta - 1024);
  379.  
  380. #if    UseStaticMsgType
  381.     InP->fileNameType = fileNameType;
  382. #else    UseStaticMsgType
  383.     InP->fileNameType.msg_type_name = MSG_TYPE_CHAR;
  384.     InP->fileNameType.msg_type_size = 8;
  385.     InP->fileNameType.msg_type_inline = TRUE;
  386.     InP->fileNameType.msg_type_longform = FALSE;
  387.     InP->fileNameType.msg_type_deallocate = FALSE;
  388. #endif    UseStaticMsgType
  389.  
  390.     if (fileNameCnt > 1024)
  391.         return MIG_ARRAY_TOO_LARGE;
  392.     bcopy((char *) fileName, (char *) InP->fileName, 1 * fileNameCnt);
  393.  
  394.     InP->fileNameType.msg_type_number /* fileNameCnt */ = /* fileNameType.msg_type_number */ fileNameCnt;
  395.  
  396.     msg_size_delta = (1 * fileNameCnt + 3) & ~3;
  397.     msg_size += msg_size_delta;
  398.     InP = (Request *) ((char *) InP + msg_size_delta - 1024);
  399.  
  400. #if    UseStaticMsgType
  401.     InP->directoryType = directoryType;
  402. #else    UseStaticMsgType
  403.     InP->directoryType.msg_type_name = MSG_TYPE_CHAR;
  404.     InP->directoryType.msg_type_size = 8;
  405.     InP->directoryType.msg_type_inline = TRUE;
  406.     InP->directoryType.msg_type_longform = FALSE;
  407.     InP->directoryType.msg_type_deallocate = FALSE;
  408. #endif    UseStaticMsgType
  409.  
  410.     if (directoryCnt > 1024)
  411.         return MIG_ARRAY_TOO_LARGE;
  412.     bcopy((char *) directory, (char *) InP->directory, 1 * directoryCnt);
  413.  
  414.     InP->directoryType.msg_type_number /* directoryCnt */ = /* directoryType.msg_type_number */ directoryCnt;
  415.  
  416.     msg_size_delta = (1 * directoryCnt + 3) & ~3;
  417.     msg_size += msg_size_delta;
  418.     InP = (Request *) ((char *) InP + msg_size_delta - 1024);
  419.  
  420. #if    UseStaticMsgType
  421.     InP->lineType = lineType;
  422. #else    UseStaticMsgType
  423.     InP->lineType.msg_type_name = MSG_TYPE_INTEGER_32;
  424.     InP->lineType.msg_type_size = 32;
  425.     InP->lineType.msg_type_number = 1;
  426.     InP->lineType.msg_type_inline = TRUE;
  427.     InP->lineType.msg_type_longform = FALSE;
  428.     InP->lineType.msg_type_deallocate = FALSE;
  429. #endif    UseStaticMsgType
  430.  
  431.     InP->line /* line */ = /* line */ line;
  432.  
  433. #if    UseStaticMsgType
  434.     InP->messageType = messageType;
  435. #else    UseStaticMsgType
  436.     InP->messageType.msg_type_name = MSG_TYPE_CHAR;
  437.     InP->messageType.msg_type_size = 8;
  438.     InP->messageType.msg_type_inline = TRUE;
  439.     InP->messageType.msg_type_longform = FALSE;
  440.     InP->messageType.msg_type_deallocate = FALSE;
  441. #endif    UseStaticMsgType
  442.  
  443.     if (messageCnt > 1024)
  444.         return MIG_ARRAY_TOO_LARGE;
  445.     bcopy((char *) message, (char *) InP->message, 1 * messageCnt);
  446.  
  447.     InP->messageType.msg_type_number /* messageCnt */ = /* messageType.msg_type_number */ messageCnt;
  448.  
  449.     msg_size_delta = (1 * messageCnt + 3) & ~3;
  450.     msg_size += msg_size_delta;
  451.  
  452.     InP = &Mess.In;
  453.     InP->Head.msg_simple = TRUE;
  454.     InP->Head.msg_size = msg_size;
  455.     InP->Head.msg_type = MSG_TYPE_NORMAL;
  456.     InP->Head.msg_request_port = makePort;
  457.     InP->Head.msg_reply_port = PORT_NULL;
  458.     InP->Head.msg_id = 101;
  459.  
  460.     return msg_send(&InP->Head, MSG_OPTION_NONE, 0);
  461. }
  462.