bootstrap_cmds/migcom.tproj/user.c

bootstrap_cmds source @ c71d2d7 2025-04-30 · 3255 lines · view on GitHub
1/*
* Copyright (c) 1999-2018 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
23/*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
* CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
*  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
*  School of Computer Science
*  Carnegie Mellon University
*  Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
48
49#include <stdlib.h>
50#include <assert.h>
51
52#include <mach/message.h>
53#include "write.h"
54#include "error.h"
55#include "utils.h"
56#include "global.h"
57
58#ifndef USE_IMMEDIATE_SEND_TIMEOUT
59#define USE_IMMEDIATE_SEND_TIMEOUT 0
60#endif
61
62char *MessAllocRoutine = "mig_user_allocate";
63char *MessFreeRoutine = "mig_user_deallocate";
64
65char stRetCode[] = "ReturnValue";
66char stRetNone[] = "";
67
68void WriteLogDefines(FILE *file, string_t who);
69void WriteIdentificationString(FILE *file);
70
71static void
72WriteKPD_Iterator(FILE *file, boolean_t in, boolean_t overwrite, boolean_t varying, argument_t *arg, boolean_t bracket)
73{
ipc_type_t *it = arg->argType;
char string[MAX_STR_LEN];
76
fprintf(file, "\t{\n");
fprintf(file, "\t    %s\t*ptr;\n", it->itKPDType);
fprintf(file, "\t    int\ti");
if (varying && !in)
  fprintf(file, ", j");
fprintf(file, ";\n\n");
83
if (in)
  sprintf(string, "InP");
else if (overwrite)
  sprintf(string, "InOvTemplate");
else
  sprintf(string, "Out%dP", arg->argRequestPos);
90
fprintf(file, "\t    ptr = &%s->%s[0];\n", string, arg->argMsgField);
92
if (varying) {
  argument_t *count = arg->argCount;
  char *cref = count->argByReferenceUser ? "*" : "";
96
  if (in || overwrite) {
    fprintf(file, "\t    if (%s%s > %d)\n", cref, count->argVarName, it->itKPD_Number);
    WriteReturnMsgError(file, arg->argRoutine, TRUE, arg, "MIG_ARRAY_TOO_LARGE");
    fprintf(file, "\t    for (i = 0; i < %s%s; ptr++, i++) %s\n", cref, count->argVarName, (bracket) ? "{" : "");
  }
  else {
    fprintf(file, "\t    j = min(Out%dP->%s, %s%s);\n", count->argReplyPos, count->argVarName, cref, count->argVarName);
    fprintf(file, "\t    for (i = 0; i < j; ptr++, i++) %s\n",(bracket) ? "{" : "");
105}
}
else
  fprintf(file, "\t    for (i = 0; i < %d; ptr++, i++) %s\n", it->itKPD_Number, (bracket) ? "{" : "");
109}
110
111/*************************************************************
* Writes the standard includes. The subsystem specific
* includes  are in <SubsystemName>.h and writen by
* header:WriteHeader. Called by WriteProlog.
*************************************************************/
116static void
117WriteMyIncludes(FILE *file, statement_t *stats)
118{
119#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelServer)
{
  /*
   * We want to get the user-side definitions of types
   * like task_t, ipc_space_t, etc. in mach/mach_types.h.
   */
126
  fprintf(file, "#undef\tMACH_KERNEL\n");
128
  if (InternalHeaderFileName != strNULL)
  {
    char *cp;
132
    /* Strip any leading path from InternalHeaderFileName. */
    cp = strrchr(InternalHeaderFileName, '/');
    if (cp == 0)
      cp = InternalHeaderFileName;
    else
      cp++; /* skip '/' */
    fprintf(file, "#include \"%s\"\n", cp);
  }
}
142#endif
143
if (UserHeaderFileName == strNULL || UseSplitHeaders)
  WriteIncludes(file, TRUE, FALSE);
if (UserHeaderFileName != strNULL)
{
  char *cp;
149
  /* Strip any leading path from UserHeaderFileName. */
  cp = strrchr(UserHeaderFileName, '/');
  if (cp == 0)
    cp = UserHeaderFileName;
  else
    cp++; /* skip '/' */
  fprintf(file, "#include \"%s\"\n", cp);
}
if (UseSplitHeaders)
  WriteImplImports(file, stats, TRUE);
160
if (UseEventLogger) {
  if (IsKernelUser) {
    fprintf(file, "#if\t__MigKernelSpecificCode\n");
    fprintf(file, "#include <mig_debug.h>\n");
    fprintf(file, "#endif\t/* __MigKernelSpecificCode */\n");
  }
  fprintf(file, "#if  MIG_DEBUG\n");
  fprintf(file, "#include <mach/mig_log.h>\n");
  fprintf(file, "#endif /* MIG_DEBUG */\n");
}
if (HasConsumeOnSendError && !IsKernelUser) {
  fprintf(file, "#include <mach/mach.h>\n");
}
if (BeLint) {
  fprintf(file, "/* LINTLIBRARY */\n");
}
fprintf(file, "\n");
if (!BeAnsiC) {
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "#else\t/* %s */\n", NewCDecl);
  fprintf(file, "extern mach_port_t mig_get_reply_port();\n");
  fprintf(file, "extern void mig_dealloc_reply_port();\n");
  fprintf(file, "extern char *%s();\n", MessAllocRoutine);
  fprintf(file, "extern void %s();\n", MessFreeRoutine);
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
if (HasUseSpecialReplyPort) {
  fprintf(file, "\n");
  fprintf(file, "#include <TargetConditionals.h>\n");
  fprintf(file, "#include <mach/mach_sync_ipc.h>\n");
  fprintf(file, "#ifndef __MigSpecialReplyPortMsgOption\n");
  fprintf(file, "#define __MigSpecialReplyPortMsgOption "
    "(MACH_SEND_SYNC_OVERRIDE|MACH_SEND_SYNC_USE_THRPRI|MACH_RCV_SYNC_WAIT)\n");
  fprintf(file, "#endif /* __MigSpecialReplyPortMsgOption */\n");
}
if (IsKernelServer) {
  fprintf(file, "\n");
  fprintf(file, "#include <TargetConditionals.h>\n");
  fprintf(file, "#if defined(MACH_SEND_AUX_TOO_SMALL) && (defined(__arm64__) || defined(__LP64__))\n");
  fprintf(file, "#undef mach_msg\n");
  fprintf(file, "#define mach_msg mig_mach_msg\n");
  fprintf(file, "static inline mach_msg_return_t\n");
  fprintf(file, "mig_mach_msg(\n");
  fprintf(file, "\tmach_msg_header_t *msg,\n");
  fprintf(file, "\tmach_msg_option_t option,\n");
  fprintf(file, "\tmach_msg_size_t send_size,\n");
  fprintf(file, "\tmach_msg_size_t rcv_size,\n");
  fprintf(file, "\tmach_port_name_t rcv_name,\n");
  fprintf(file, "\tmach_msg_timeout_t timeout,\n");
  fprintf(file, "\tmach_port_name_t notify)\n");
  fprintf(file, "{\n");
  fprintf(file, "\t(void)notify;\n");
  fprintf(file, "\treturn mach_msg2(msg, option | MACH64_SEND_KOBJECT_CALL,\n");
  fprintf(file, "\t\t*msg, send_size, rcv_size, rcv_name, timeout, 0);\n");
  fprintf(file, "}\n");
  fprintf(file, "#endif\n");
}
/*
 * extern the definition of mach_msg_destroy
 * (to avoid inserting mach/mach.h everywhere)
 */
fprintf(file, "/* TODO: #include <mach/mach.h> */\n");
fprintf(file, "#ifdef __cplusplus\nextern \"C\" {\n#endif /* __cplusplus */\n");
fprintf(file, "extern void mach_msg_destroy(mach_msg_header_t *);\n");
fprintf(file, "#ifdef __cplusplus\n}\n#endif /* __cplusplus */\n");
226
fprintf(file, "\n");
228}
229
230static void
231WriteGlobalDecls(FILE *file)
232{
if (RCSId != strNULL)
  WriteRCSDecl(file, strconcat(SubsystemName, "_user"), RCSId);
235
fprintf(file, "#define msgh_request_port\tmsgh_remote_port\n");
fprintf(file, "#define msgh_reply_port\t\tmsgh_local_port\n");
fprintf(file, "\n");
if (UseEventLogger)
  WriteLogDefines(file, "MACH_MSG_LOG_USER");
fprintf(file, "\n");
242}
243
244static void
245WriteOneMachErrorDefine(FILE *file, char *name, boolean_t timeout, boolean_t SpecialReplyPort)
246{
fprintf(file, "#ifndef\t%s\n", name);
fprintf(file, "#define\t%s(_R_) { \\\n", name);
fprintf(file, "\tswitch (_R_) { \\\n");
fprintf(file, "\tcase MACH_SEND_INVALID_DATA: \\\n");
fprintf(file, "\tcase MACH_SEND_INVALID_DEST: \\\n");
fprintf(file, "\tcase MACH_SEND_INVALID_HEADER: \\\n");
if (!SpecialReplyPort) {
  fprintf(file, "\t\tmig_put_reply_port(InP->Head.msgh_reply_port); \\\n");
}
fprintf(file, "\t\tbreak; \\\n");
if (timeout) {
 fprintf(file, "\tcase MACH_SEND_TIMED_OUT: \\\n");
 fprintf(file, "\tcase MACH_RCV_TIMED_OUT: \\\n");
}
fprintf(file, "\tdefault: \\\n");
if (SpecialReplyPort) {
  fprintf(file, "\t\tmig_dealloc_special_reply_port(InP->Head.msgh_reply_port); \\\n");
} else {
  fprintf(file, "\t\tmig_dealloc_reply_port(InP->Head.msgh_reply_port); \\\n");
}
fprintf(file, "\t} \\\n}\n");
fprintf(file, "#endif\t/* %s */\n", name);
fprintf(file, "\n");
270}
271
272static void
273WriteMachErrorDefines(FILE *file)
274{
WriteOneMachErrorDefine(file, "__MachMsgErrorWithTimeout", TRUE, FALSE);
WriteOneMachErrorDefine(file, "__MachMsgErrorWithoutTimeout", FALSE, FALSE);
if (HasUseSpecialReplyPort) {
  WriteOneMachErrorDefine(file, "__MachMsgErrorWithTimeoutSRP", TRUE, TRUE);
  WriteOneMachErrorDefine(file, "__MachMsgErrorWithoutTimeoutSRP", FALSE, TRUE);
}
281}
282
283static void
284WriteMIGCheckDefines(FILE *file)
285{
fprintf(file, "#define\t__MIG_check__Reply__%s_subsystem__ 1\n", SubsystemName);
fprintf(file, "\n");
288}
289
290static void
291WriteNDRDefines(FILE *file)
292{
fprintf(file, "#define\t__NDR_convert__Reply__%s_subsystem__ 1\n", SubsystemName);
fprintf(file, "#define\t__NDR_convert__mig_reply_error_subsystem__ 1\n");
fprintf(file, "\n");
296}
297
298/*************************************************************
* Writes the standard #includes, #defines, and
* RCS declaration. Called by WriteUser.
*************************************************************/
302static void
303WriteProlog(FILE *file, statement_t *stats)
304{
WriteIdentificationString(file);
WriteMIGCheckDefines(file);
if (CheckNDR)
 WriteNDRDefines(file);
WriteMyIncludes(file, stats);
WriteBogusDefines(file);
WriteMachErrorDefines(file);
WriteApplDefaults(file, "Send");
WriteGlobalDecls(file);
314}
315
316/*ARGSUSED*/
317static void
318WriteEpilog(FILE *file)
319{
/* nothing to see here, move along... */
321}
322
323static string_t
324WriteHeaderPortType(argument_t *arg)
325{
if (arg->argType->itInName == MACH_MSG_TYPE_POLYMORPHIC)
  return arg->argPoly->argVarName;
else
  return arg->argType->itInNameStr;
330}
331
332static void
333WriteRequestHead(FILE *file, routine_t *rt)
334{
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest)
  fprintf(file, "ready_to_send:\n");
337
if (rt->rtMaxRequestPos > 0) {
  if (rt->rtOverwrite)
    fprintf(file, "\tInP = &MessRequest;\n");
  else
    fprintf(file, "\tInP = &Mess%sIn;\n", (rtMessOnStack(rt) ? "." : "->"));
}
344
if (akCheck(rt->rtReplyPort->argKind, akbUserArg)) {
346#ifdef MIG_KERNEL_PORT_CONVERSION
  if (IsKernelUser)
    fprintf(file, "\tInP->%s = (mach_port_t) %s;\n", rt->rtReplyPort->argMsgField, rt->rtReplyPort->argVarName);
  else
350#endif
    fprintf(file, "\tInP->%s = %s;\n", rt->rtReplyPort->argMsgField, rt->rtReplyPort->argVarName);
}
else if (rt->rtOneWay)
  fprintf(file, "\tInP->%s = MACH_PORT_NULL;\n", rt->rtReplyPort->argMsgField);
else if (rt->rtUseSpecialReplyPort)
  fprintf(file, "\tInP->%s = mig_get_special_reply_port();\n", rt->rtReplyPort->argMsgField);
else
  fprintf(file, "\tInP->%s = mig_get_reply_port();\n", rt->rtReplyPort->argMsgField);
359
fprintf(file, "\tInP->Head.msgh_bits =");
if (rt->rtRetCArg == argNULL && !rt->rtSimpleRequest)
  fprintf(file, " MACH_MSGH_BITS_COMPLEX|");
fprintf(file, "\n");
fprintf(file, "\t\tMACH_MSGH_BITS(%s, %s);\n", WriteHeaderPortType(rt->rtRequestPort), WriteHeaderPortType(rt->rtReplyPort));
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  fprintf(file, "\tif (!%s)\n", rt->rtRetCArg->argVarName);
  fprintf(file, "\t\tInP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;\n");
}
369
if (!IsKernelServer) {
  fprintf(file, "\t/* msgh_size passed as argument */\n");
} else if (rt->rtNumRequestVar == 0) {
  fprintf(file, "\tInP->Head.msgh_size = (mach_msg_size_t)sizeof(Request);\n");
} else {
  fprintf(file, "\tInP->Head.msgh_size = msgh_size;\n");
}
377
/*
 * KernelUser stubs need to cast the request and reply ports
 * from ipc_port_t to mach_port_t.
 */
382
383#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelUser)
  fprintf(file, "\tInP->%s = (mach_port_t) %s;\n", rt->rtRequestPort->argMsgField, rt->rtRequestPort->argVarName);
else
387#endif
  fprintf(file, "\tInP->%s = %s;\n", rt->rtRequestPort->argMsgField, rt->rtRequestPort->argVarName);
389
fprintf(file, "\tInP->Head.msgh_id = %d;\n", rt->rtNumber + SubsystemBase);
fprintf(file, "\tInP->Head.msgh_reserved = 0;\n");
392
393
if (IsVoucherCodeAllowed && !IsKernelUser && !IsKernelServer) {
  fprintf(file, "\t\n/* BEGIN VOUCHER CODE */\n\n");
  fprintf(file, "#ifdef USING_VOUCHERS\n");
  fprintf(file, "\tif (voucher_mach_msg_set != NULL) {\n");
  fprintf(file, "\t\tvoucher_mach_msg_set(&InP->Head);\n");
  fprintf(file, "\t}\n");
  fprintf(file, "#endif // USING_VOUCHERS\n");
  fprintf(file, "\t\n/* END VOUCHER CODE */\n");
}
403}
404
405/*************************************************************
*  Writes declarations for the message types, variables
*  and return  variable if needed. Called by WriteRoutine.
*************************************************************/
409static void
410WriteVarDecls(FILE *file, routine_t *rt)
411{
int i;
413
if (rt->rtOverwrite) {
  fprintf(file, "\tRequest MessRequest;\n");
  fprintf(file, "\tRequest *InP = &MessRequest;\n\n");
417
  fprintf(file, "\tunion {\n");
  fprintf(file, "\t\tOverwriteTemplate In;\n");
  fprintf(file, "\t\tReply Out;\n");
  fprintf(file, "\t} MessReply;\n");
422
  fprintf(file, "\tOverwriteTemplate *InOvTemplate = &MessReply.In;\n");
  fprintf(file, "\tReply *Out0P = &MessReply.Out;\n");
  for (i = 1; i <= rt->rtMaxReplyPos; i++)
    fprintf(file, "\t" "Reply *Out%dP = NULL;\n", i);
}
else {
  if (rtMessOnStack(rt))
    fprintf(file, "\tunion {\n");
  else
    fprintf(file, "\tunion %sMessU {\n", rt->rtName);
  fprintf(file, "\t\tRequest In;\n");
  if (!rt->rtOneWay)
    fprintf(file, "\t\tReply Out;\n");
  if (rtMessOnStack(rt))
    fprintf(file, "\t} Mess;\n");
  else
    fprintf(file, "\t} *Mess = (union %sMessU *) %s(sizeof(*Mess));\n",
            rt->rtName, MessAllocRoutine);
  fprintf(file, "\n");
442
  fprintf(file, "\tRequest *InP = &Mess%sIn;\n", (rtMessOnStack(rt) ? "." : "->"));
  if (!rt->rtOneWay) {
    fprintf(file, "\tReply *Out0P = &Mess%sOut;\n", (rtMessOnStack(rt) ? "." : "->"));
    for (i = 1; i <= rt->rtMaxReplyPos; i++)
      fprintf(file, "\t" "Reply *Out%dP = NULL;\n", i);
  }
}
450
fprintf(file, "\n");
452
fprintf(file, "\tmach_msg_return_t msg_result;\n");
454
/* if request is variable, we need msgh_size_delta and msgh_size */
if (rt->rtNumRequestVar > 0)
  fprintf(file, "\tunsigned int msgh_size;\n");
if (rt->rtMaxRequestPos > 0)
  fprintf(file, "\tunsigned int msgh_size_delta;\n");
if (rt->rtNumRequestVar > 1 || rt->rtMaxRequestPos > 0)
  fprintf(file, "\n");
462
if (rt->rtUserImpl) {
  fprintf(file, "\tmach_msg_max_trailer_t *TrailerP;\n");
  fprintf(file, "#if\t__MigTypeCheck\n");
  fprintf(file, "\tunsigned int trailer_size __attribute__((unused));\n");
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
fprintf(file, "\n");
fprintf(file, "#ifdef\t__MIG_check__Reply__%s_t__defined\n", rt->rtName);
fprintf(file, "\tkern_return_t check_result;\n");
fprintf(file, "#endif\t/* __MIG_check__Reply__%s_t__defined */\n", rt->rtName);
fprintf(file, "\n");
WriteApplMacro(file, "Send", "Declare", rt);
fprintf(file, "\n");
476}
477
478static void
479WriteReturn(FILE *file, routine_t *rt, char *before, char *value, char *after, boolean_t deallocate_mess)
480{
if (rtMessOnStack(rt)) {
  if (value != stRetCode) {
    /* get the easy case (no braces needed) out of the way */
    fprintf(file, "%sreturn%s%s;%s", before, (*value ? " " : ""), value, after);
    return;
  }
  else {
    fprintf(file, "%s{\n", before);
    fprintf(file, "%s\treturn Out0P->RetCode;\n%s}%s", before, before, after);
    return;
  }
}
493
if (value == stRetCode) {
  fprintf(file, "%s{\n%s\t%s ReturnValue;\n", before, before, ReturnTypeStr(rt));
  fprintf(file, "%s\tReturnValue = Out0P->RetCode;\n%s\t", before, before);
}
else {
  fprintf(file, "%s{ ", before);
}
501
if (deallocate_mess) {
  fprintf(file, "%s((char *) Mess, sizeof(*Mess)); ", MessFreeRoutine);
}
505
if (value == stRetCode)
  fprintf(file, "return ReturnValue;\n%s}%s", before, after);
else if (value == stRetNone)
  fprintf(file, "return; }%s", after);
else
  fprintf(file, "return %s; }%s", value, after);
512}
513
514static void
515WriteRetCodeArg(FILE *file, routine_t *rt)
516{
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  argument_t *arg = rt->rtRetCArg;
519
  fprintf(file, "\tif (%s) {\n", arg->argVarName);
  fprintf(file, "\t\t((mig_reply_error_t *)InP)->RetCode = %s;\n", arg->argVarName);
  fprintf(file, "\t\t((mig_reply_error_t *)InP)->NDR = NDR_record;\n");
  fprintf(file, "\t\tgoto ready_to_send;\n");
  fprintf(file, "\t}\n\n");
}
526}
527
528/*************************************************************
*   Writes the logic to check for a message send timeout, and
*   deallocate any relocated ool data so as not to leak.
*************************************************************/
532static void
533WriteMsgCheckForSendErrors(FILE *file, routine_t *rt)
534{
if (rt->rtConsumeOnSendError != ConsumeOnSendErrorAny && rt->rtWaitTime == argNULL) {
  return;
}
538
if (rt->rtConsumeOnSendError == ConsumeOnSendErrorAny) {
  // other errors mean the kernel consumed some of the rights
  // and we can't possibly know if there's something left to destroy
  fputs("\n"
        "\t"    "if (msg_result == MACH_SEND_INVALID_DEST ||" "\n"
        "\t\t"    "msg_result == MACH_SEND_TIMED_OUT) {" "\n", file);
} else {
  fputs("\n"
        "\t"    "if (msg_result == MACH_SEND_TIMED_OUT) {" "\n", file);
}
549
if (rt->rtConsumeOnSendError == ConsumeOnSendErrorNone) {
    argument_t  *arg_ptr;
552
  // iterate over arg list
  for (arg_ptr = rt->rtArgs; arg_ptr != NULL; arg_ptr = arg_ptr->argNext) {
555
    //  if argument contains ool data
    if (akCheck(arg_ptr->argKind, akbSendKPD) && arg_ptr->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
      //    generate code to test current arg address vs. address before the msg_send call
      //    if not at the same address, mig_deallocate the argument
      fprintf(file, "\t\t"    "if((vm_offset_t) InP->%s.address != (vm_offset_t) %s)\n",
              arg_ptr->argVarName, arg_ptr->argVarName);
      fprintf(file, "\t\t\t"    "mig_deallocate((vm_offset_t) InP->%s.address, "
              "(vm_size_t) InP->%s.size);\n", arg_ptr->argVarName, arg_ptr->argVarName);
    }
  }
} else {
  /*
   * The original MIG would leak most resources on send timeout without
   * leaving a chance for callers to know how to dispose of most of the
   * resources, as the caller can't possibly guess the new names
   * picked during pseudo-receive.
   */
  if (IsKernelUser) {
    fputs("#if\t__MigKernelSpecificCode" "\n", file);
    fputs("\t\t"    "mach_msg_destroy_from_kernel(&InP->Head);" "\n", file);
    fputs("#endif\t/* __MigKernelSpecificCode */" "\n", file);
  } else {
    fputs("\t\t"    "/* mach_msg_destroy doesn't handle the local port */" "\n", file);
    fputs("\t\t"    "switch (MACH_MSGH_BITS_LOCAL(InP->Head.msgh_bits)) {" "\n", file);
    fputs("\t\t"    "case MACH_MSG_TYPE_MOVE_SEND:" "\n", file);
    fputs("\t\t\t"    "mach_port_deallocate(mach_task_self(), InP->Head.msgh_local_port);" "\n", file);
    fputs("\t\t\t"    "break;" "\n", file);
    fputs("\t\t"    "}" "\n", file);
    fputs("\t\t"    "mach_msg_destroy(&InP->Head);" "\n", file);
  }
}
587
fputs("\t"  "}" "\n\n", file);
return;
590}
591
592/*************************************************************
*   Writes the send call when there is to be no subsequent
*   receive. Called by WriteRoutine SimpleRoutines
*************************************************************/
596static void
597WriteMsgSend(FILE *file, routine_t *rt)
598{
char *SendSize = "";
char string[MAX_STR_LEN];
601
if (rt->rtNumRequestVar == 0)
  SendSize = "(mach_msg_size_t)sizeof(Request)";
else
  SendSize = "msgh_size";
606
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  sprintf(string, "(%s) ? (mach_msg_size_t)sizeof(mig_reply_error_t) : ", rt->rtRetCArg->argVarName);
  SendSize = strconcat(string, SendSize);
}
611
if (IsKernelUser) {
  fprintf(file, "#if\t__MigKernelSpecificCode\n");
  fprintf(file, "\tmsg_result = mach_msg_send_from_kernel(");
  fprintf(file, "&InP->Head, %s);\n", SendSize);
  fprintf(file, "#else\n");
}
fprintf(file, "\tmsg_result = mach_msg("
        "&InP->Head, MACH_SEND_MSG|%s%s, %s, 0, MACH_PORT_NULL, %s, MACH_PORT_NULL);\n",
        rt->rtWaitTime !=argNULL ? "MACH_SEND_TIMEOUT|" : "",
        rt->rtMsgOption->argVarName,
        SendSize,
        rt->rtWaitTime != argNULL ? rt->rtWaitTime->argVarName:"MACH_MSG_TIMEOUT_NONE");
624
if (IsKernelUser) {
  fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
}
628
WriteApplMacro(file, "Send", "After", rt);
630
WriteMsgCheckForSendErrors(file, rt);
632
WriteReturn(file, rt, "\t", "msg_result", "\n", TRUE);
634}
635
636/*************************************************************
*  Writes to code to check for error returns from receive.
*  Called by WriteMsgSendReceive and WriteMsgRPC
*************************************************************/
640static void
641WriteMsgCheckReceiveCleanupMigReplyPort(FILE *file, routine_t *rt, char *success)
642{
if (!akCheck(rt->rtReplyPort->argKind, akbUserArg))
{
  /* If we aren't using a user-supplied reply port, then
     deallocate the reply port when it is invalid or
     for TIMED_OUT errors. */
  fprintf(file, "\tif (msg_result != %s) {\n", success);
  if (rt->rtWaitTime != argNULL) {
    fprintf(file, "\t\t__MachMsgErrorWithTimeout%s(msg_result);\n",
      rt->rtUseSpecialReplyPort ? "SRP" : "");
  } else {
    fprintf(file, "\t\t__MachMsgErrorWithoutTimeout%s(msg_result);\n",
      rt->rtUseSpecialReplyPort ? "SRP" : "");
  }
  fprintf(file, "\t}\n");
}
658}
659
660static void
661WriteMsgCheckReceive(FILE *file, routine_t *rt, char *success)
662{
fprintf(file, "\tif (msg_result != %s) {\n", success);
WriteReturnMsgError(file, rt, TRUE, argNULL, "msg_result");
fprintf(file, "\t}\n");
666}
667
668/*************************************************************
*  Writes the send and receive calls and code to check
*  for errors. Normally the rpc code is generated instead
*  although, the subsytem can be compiled with the -R option
*  which will cause this code to be generated. Called by
*  WriteRoutine if UseMsgRPC option is false.
*************************************************************/
675static void
676WriteMsgSendReceive(FILE *file, routine_t *rt)
677{
char *SendSize = "";
char string[MAX_STR_LEN];
680
if (rt->rtNumRequestVar == 0)
  SendSize = "(mach_msg_size_t)sizeof(Request)";
else
  SendSize = "msgh_size";
685
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  sprintf(string, "(%s) ? (mach_msg_size_t)sizeof(mig_reply_error_t) : ", rt->rtRetCArg->argVarName);
  SendSize = strconcat(string, SendSize);
}
690
/* IsKernelUser to be done! */
fprintf(file, "\tmsg_result = mach_msg(&InP->Head, MACH_SEND_MSG|%s%s, %s, 0, ", rt->rtWaitTime != argNULL ? "MACH_SEND_TIMEOUT|" : "", rt->rtMsgOption->argVarName, SendSize);
fprintf(file, " MACH_PORT_NULL, %s, MACH_PORT_NULL);\n",
694#if !USE_IMMEDIATE_SEND_TIMEOUT
        (rt->rtWaitTime != argNULL) ? rt->rtWaitTime->argVarName :
696#endif
        "MACH_MSG_TIMEOUT_NONE");
fprintf(file, "\tif (msg_result != MACH_MSG_SUCCESS)\n");
WriteReturnMsgError(file, rt, TRUE, argNULL, "msg_result");
fprintf(file, "\n");
701
fprintf(file, "\tmsg_result = mach_msg(&Out0P->Head, MACH_RCV_MSG|%s%s%s, 0, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_local_port, %s, MACH_PORT_NULL);\n",
        rt->rtUserImpl != 0 ? "MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0)|" : "",
        (rt->rtWaitTime != argNULL && akIdent(rt->rtWaitTime->argKind) == akeWaitTime) ? "MACH_RCV_TIMEOUT|" : "",
        rt->rtMsgOption->argVarName,
        (rt->rtWaitTime != argNULL && akIdent(rt->rtWaitTime->argKind) == akeWaitTime) ? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE");
WriteApplMacro(file, "Send", "After", rt);
WriteMsgCheckReceiveCleanupMigReplyPort(file, rt, "MACH_MSG_SUCCESS");
WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS");
fprintf(file, "\n");
711}
712
713/*************************************************************
*  Writes the rpc call and the code to check for errors.
*  This is the default code to be generated. Called by WriteRoutine
*  for all routine types except SimpleRoutine.
*************************************************************/
718static void
719WriteMsgRPC(FILE *file, routine_t *rt)
720{
char *SendSize = "";
char string[MAX_STR_LEN];
723
if (rt->rtNumRequestVar == 0)
  SendSize = "(mach_msg_size_t)sizeof(Request)";
else
  SendSize = "msgh_size";
728
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  sprintf(string, "(%s) ? (mach_msg_size_t)sizeof(mig_reply_error_t) : ", rt->rtRetCArg->argVarName);
  SendSize = strconcat(string, SendSize);
}
733
if (IsKernelUser) {
  fprintf(file, "#if\t(__MigKernelSpecificCode) || (_MIG_KERNELSPECIFIC_CODE_)\n");
  fprintf(file, "\tmsg_result = mach_msg_rpc_from_kernel(&InP->Head, %s, (mach_msg_size_t)sizeof(Reply));\n", SendSize);
  fprintf(file, "#else\n");
}
if (rt->rtOverwrite) {
  fprintf(file, "\tmsg_result = mach_msg_overwrite(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_RCV_OVERWRITE|%s%s%s, %s, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, %s, MACH_PORT_NULL, ",
          rt->rtUserImpl != 0 ? "MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0)|" : "",
          rt->rtWaitTime != argNULL ?
       (akIdent(rt->rtWaitTime->argKind) == akeWaitTime ? "MACH_SEND_TIMEOUT|MACH_RCV_TIMEOUT|" : "MACH_SEND_TIMEOUT|") : "",
          rt->rtMsgOption->argVarName,
          SendSize,
          rt->rtWaitTime != argNULL? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE");
  fprintf(file, " &InOvTemplate->Head, (mach_msg_size_t)sizeof(OverwriteTemplate));\n");
}
else {
  fprintf(file, "\tmsg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|%s%s%s, %s, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, %s, MACH_PORT_NULL);\n",
          rt->rtUserImpl != 0 ? "MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0)|" : "",
          rt->rtWaitTime != argNULL ?
       (akIdent(rt->rtWaitTime->argKind) == akeWaitTime ? "MACH_SEND_TIMEOUT|MACH_RCV_TIMEOUT|" : "MACH_SEND_TIMEOUT|") : "",
          rt->rtMsgOption->argVarName,
          SendSize,
          rt->rtWaitTime != argNULL? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE");
}
if (IsKernelUser)
  fprintf(file,"#endif /* __MigKernelSpecificCode */\n");
WriteApplMacro(file, "Send", "After", rt);
761
WriteMsgCheckReceiveCleanupMigReplyPort(file, rt, "MACH_MSG_SUCCESS");
WriteMsgCheckForSendErrors(file, rt);
764
WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS");
fprintf(file, "\n");
767}
768
769/*
* argKPD_Pack discipline for Port types.
*/
772static void
773WriteKPD_port(FILE *file, argument_t *arg)
774{
ipc_type_t *it = arg->argType;
char *subindex = "";
char *recast = "";
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
char *ref = arg->argByReferenceUser ? "*" : "";
ipc_type_t *real_it;
782
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, FALSE, it->itVarArray, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  subindex = "[i]";
  real_it = it->itElement;
}
else {
  (void)sprintf(firststring, "InP->%s", arg->argMsgField);
  (void)sprintf(string, "InP->%s.", arg->argMsgField);
  real_it = it;
}
795
796#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelUser && streql(real_it->itUserType, "ipc_port_t"))
  recast = "(mach_port_t)";
799#endif
fprintf(file, "#if\tUseStaticTemplates\n");
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
/* ref is required also in the Request part, because of inout parameters */
fprintf(file, "\t%sname = %s%s%s%s;\n", string, recast, ref, arg->argVarName, subindex);
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbSendSnd)) {
  argument_t *poly = arg->argPoly;
806
  fprintf(file, "\t%sdisposition = %s%s;\n", string, poly->argByReferenceUser ? "*" : "", poly->argVarName);
}
fprintf(file, "#else\t/* UseStaticTemplates */\n");
fprintf(file, "\t%sname = %s%s%s%s;\n", string, recast, ref, arg->argVarName, subindex);
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbSendSnd)) {
  argument_t *poly = arg->argPoly;
813
  fprintf(file, "\t%sdisposition = %s%s;\n", string, poly->argByReferenceUser ? "*" : "", poly->argVarName);
}
else
  fprintf(file, "\t%sdisposition = %s;\n", string, it->itInNameStr);
fprintf(file, "\t%stype = MACH_MSG_PORT_DESCRIPTOR;\n", string);
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
if (IS_MULTIPLE_KPD(it))  {
  fprintf(file, "\t    }\n");
  if (it->itVarArray) {
    fprintf(file, "\t    for (i = %s; i < %d; ptr++, i++) {\n", arg->argCount->argVarName, it->itKPD_Number);
    /* fill the rest of the statically allocated KPD entries with MACH_PORT_NULL */
    fprintf(file, "#if\tUseStaticTemplates\n");
    fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
    fprintf(file, "#else\t/* UseStaticTemplates */\n");
    fprintf(file, "\t%sname = MACH_PORT_NULL;\n", string);
    fprintf(file, "\t%stype = MACH_MSG_PORT_DESCRIPTOR;\n", string);
    fprintf(file, "#endif\t/* UseStaticTemplates */\n");
    fprintf(file, "\t    }\n");
  }
  fprintf(file, "\t}\n");
}
fprintf(file, "\n");
836}
837
838static void
839WriteKPD_ool_varsize(FILE *file, argument_t *arg, char *who, char *where, boolean_t iscomplex)
840{
ipc_type_t *it = arg->argType;
argument_t *count;
char *cref;
844
if (iscomplex) {
  it = it->itElement;
  count = arg->argSubCount;
}
else
  count = arg->argCount;
cref = count->argByReferenceUser ? "*" : "";
852
/* size has to be expressed in bytes! */
if (count->argMultiplier > 1 || it->itSize > 8)
  fprintf(file, "\t%s->%s = %s%s%s * %d;\n", who, where, cref, count->argVarName, (iscomplex)? "[i]" : "", count->argMultiplier * it->itSize / 8);
else
  fprintf(file, "\t%s->%s = %s%s%s;\n", who, where, cref, count->argVarName, (iscomplex)? "[i]" : "");
858}
859
860/*
* argKPD_Pack discipline for out-of-line types.
*/
863static void
864WriteKPD_ool(FILE *file, argument_t *arg)
865{
ipc_type_t *it = arg->argType;
char *ref = arg->argByReferenceUser ? "*" : "";
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
boolean_t VarArray;
u_int howmany, howbig;
char *subindex;
873
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, FALSE, it->itVarArray, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  howmany = it->itElement->itNumber;
  howbig = it->itElement->itSize;
  subindex = "[i]";
}
else {
  (void)sprintf(firststring, "InP->%s", arg->argMsgField);
  (void)sprintf(string, "InP->%s.", arg->argMsgField);
  VarArray = it->itVarArray;
  howmany = it->itNumber;
  howbig = it->itSize;
  subindex = "";
}
891
fprintf(file, "#if\tUseStaticTemplates\n");
893
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
fprintf(file, "\t%saddress = (void *)(%s%s%s);\n", string, ref, arg->argVarName, subindex);
if (VarArray) {
  if (IS_MULTIPLE_KPD(it))
    WriteKPD_ool_varsize(file, arg, "\tptr", "size", TRUE);
  else
    WriteKPD_ool_varsize(file, arg, "InP", strconcat(arg->argMsgField, ".size"), FALSE);
}
902
if (arg->argDeallocate == d_MAYBE)
  fprintf(file, "\t%sdeallocate =  %s;\n", string, arg->argDealloc->argVarName);
905
fprintf(file, "#else\t/* UseStaticTemplates */\n");
907
fprintf(file, "\t%saddress = (void *)(%s%s%s);\n", string, ref, arg->argVarName, subindex);
if (VarArray)
  if (IS_MULTIPLE_KPD(it))
    WriteKPD_ool_varsize(file, arg, "\tptr", "size", TRUE);
  else
    WriteKPD_ool_varsize(file, arg, "InP", strconcat(arg->argMsgField, ".size"), FALSE);
  else
    fprintf(file, "\t%ssize = %d;\n", string, (howmany * howbig + 7)/8);
if (arg->argDeallocate == d_MAYBE)
  fprintf(file, "\t%sdeallocate =  %s;\n", string, arg->argDealloc->argVarName);
else
  fprintf(file, "\t%sdeallocate =  %s;\n", string, (arg->argDeallocate == d_YES) ? "TRUE" : "FALSE");
fprintf(file, "\t%scopy = %s;\n", string, (arg->argFlags & flPhysicalCopy) ? "MACH_MSG_PHYSICAL_COPY" : "MACH_MSG_VIRTUAL_COPY");
921#ifdef ALIGNMENT
fprintf(file, "\t%salignment = MACH_MSG_ALIGN_%d;\n", string, (it->itElement->itSize < 8) ? 1 : it->itElement->itSize / 8);
923#endif
fprintf(file, "\t%stype = MACH_MSG_OOL_DESCRIPTOR;\n", string);
925
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
if (IS_MULTIPLE_KPD(it)) {
  fprintf(file, "\t    }\n");
  if (it->itVarArray) {
    fprintf(file, "\t    for (i = %s; i < %d; ptr++, i++) {\n", arg->argCount->argVarName, it->itKPD_Number);
    /* fill the rest of the statically allocated KPD entries with size NULL */
    fprintf(file, "#if\tUseStaticTemplates\n");
    fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
    if (!VarArray)
      fprintf(file, "\t%ssize = 0;\n", string);
    /* otherwise the size in the template would be != 0! */
    fprintf(file, "#else\t/* UseStaticTemplates */\n");
    fprintf(file, "\t%ssize = 0;\n", string);
    fprintf(file, "\t%stype = MACH_MSG_OOL_DESCRIPTOR;\n", string);
    fprintf(file, "#endif\t/* UseStaticTemplates */\n");
    fprintf(file, "\t    }\n");
  }
  fprintf(file, "\t}\n");
}
fprintf(file, "\n");
946}
947
948/*
* argKPD_Pack discipline for out-of-line Port types.
*/
951static void
952WriteKPD_oolport(FILE *file, argument_t *arg)
953{
ipc_type_t *it = arg->argType;
char *ref = arg->argByReferenceUser ? "*" : "";
argument_t *count;
boolean_t VarArray;
string_t howstr;
u_int howmany;
char *subindex;
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
963
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, FALSE, it->itVarArray, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  howmany = it->itElement->itNumber;
  howstr = it->itElement->itInNameStr;
  count = arg->argSubCount;
  subindex = "[i]";
}
else {
  (void)sprintf(firststring, "InP->%s", arg->argMsgField);
  (void)sprintf(string, "InP->%s.", arg->argMsgField);
  VarArray = it->itVarArray;
  howmany = it->itNumber;
  howstr = it->itInNameStr;
  count = arg->argCount;
  subindex = "";
}
983
fprintf(file, "#if\tUseStaticTemplates\n");
985
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
fprintf(file, "\t%saddress = (void *)(%s%s%s);\n", string, ref, arg->argVarName, subindex);
if (VarArray)
  fprintf(file, "\t%scount = %s%s%s;\n", string, count->argByReferenceUser ? "*" : "", count->argVarName, subindex);
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbSendSnd)) {
  argument_t *poly = arg->argPoly;
  char *pref = poly->argByReferenceUser ? "*" : "";
993
  fprintf(file, "\t%sdisposition = %s%s;\n", string, pref, poly->argVarName);
}
if (arg->argDeallocate == d_MAYBE)
  fprintf(file, "\t%sdeallocate =  %s;\n", string, arg->argDealloc->argVarName);
998
fprintf(file, "#else\t/* UseStaticTemplates */\n");
1000
fprintf(file, "\t%saddress = (void *)(%s%s%s);\n", string, ref, arg->argVarName, subindex);
if (VarArray)
  fprintf(file, "\t%scount = %s%s%s;\n", string, count->argByReferenceUser ? "*" : "", count->argVarName, subindex);
else
  fprintf(file, "\t%scount = %d;\n", string, howmany);
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbSendSnd)) {
  argument_t *poly = arg->argPoly;
  char *pref = poly->argByReferenceUser ? "*" : "";
1009
  fprintf(file, "\t%sdisposition = %s%s;\n", string, pref, poly->argVarName);
}
else
  fprintf(file, "\t%sdisposition = %s;\n", string, howstr);
if (arg->argDeallocate == d_MAYBE)
  fprintf(file, "\t%sdeallocate =  %s;\n", string, arg->argDealloc->argVarName);
else
  fprintf(file, "\t%sdeallocate =  %s;\n", string, (arg->argDeallocate == d_YES) ? "TRUE" : "FALSE");
fprintf(file, "\t%stype = MACH_MSG_OOL_PORTS_DESCRIPTOR;\n", string);
1019
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
fprintf(file, "\n");
1022
if (IS_MULTIPLE_KPD(it)) {
  fprintf(file, "\t    }\n");
  if (it->itVarArray) {
    fprintf(file, "\t    for (i = %s; i < %d; ptr++, i++) {\n", arg->argCount->argVarName, it->itKPD_Number);
    /* fill the rest of the statically allocated KPD entries with size NULL */
    fprintf(file, "#if\tUseStaticTemplates\n");
    fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
    if (!VarArray)
      fprintf(file, "\t%scount = 0;\n", string);
    /* otherwise the size in the template would be != 0! */
    fprintf(file, "#else\t/* UseStaticTemplates */\n");
    fprintf(file, "\t%scount = 0;\n", string);
    fprintf(file, "\t%stype = MACH_MSG_OOL_PORTS_DESCRIPTOR;\n", string);
    fprintf(file, "#endif\t/* UseStaticTemplates */\n");
    fprintf(file, "\t    }\n");
  }
  fprintf(file, "\t}\n");
}
fprintf(file, "\n");
1042}
1043
1044static void
1045WriteOverwriteTemplate(FILE *file, routine_t *rt)
1046{
argument_t *arg;
char string[MAX_STR_LEN];
char *subindex = "";
boolean_t finish = FALSE;
1051
fprintf(file, "\t/* Initialize the template for overwrite */\n");
fprintf(file, "\tInOvTemplate->msgh_body.msgh_descriptor_count = %d;\n", rt->rtOverwriteKPDs);
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
  ipc_type_t *it = arg->argType;
  char *ref = arg->argByReferenceUser ? "*" : "";
  argument_t *count;
  char *cref;
  boolean_t VarIndex;
  u_int howmany, howbig;
1061
  if (akCheck(arg->argKind, akbOverwrite)) {
    if (arg->argFlags & flOverwrite) {
      if (IS_MULTIPLE_KPD(it)) {
        WriteKPD_Iterator(file, FALSE, TRUE, it->itVarArray, arg, TRUE);
        if (it->itVarArray)
          finish = TRUE;
        sprintf(string, "\tptr->");
        subindex = "[i]";
        count = arg->argSubCount;
        VarIndex = it->itElement->itVarArray;
        howmany = it->itElement->itNumber;
        howbig = it->itElement->itSize;
      }
      else {
        sprintf(string, "InOvTemplate->%s.", arg->argMsgField);
        subindex = "";
        count = arg->argCount;
        VarIndex = it->itVarArray;
        howmany = it->itNumber;
        howbig = it->itSize;
      }
1083
      fprintf(file, "\t%saddress = (void *) %s%s%s;\n", string, ref, arg->argVarName, subindex);
1085
      if (it->itPortType) {
        fprintf(file, "\t%scount = ", string);
        if (VarIndex) {
          cref = count->argByReferenceUser ? "*" : "";
          fprintf(file, "%s%s%s;\n", cref, count->argVarName, subindex);
        }
        else
          fprintf(file, "%d;\n", howmany);
      }
      else {
        fprintf(file, "\t%ssize = ", string);
        if (VarIndex) {
          cref = count->argByReferenceUser ? "*" : "";
          if (count->argMultiplier > 1 || howbig > 8)
            fprintf(file, "%s%s%s * %d;\n", cref, count->argVarName, subindex, count->argMultiplier * howbig / 8);
          else
            fprintf(file, "%s%s%s;\n", cref, count->argVarName, subindex);
        }
        else
          fprintf(file, "\t%ssize = %d;\n", string, (howmany * howbig + 7)/8);
      }
      fprintf(file, "\t%scopy = MACH_MSG_OVERWRITE;\n", string);
      fprintf(file, "\t%stype = MACH_MSG_OOL_%sDESCRIPTOR;\n", string, (it->itPortType) ? "PORTS_" : "");
      if (IS_MULTIPLE_KPD(it))
        fprintf(file, "\t    }\n");
      if (finish) {
        fprintf(file, "\t    for (i = %s%s; i < %d; ptr++, i++) {\n", (arg->argCount->argByReferenceUser) ? "*" : "", arg->argCount->argVarName, it->itKPD_Number);
        fprintf(file, "\t\tptr->copy = MACH_MSG_ALLOCATE;\n");
        fprintf(file, "\t\tptr->type = MACH_MSG_OOL_%sDESCRIPTOR;\n", (it->itPortType) ? "PORTS_" : "");
        fprintf(file, "\t    }\n");
      }
      if (IS_MULTIPLE_KPD(it))
        fprintf(file, "\t}\n");
    }
    else {
      /* just a placeholder */
      if (IS_MULTIPLE_KPD(it)) {
        WriteKPD_Iterator(file, FALSE, TRUE, FALSE, arg, TRUE);
        fprintf(file, "\t\tptr->copy = MACH_MSG_ALLOCATE;\n");
        fprintf(file, "\t\tptr->type = MACH_MSG_OOL_%sDESCRIPTOR;\n", (it->itPortType) ? "PORTS_" : "");
        fprintf(file, "\t    }\n\t}\n");
      }
      else {
        fprintf(file, "\tInOvTemplate->%s.copy = MACH_MSG_ALLOCATE;\n", arg->argMsgField);
        /* not sure whether this is needed */
        fprintf(file, "\tInOvTemplate->%s.type = MACH_MSG_OOL_%sDESCRIPTOR;\n", arg->argMsgField, (it->itPortType) ? "PORTS_" : "");
      }
    }
  }
}
fprintf(file, "\n");
1137}
1138
1139/*************************************************************
*  Writes code to copy an argument into the request message.
*  Called by WriteRoutine for each argument that is to placed
*  in the request message.
*************************************************************/
1144
1145static void
1146WritePackArgValueNormal(FILE *file, argument_t *arg)
1147{
ipc_type_t *it = arg->argType;
char *ref = (arg->argByReferenceUser ||
                      it->itNativePointer) ? "*" : "";
1151
if (IS_VARIABLE_SIZED_UNTYPED(it) || it->itNoOptArray) {
  if (it->itString) {
    /*
     * Copy variable-size C string with mig_strncpy.
     * Save the string length (+ 1 for trailing 0)
     * in the argument`s count field.
     */
    fprintf(file, "#ifdef USING_MIG_STRNCPY_ZEROFILL\n");
    fprintf(file, "\tif (mig_strncpy_zerofill != NULL) {\n");
    fprintf(file, "\t\tInP->%s = (%s) mig_strncpy_zerofill(InP->%s, %s, %d);\n", arg->argCount->argMsgField, arg->argCount->argType->itTransType, arg->argMsgField, arg->argVarName, it->itNumber);
    fprintf(file, "\t} else {\n");
    fprintf(file, "#endif /* USING_MIG_STRNCPY_ZEROFILL */\n");
1164
    fprintf(file, "\t\tInP->%s = (%s) mig_strncpy(InP->%s, %s, %d);\n", arg->argCount->argMsgField, arg->argCount->argType->itTransType, arg->argMsgField, arg->argVarName, it->itNumber);
1166
    fprintf(file, "#ifdef USING_MIG_STRNCPY_ZEROFILL\n");
    fprintf(file, "\t}\n");
    fprintf(file, "#endif /* USING_MIG_STRNCPY_ZEROFILL */\n");
1170
    fprintf(file, "\tInP->%sOffset = 0;\n", arg->argMsgField);
  }
  else if (it->itNoOptArray)
    fprintf(file, "\t(void)memcpy((char *) InP->%s, (const char *) %s%s, %d);\n", arg->argMsgField, ref, arg->argVarName, it->itTypeSize);
  else {
1176
    /*
     * Copy in variable-size inline array with (void)memcpy,
     * after checking that number of elements doesn`t
     * exceed declared maximum.
     */
    argument_t *count = arg->argCount;
    char *countRef = count->argByReferenceUser ? "*" : "";
    ipc_type_t *btype = it->itElement;
1185
    /* Note btype->itNumber == count->argMultiplier */
1187
    if (akIdent(arg->argKind) != akeSubCount) {
      /* we skip the SubCount case, as we have already taken care of */
      fprintf(file, "\tif (%s%s > %d) {\n", countRef, count->argVarName, it->itNumber/btype->itNumber);
      WriteReturnMsgError(file, arg->argRoutine, TRUE, arg, "MIG_ARRAY_TOO_LARGE");
      fprintf(file, "\t}\n");
    }
1194
    fprintf(file, "\t(void)memcpy((char *) InP->%s, (const char *) %s%s, ", arg->argMsgField, ref, arg->argVarName);
    if (btype->itTypeSize > 1)
      fprintf(file, "%d * ", btype->itTypeSize);
    fprintf(file, "%s%s);\n", countRef, count->argVarName);
  }
}
else if (IS_OPTIONAL_NATIVE(it)) {
  fprintf(file, "\tif ((InP->__Present__%s = (%s != %s))) {\n", arg->argMsgField, arg->argVarName, it->itBadValue);
  WriteCopyType(file, it, TRUE, "\tInP->%s.__Real__%s", "/* %s%s */ %s%s", arg->argMsgField, arg->argMsgField, ref, arg->argVarName);
  fprintf(file, "\t}\n");
}
else
  WriteCopyType(file, it, TRUE, "InP->%s", "/* %s */ %s%s", arg->argMsgField, ref, arg->argVarName);
1208
if (arg->argPadName != NULL && it->itPadSize != 0) {
  fprintf(file, "\t    for (int i = 0; i < %d; i++)\n", it->itPadSize);
  fprintf(file, "\t\t    InP->%s[i] = 0;\n", arg->argPadName);
}
fprintf(file, "\n");
1214}
1215
1216/*
* Calculate the size of a variable-length message field.
*/
1219static void
1220WriteArgSizeVariable(FILE *file,  argument_t *arg, ipc_type_t *ptype)
1221{
int bsize = ptype->itElement->itTypeSize;
argument_t *count = arg->argCount;
1224
if (PackMsg == FALSE) {
  fprintf(file, "%d", ptype->itTypeSize + ptype->itPadSize);
  return;
}
1229
/* If the base type size of the data field isn`t a multiple of 4,
 we have to round up. */
if (bsize % itWordAlign != 0)
  fprintf(file, "_WALIGN_");
fprintf(file, "(");
if (bsize > 1)
  fprintf(file, "%d * ", bsize);
if (ptype->itString)
/* get count from descriptor in message */
  fprintf(file, "InP->%s", count->argMsgField);
else
/* get count from argument */
  fprintf(file, "%s%s", count->argByReferenceUser ? "*" : "", count->argVarName);
fprintf(file, ")");
1244}
1245
1246static void
1247WriteArgSizeOptional(FILE *file, argument_t *arg, ipc_type_t *ptype)
1248{
fprintf(file, "(InP->__Present__%s ? _WALIGNSZ_(%s) : 0)", arg->argVarName, ptype->itUserType);
1250}
1251
1252static void
1253WriteArgSize(FILE *file, argument_t *arg)
1254
1255{
ipc_type_t *ptype = arg->argType;
1257
if (IS_OPTIONAL_NATIVE(ptype))
  WriteArgSizeOptional(file, arg, ptype);
else
  WriteArgSizeVariable(file, arg, ptype);
1262}
1263
1264/*
* Adjust message size and advance request pointer.
* Called after packing a variable-length argument that
* has more arguments following.
*/
1269static void
1270WriteAdjustMsgSize(FILE *file, argument_t *arg)
1271{
ipc_type_t *ptype = arg->argType;
1273
/* There are more In arguments.  We need to adjust msgh_size
   and advance InP, so we save the size of the current field
   in msgh_size_delta. */
1277
fprintf(file, "\tmsgh_size_delta = ");
WriteArgSize(file, arg);
fprintf(file, ";\n");
1281
if (arg->argRequestPos == 0) {
  /* First variable-length argument.  The previous msgh_size value
     is the minimum request size. */
1285
  fprintf(file, "\tmsgh_size = ");
  rtMinRequestSize(file, arg->argRoutine, "Request");
  fprintf(file, " + msgh_size_delta;\n");
}
else
  fprintf(file, "\tmsgh_size += msgh_size_delta;\n");
1292
if (PackMsg == TRUE) {
  fprintf(file, "\tInP = (Request *) ((pointer_t) InP + msgh_size_delta - ");
  if (IS_OPTIONAL_NATIVE(ptype))
    fprintf(file, "_WALIGNSZ_(%s)", ptype->itUserType);
  else
    fprintf(file, "%d", ptype->itTypeSize + ptype->itPadSize);
  fprintf(file, ");\n\n");
}
1301}
1302
1303/*
* Calculate the size of the message.  Called after the
* last argument has been packed.
*/
1307static void
1308WriteFinishMsgSize(FILE *file, argument_t *arg)
1309{
/* No more In arguments.  If this is the only variable In
   argument, the previous msgh_size value is the minimum
   request size. */
1313
if (arg->argRequestPos == 0) {
  fprintf(file, "\tmsgh_size = ");
  rtMinRequestSize(file, arg->argRoutine, "Request");
  fprintf(file, " + (");
  WriteArgSize(file, arg);
  fprintf(file, ");\n");
}
else {
  fprintf(file, "\tmsgh_size += ");
  WriteArgSize(file, arg);
  fprintf(file, ";\n");
}
1326}
1327
1328static void
1329WriteInitializeCount(FILE *file, argument_t *arg)
1330{
ipc_type_t *ptype = arg->argCInOut->argParent->argType;
ipc_type_t *btype = ptype->itElement;
1333
fprintf(file, "\tif (%s%s < %d)\n", arg->argByReferenceUser ? "*" : "", arg->argVarName, ptype->itNumber/btype->itNumber);
fprintf(file, "\t\tInP->%s = %s%s;\n", arg->argMsgField, arg->argByReferenceUser ? "*" : "", arg->argVarName);
fprintf(file, "\telse\n");
fprintf(file, "\t\tInP->%s = %d;\n", arg->argMsgField, ptype->itNumber/btype->itNumber);
fprintf(file, "\n");
1339}
1340
1341/*
* Generate code to fill in all of the request arguments and their
* message types.
*/
1345static void
1346WriteRequestArgs(FILE *file, routine_t *rt)
1347{
argument_t *arg;
argument_t *lastVarArg;
1350
/*
 * 1. The Kernel Processed Data
 */
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, akbSendSnd|akbSendKPD))
    (*arg->argKPD_Pack)(file, arg);
1357
/*
 * 2. The Data Stream
 */
lastVarArg = argNULL;
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
  /*
   * Adjust message size and advance message pointer if
   * the last request argument was variable-length and the
   * request position will change.
   */
  if (lastVarArg != argNULL &&
      lastVarArg->argRequestPos < arg->argRequestPos) {
    WriteAdjustMsgSize(file, lastVarArg);
    lastVarArg = argNULL;
  }
1373
  if ((akIdent(arg->argKind) == akeCountInOut) &&
      akCheck(arg->argKind, akbSendSnd))
    WriteInitializeCount(file, arg);
  else if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody))
    WritePackArgValueNormal(file, arg);
  /*
   * Remember whether this was variable-length.
   */
  if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody|akbVariable))
    lastVarArg = arg;
}
/*
 * Finish the message size.
 */
if (lastVarArg != argNULL)
  WriteFinishMsgSize(file, lastVarArg);
1390}
1391
1392/*************************************************************
*  Writes code to check that the return msgh_id is correct and that
*  the size of the return message is correct. Called by
*  WriteRoutine.
*************************************************************/
1397static void
1398WriteCheckIdentity(FILE *file, routine_t *rt)
1399{
fprintf(file, "\tif (Out0P->Head.msgh_id != %d) {\n", rt->rtNumber + SubsystemBase + 100);
fprintf(file, "\t    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)\n");
fprintf(file, "\t\t{ return MIG_SERVER_DIED; }\n");
fprintf(file, "\t    else\n");
fprintf(file, "\t\t{ return MIG_REPLY_MISMATCH; }\n");
fprintf(file, "\t}\n");
fprintf(file, "\n");
if (!rt->rtSimpleReply)
  fprintf(file, "\tmsgh_simple = !(Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);\n");
fprintf(file, "#if\t__MigTypeCheck\n");
1410
if (!rt->rtNoReplyArgs)
  fprintf(file, "\tmsgh_size = Out0P->Head.msgh_size;\n\n");
1413
if (rt->rtSimpleReply) {
  /* Expecting a simple message.  We can factor out the check for
   * a simple message, since the error reply message is also simple.
   */
  fprintf(file, "\tif ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n");
  if (rt->rtNoReplyArgs)
    fprintf(file, "\t    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))\n");
  else {
    /*
     * We have an error iff:
     * 1) the message size is not the one expected AND
     * 2) the message size is also different from sizeof(mig_reply_error_t)
     *    or the RetCode == KERN_SUCCESS
     */
    if (rt->rtNumReplyVar > 0)  {
      fprintf(file, "\t    ((msgh_size > (mach_msg_size_t)sizeof(__Reply) || msgh_size < ");
      rtMinReplySize(file, rt, "__Reply");
      fprintf(file, ") &&\n");
    }
    else
      fprintf(file, "\t    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&\n");
    fprintf(file, "\t     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||\n");
    fprintf(file, "\t      Out0P->RetCode == KERN_SUCCESS)))\n");
  }
}
else {
  /* Expecting a complex message. */
1441
  fprintf(file, "\t" "if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != %d ||\n", rt->rtReplyKPDs);
  if (rt->rtNumReplyVar > 0) {
    fprintf(file, "\t    msgh_size < ");
    rtMinReplySize(file, rt, "__Reply");
    fprintf(file, " || msgh_size > (mach_msg_size_t)sizeof(__Reply)) &&\n");
  }
  else
    fprintf(file, "\t    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&\n");
  fprintf(file, "\t    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||\n");
  fprintf(file, "\t    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))\n");
}
fprintf(file, "\t\t{ return MIG_TYPE_ERROR ; }\n");
fprintf(file, "#endif\t/* __MigTypeCheck */\n");
fprintf(file, "\n");
1456}
1457
1458/*************************************************************
*  Write code to generate error handling code if the RetCode
*  argument of a Routine is not KERN_SUCCESS.
*************************************************************/
1462static void
1463WriteRetCodeCheck(FILE *file, routine_t *rt)
1464{
if (rt->rtSimpleReply)
  fprintf(file, "\tif (Out0P->RetCode != KERN_SUCCESS) {\n");
else
  fprintf(file, "\tif (msgh_simple) {\n");
if (CheckNDR) {
  fprintf(file, "#ifdef\t__NDR_convert__mig_reply_error_t__defined\n");
  fprintf(file, "\t\t__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);\n");
  fprintf(file, "#endif\t/* __NDR_convert__mig_reply_error_t__defined */\n");
}
fprintf(file, "\t\treturn ((mig_reply_error_t *)Out0P)->RetCode;\n");
fprintf(file, "\t}\n");
fprintf(file, "\n");
1477}
1478
1479/*
* argKPD_TypeCheck discipline for Port types.
*/
1482static void
1483WriteTCheckKPD_port(FILE *file, argument_t *arg)
1484{
ipc_type_t *it = arg->argType;
char *tab = "";
char string[MAX_STR_LEN];
boolean_t close = FALSE;
1489
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, FALSE, arg, TRUE);
  (void)sprintf(string, "ptr->");
  tab = "\t";
  close = TRUE;
}
else
  (void)sprintf(string, "Out%dP->%s.", arg->argReplyPos, arg->argMsgField);
fprintf(file, "\t%sif (%stype != MACH_MSG_PORT_DESCRIPTOR", tab, string);
if (arg->argPoly == argNULL && !it->itVarArray)
/* we can't check disposition when poly or VarArray,
   (because some of the entries could be empty) */
  fprintf(file, " ||\n\t%s    %sdisposition != %s", tab, string, it->itOutNameStr);
fprintf(file,
        ") {\n"
        "\t\t%s" "return MIG_TYPE_ERROR;\n"
        "\t%s" "}\n"
      , tab, tab);
if (close)
  fprintf(file, "\t    }\n\t}\n");
1510}
1511
1512/*
* argKPD_TypeCheck discipline for out-of-line types.
*/
1515static void
1516WriteTCheckKPD_ool(FILE *file, argument_t *arg)
1517{
ipc_type_t *it = arg->argType;
char *tab, string[MAX_STR_LEN];
boolean_t test;
u_int howmany, howbig;
1522
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, FALSE, arg, TRUE);
  tab = "\t";
  sprintf(string, "ptr->");
  howmany = it->itElement->itNumber;
  howbig = it->itElement->itSize;
  test = !it->itVarArray && !it->itElement->itVarArray;
}
else {
  tab = "";
  sprintf(string, "Out%dP->%s.", arg->argReplyPos, arg->argMsgField);
  howmany = it->itNumber;
  howbig = it->itSize;
  test = !it->itVarArray;
}
1538
fprintf(file, "\t%sif (%stype != MACH_MSG_OOL_DESCRIPTOR", tab, string);
if (test)
/* if VarArray we may use no-op; if itElement->itVarArray size might change */
  fprintf(file, " ||\n\t%s    %ssize != %d", tab, string, (howmany * howbig + 7)/8);
fprintf(file,
        ") {\n"
        "\t\t%s" "return MIG_TYPE_ERROR;\n"
        "\t%s" "}\n"
        , tab, tab);
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
1550}
1551
1552/*
* argKPD_TypeCheck discipline for out-of-line Port types.
*/
1555static void
1556WriteTCheckKPD_oolport(FILE *file, argument_t *arg)
1557{
ipc_type_t *it = arg->argType;
char *tab, string[MAX_STR_LEN];
boolean_t test;
u_int howmany;
char *howstr;
1563
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, FALSE, arg, TRUE);
  tab = "\t";
  sprintf(string, "ptr->");
  howmany = it->itElement->itNumber;
  test = !it->itVarArray && !it->itElement->itVarArray;
  howstr = it->itElement->itOutNameStr;
}
else {
  tab = "";
  sprintf(string, "Out%dP->%s.", arg->argReplyPos, arg->argMsgField);
  howmany = it->itNumber;
  test = !it->itVarArray;
  howstr = it->itOutNameStr;
}
1579
fprintf(file, "\t%sif (%stype != MACH_MSG_OOL_PORTS_DESCRIPTOR", tab, string);
if (test)
  /* if VarArray we may use no-op; if itElement->itVarArray size might change */
  fprintf(file, " ||\n\t%s    %scount != %d", tab, string, howmany);
if (arg->argPoly == argNULL)
  fprintf(file, " ||\n\t%s    %sdisposition != %s", tab, string, howstr);
fprintf(file, ") {\n"
        "\t\t%s" "return MIG_TYPE_ERROR;\n"
        "\t%s" "}\n"
        ,tab, tab);
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
1592}
1593
1594/*************************************************************
*  Writes code to check that the type of each of the arguments
*  in the reply message is what is expected. Called by
*  WriteRoutine for each out && typed argument in the reply message.
*************************************************************/
1599static void
1600WriteTypeCheck(FILE *file, argument_t *arg)
1601{
fprintf(file, "#if\t__MigTypeCheck\n");
(*arg->argKPD_TypeCheck)(file, arg);
fprintf(file, "#endif\t/* __MigTypeCheck */\n");
1605}
1606
1607
1608/*
* argKPD_Extract discipline for Port types.
*/
1611static void
1612WriteExtractKPD_port(FILE *file,  argument_t *arg)
1613{
ipc_type_t *it = arg->argType;
char *ref = arg->argByReferenceUser ? "*" : "";
char *subindex;
char *recast = "";
ipc_type_t *real_it;
1619
real_it = (IS_MULTIPLE_KPD(it)) ? it->itElement : it;
1621#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelUser && streql(real_it->itUserType, "ipc_port_t"))
  recast = "(mach_port_t)";
1624#endif
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, it->itVarArray, arg, FALSE);
1627
  fprintf(file, "\t\t%s[i] = %sptr->name;\n", arg->argVarName, recast);
  if (it->itVarArray) {
    argument_t *count = arg->argCount;
    char *cref = count->argByReferenceUser ? "*" : "";
1632
    fprintf(file, "\t    if (Out%dP->%s >",count->argReplyPos, count->argVarName);
    if (arg->argCountInOut) {
      fprintf(file, " %s%s)\n", cref, count->argVarName);
    }
    else {
      fprintf(file, " %d)\n", it->itNumber/it->itElement->itNumber);
    }
    WriteReturnMsgError(file, arg->argRoutine, TRUE, arg, "MIG_ARRAY_TOO_LARGE");
  }
  fprintf(file, "\t}\n");
  subindex = "[0]";
}
else {
  fprintf(file, "\t%s%s = %sOut%dP->%s.name;\n", ref, arg->argVarName, recast, arg->argReplyPos, arg->argMsgField);
  subindex = "";
}
1649
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbReturnRcv)) {
  argument_t *poly = arg->argPoly;
  char *pref = poly->argByReferenceUser ? "*" : "";
1653
  fprintf(file, "\t%s%s = Out%dP->%s%s.disposition;\n", pref, poly->argVarName, arg->argReplyPos, arg->argMsgField, subindex);
}
1656}
1657
1658/*
* argKPD_Extract discipline for out-of-line types.
*/
1661static void
1662WriteExtractKPD_ool(FILE *file, argument_t *arg)
1663{
char *ref = arg->argByReferenceUser ? "*" : "";
ipc_type_t *it = arg->argType;
1666
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, it->itVarArray, arg, FALSE);
  fprintf(file, "\t\t%s[i] = ptr->address;\n", arg->argVarName);
  fprintf(file, "\t}\n");
}
else
  fprintf(file, "\t%s%s = (%s)(Out%dP->%s.address);\n", ref, arg->argVarName, arg->argType->itUserType, arg->argReplyPos, arg->argMsgField);
/*
 *  In case of variable sized arrays,
 *  the count field will be retrieved from the untyped
 *  section of the message
 */
1679}
1680
1681/*
* argKPD_Extract discipline for out-of-line Port types.
*/
1684static void
1685WriteExtractKPD_oolport(FILE *file, argument_t *arg)
1686{
char *ref = arg->argByReferenceUser ? "*" : "";
ipc_type_t *it = arg->argType;
char *subindex;
1690
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, it->itVarArray, arg, FALSE);
  fprintf(file, "\t\t%s[i] = ptr->address;\n", arg->argVarName);
  fprintf(file, "\t}\n");
  subindex = "[0]";
}
else {
  fprintf(file, "\t%s%s = (%s)(Out%dP->%s.address);\n", ref, arg->argVarName, arg->argType->itUserType, arg->argReplyPos, arg->argMsgField);
  subindex = "";
}
/*
 *  In case of variable sized arrays,
 *  the count field will be retrieved from the untyped
 *  section of the message
 */
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbReturnRcv)) {
  argument_t *poly = arg->argPoly;
  char *pref = poly->argByReferenceUser ? "*" : "";
1709
  fprintf(file, "\t%s%s = Out%dP->%s%s.disposition;\n", pref, poly->argVarName, arg->argReplyPos, arg->argMsgField, subindex);
}
1712}
1713
1714/*************************************************************
*  Write code to copy an argument from the reply message
*  to the parameter. Called by WriteRoutine for each argument
*  in the reply message.
*************************************************************/
1719
1720static void
1721WriteExtractArgValueNormal(FILE *file, argument_t *arg)
1722{
ipc_type_t *argType = arg->argType;
char *ref = arg->argByReferenceUser ? "*" : "";
char who[20];
1726
if (akCheck(arg->argKind, akbUserImplicit))
  sprintf(who, "TrailerP");
else
  sprintf(who, "Out%dP", arg->argReplyPos);
1731
if (IS_VARIABLE_SIZED_UNTYPED(argType) || argType->itNoOptArray) {
  if (argType->itString) {
    /*
     * Copy out variable-size C string with mig_strncpy, not the zerofill variant.
     * We don't risk leaking process / kernel memory on this copy-out because
     * we've already zero-filled the buffer on copy-in.
     */
    fprintf(file, "\t(void) mig_strncpy(%s%s, %s->%s, %d);\n", ref, arg->argVarName, who, arg->argMsgField, argType->itNumber);
  }
  else if (argType->itNoOptArray)
    fprintf(file, "\t(void)memcpy((char *) %s%s, (const char *) %s->%s, %d);\n", ref, arg->argVarName, who, arg->argMsgField, argType->itTypeSize);
  else {
1744
    /*
     * Copy out variable-size inline array with (void)memcpy,
     * after checking that number of elements doesn`t
     * exceed user`s maximum.
     */
    argument_t *count = arg->argCount;
    char *countRef = count->argByReferenceUser ? "*" : "";
    ipc_type_t *btype = argType->itElement;
1753
    /* Note count->argMultiplier == btype->itNumber */
    /* Note II: trailer logic isn't supported in this case */
    fprintf(file, "\tif (Out%dP->%s", count->argReplyPos, count->argMsgField);
    if (arg->argCountInOut) {
      fprintf(file, " > %s%s) {\n", countRef, count->argVarName);
    }
    else {
      fprintf(file, " > %d) {\n", argType->itNumber/btype->itNumber);
    }
1763
    /*
     * If number of elements is too many for user receiving area,
     * fill user`s area as much as possible.  Return the correct
     * number of elements.
     */
    fprintf(file, "\t\t(void)memcpy((char *) %s%s, (const char *) Out%dP->%s, ", ref, arg->argVarName, arg->argReplyPos, arg->argMsgField);
    if (btype->itTypeSize > 1)
      fprintf(file, "%d * ", btype->itTypeSize);
    if (arg->argCountInOut) {
      fprintf(file, " %s%s);\n", countRef, count->argVarName);
    }
    else {
      fprintf(file, " %d);\n", argType->itNumber/btype->itNumber);
    }
    fprintf(file, "\t\t%s%s = Out%dP->%s", countRef, count->argVarName, count->argReplyPos, count->argMsgField);
    fprintf(file, ";\n");
    WriteReturnMsgError(file, arg->argRoutine, TRUE, arg, "MIG_ARRAY_TOO_LARGE");
1781
    fprintf(file, "\t}\n");
1783
    fprintf(file, "\t(void)memcpy((char *) %s%s, (const char *) Out%dP->%s, ", ref, arg->argVarName, arg->argReplyPos, arg->argMsgField);
    if (btype->itTypeSize > 1)
      fprintf(file, "%d * ", btype->itTypeSize);
    fprintf(file, "Out%dP->%s);\n", count->argReplyPos, count->argMsgField);
  }
}
else
  WriteCopyType(file, argType, FALSE, "%s%s", "/* %s%s */ %s->%s", ref, arg->argVarName, who, arg->argMsgField);
fprintf(file, "\n");
1793}
1794
1795static void
1796WriteCalcArgSize(FILE *file, argument_t *arg)
1797{
ipc_type_t *ptype = arg->argType;
ipc_type_t *btype = ptype->itElement;
argument_t *count = arg->argCount;
int multiplier = btype->itTypeSize;
1802
/* If the base type size of the data field isn`t a multiple of 4,
   we have to round up. */
if (btype->itTypeSize % itWordAlign != 0)
  fprintf(file, "_WALIGN_(");
1807
fprintf(file, "Out%dP->%s", count->argReplyPos, count->argMsgField);
if (multiplier > 1)
  fprintf(file, " * %d", multiplier);
1811
if (btype->itTypeSize % itWordAlign != 0)
  fprintf(file, ")");
1814}
1815
1816static void
1817WriteCheckArgSize(FILE *file, routine_t *rt, argument_t *arg, const char *comparator)
1818{
ipc_type_t *ptype = arg->argType;
ipc_type_t *btype = ptype->itElement;
argument_t *count = arg->argCount;
int multiplier = btype->itTypeSize;
1823
fprintf(file, "\tif (((msgh_size - ");
rtMinReplySize(file, rt, "__Reply");
fprintf(file, ")");
if (multiplier > 1)
 fprintf(file, " / %d", multiplier);
fprintf(file, "< Out%dP->%s) ||\n", count->argReplyPos, count->argMsgField);
fprintf(file, "\t    (msgh_size %s ", comparator);
rtMinReplySize(file, rt, "__Reply");
fprintf(file, " + ");
WriteCalcArgSize(file, arg);
fprintf(file, ")");
fprintf(file, ")\n\t\t{ return MIG_TYPE_ERROR ; }\n");
1836}
1837
1838
1839/* NDR Conversion routines */
1840
1841
1842void
1843WriteReplyNDRConvertIntRepArgCond(FILE *file, argument_t *arg)
1844{
routine_t *rt = arg->argRoutine;
1846
fprintf(file, "defined(__NDR_convert__int_rep__Reply__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
1848}
1849
1850void
1851WriteReplyNDRConvertCharRepArgCond(FILE *file, argument_t *arg)
1852{
routine_t *rt = arg->argRoutine;
1854
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  fprintf(file, "defined(__NDR_convert__char_rep__Reply__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
else
  fprintf(file, "0");
1859}
1860
1861void
1862WriteReplyNDRConvertFloatRepArgCond(FILE *file, argument_t *arg)
1863{
routine_t *rt = arg->argRoutine;
1865
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  fprintf(file, "defined(__NDR_convert__float_rep__Reply__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
else
  fprintf(file, "0");
1870}
1871
1872void
1873WriteReplyNDRConvertIntRepArgDecl(FILE *file, argument_t *arg)
1874{
WriteNDRConvertArgDecl(file, arg, "int_rep", "Reply");
1876}
1877
1878void
1879WriteReplyNDRConvertCharRepArgDecl(FILE *file, argument_t *arg)
1880{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  WriteNDRConvertArgDecl(file, arg, "char_rep", "Reply");
1883}
1884
1885void
1886WriteReplyNDRConvertFloatRepArgDecl(FILE *file, argument_t *arg)
1887{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  WriteNDRConvertArgDecl(file, arg, "float_rep", "Reply");
1890}
1891
1892
1893
1894void
1895WriteReplyNDRConvertArgUse(FILE *file, argument_t *arg, char *convert)
1896{
routine_t *rt = arg->argRoutine;
argument_t *count = arg->argCount;
char argname[MAX_STR_LEN];
1900
if ((akIdent(arg->argKind) == akeCount || akIdent(arg->argKind) == akeCountInOut) &&
    (arg->argParent && akCheck(arg->argParent->argKind, akbReturnNdr)))
  return;
1904
if (arg->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
  if (count && !arg->argSameCount && !strcmp(convert, "int_rep")) {
    fprintf(file, "#if defined(__NDR_convert__int_rep__Reply__%s_t__%s__defined)\n", rt->rtName, count->argMsgField);
    fprintf(file, "\t\t__NDR_convert__int_rep__Reply__%s_t__%s(&Out%dP->%s, Out%dP->NDR.int_rep);\n", rt->rtName, count->argMsgField, count->argReplyPos, count->argMsgField, count->argReplyPos);
    fprintf(file, "#endif\t/* __NDR_convert__int_rep__Reply__%s_t__%s__defined */\n", rt->rtName, count->argMsgField);
  }
1911
  sprintf(argname, "(%s)(Out%dP->%s.address)", FetchServerType(arg->argType), arg->argReplyPos, arg->argMsgField);
}
else {
  sprintf(argname, "&Out%dP->%s", arg->argReplyPos, arg->argMsgField);
}
1917
fprintf(file, "#if defined(__NDR_convert__%s__Reply__%s_t__%s__defined)\n", convert, rt->rtName, arg->argMsgField);
fprintf(file, "\t\t__NDR_convert__%s__Reply__%s_t__%s(%s, Out0P->NDR.%s", convert, rt->rtName, arg->argMsgField, argname, convert);
if (count)
  fprintf(file, ", Out%dP->%s", count->argReplyPos, count->argMsgField);
fprintf(file, ");\n");
fprintf(file, "#endif /* __NDR_convert__%s__Reply__%s_t__%s__defined */\n", convert, rt->rtName, arg->argMsgField);
1924}
1925
1926void
1927WriteReplyNDRConvertIntRepOneArgUse(FILE *file, argument_t *arg)
1928{
routine_t *rt = arg->argRoutine;
1930
fprintf(file, "#if defined(__NDR_convert__int_rep__Reply__%s_t__%s__defined)\n", rt->rtName, arg->argMsgField);
fprintf(file, "\tif (Out0P->NDR.int_rep != NDR_record.int_rep)\n");
fprintf(file, "\t\t__NDR_convert__int_rep__Reply__%s_t__%s(&Out%dP->%s, Out%dP->NDR.int_rep);\n", rt->rtName, arg->argMsgField, arg->argReplyPos, arg->argMsgField, arg->argReplyPos);
fprintf(file, "#endif\t/* __NDR_convert__int_rep__Reply__%s_t__%s__defined */\n", rt->rtName, arg->argMsgField);
1935}
1936
1937void
1938WriteReplyNDRConvertIntRepArgUse(FILE *file, argument_t *arg)
1939{
WriteReplyNDRConvertArgUse(file, arg, "int_rep");
1941}
1942
1943void
1944WriteReplyNDRConvertCharRepArgUse(FILE *file, argument_t *arg)
1945{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  WriteReplyNDRConvertArgUse(file, arg, "char_rep");
1948}
1949
1950void
1951WriteReplyNDRConvertFloatRepArgUse(FILE *file, argument_t *arg)
1952{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) !=akeCountInOut && akIdent(arg->argKind) != akeRetCode)
  WriteReplyNDRConvertArgUse(file, arg, "float_rep");
1955}
1956
1957static void
1958WriteCheckMsgSize(FILE *file, argument_t *arg)
1959{
routine_t *rt = arg->argRoutine;
ipc_type_t *it = arg->argType;
ipc_type_t *btype = it->itElement;
1963
/* If there aren't any more Out args after this, then
   we can use the msgh_size_delta value directly in
   the TypeCheck conditional. */
1967
if (CheckNDR && arg->argCount && !arg->argSameCount)
  WriteReplyNDRConvertIntRepOneArgUse(file, arg->argCount);
1970
if (arg->argReplyPos == rt->rtMaxReplyPos) {
  fprintf(file, "#if\t__MigTypeCheck\n");
1973
  /*
   * emit code to verify that the server-code-provided count does not exceed the maximum count allowed by the type.
   */
  fprintf(file, "\t" "if ( Out%dP->%s > %d )\n", arg->argCount->argReplyPos,
   arg->argCount->argMsgField, it->itNumber/btype->itNumber);
  fputs("\t\t" "return MIG_TYPE_ERROR;\n", file);
  /* ...end... */
1981
  WriteCheckArgSize(file, rt, arg, "!=");
1983
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
else {
  /* If there aren't any more variable-sized arguments after this,
     then we must check for exact msg-size and we don't need
     to update msgh_size. */
1990
  boolean_t LastVarArg = arg->argReplyPos+1 == rt->rtNumReplyVar;
1992
  /* calculate the actual size in bytes of the data field.  note
     that this quantity must be a multiple of four.  hence, if
     the base type size isn't a multiple of four, we have to
     round up.  note also that btype->itNumber must
     divide btype->itTypeSize (see itCalculateSizeInfo). */
1998
  fprintf(file, "\tmsgh_size_delta = ");
  WriteCalcArgSize(file, arg);
  fprintf(file, ";\n");
  fprintf(file, "#if\t__MigTypeCheck\n");
2003
  /*
   * emit code to verify that the server-code-provided count does not exceed the maximum count allowed by the type.
   */
  fprintf(file, "\t" "if ( Out%dP->%s > %d )\n", arg->argCount->argReplyPos,
 arg->argCount->argMsgField, it->itNumber/btype->itNumber);
  fputs("\t\t" "return MIG_TYPE_ERROR;\n", file);
  /* ...end... */
2011
  WriteCheckArgSize(file, rt, arg, LastVarArg ? "!=" : "<");
2013
  if (!LastVarArg)
    fprintf(file, "\tmsgh_size -= msgh_size_delta;\n");
2016
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
fprintf(file, "\n");
2020}
2021
2022void
2023WriteAdjustReplyMsgPtr(FILE *file, argument_t *arg)
2024{
ipc_type_t *ptype = arg->argType;
2026
fprintf(file, "\t*Out%dPP = Out%dP = (__Reply *) ((pointer_t) Out%dP + msgh_size_delta - %d);\n\n",
        arg->argReplyPos+1, arg->argReplyPos +1, arg->argReplyPos, ptype->itTypeSize + ptype->itPadSize);
2029}
2030
2031static void
2032WriteReplyArgs(FILE *file, routine_t *rt)
2033{
argument_t *arg;
2035
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  if (akCheckAll(arg->argKind, akbReturnRcv|akbReturnBody)) {
    WriteExtractArgValueNormal(file, arg);
  }
  else if (akCheckAll(arg->argKind, akbReturnRcv|akbReturnKPD)) {
    /*
     * KPDs have argReplyPos 0, therefore they escape the above logic
     */
    (*arg->argKPD_Extract)(file, arg);
  }
  else if (akCheck(arg->argKind, akbUserImplicit)) {
    WriteExtractArgValueNormal(file, arg);
  }
}
2050}
2051
2052/*************************************************************
*  Writes code to return the return value. Called by WriteRoutine
*  for routines and functions.
*************************************************************/
2056static void
2057WriteReturnValue(FILE *file, routine_t *rt)
2058{
/* If returning RetCode, we have already checked that it is KERN_SUCCESS */
WriteReturn(file, rt, "\t", "KERN_SUCCESS", "\n", TRUE);
2061}
2062
2063/*************************************************************
*  Writes the elements of the message type declaration: the
*  msg_type structure, the argument itself and any padding
*  that is required to make the argument a multiple of 4 bytes.
*  Called by WriteRoutine for all the arguments in the request
*  message first and then the reply message.
*************************************************************/
2070static void
2071WriteFieldDecl(FILE *file, argument_t *arg)
2072{
if (akCheck(arg->argKind, akbSendKPD) ||
    akCheck(arg->argKind, akbReturnKPD))
  WriteFieldDeclPrim(file, arg, FetchKPDType);
else
  WriteFieldDeclPrim(file, arg, FetchUserType);
2078}
2079
2080/* Fill in the string with an expression that refers to the size
* of the specified array:
*/
2083static void
2084GetArraySize(argument_t *arg, char *size)
2085{
ipc_type_t *it = arg->argType;
2087
if (it->itVarArray) {
  if (arg->argCount->argByReferenceUser) {
    sprintf(size, "*%s", arg->argCount->argVarName);
  }
  else
    sprintf(size, "%s", arg->argCount->argVarName);
}
else {
  sprintf(size, "%d", (it->itNumber * it->itSize + 7) / 8);
}
2098}
2099
2100
2101static void
2102WriteRPCPortDisposition(FILE *file, argument_t *arg)
2103{
/*
 * According to the MIG specification, the port disposition could be different
 * on input and output. If we stay with this then a new bitfield will have
 * to be added. Right now the port disposition is the same for in and out cases.
 */
switch(arg->argType->itInName) {
2110
  case  MACH_MSG_TYPE_MOVE_RECEIVE:
    fprintf(file, " | MACH_RPC_MOVE_RECEIVE");
    break;
2114
  case  MACH_MSG_TYPE_MOVE_SEND:
    fprintf(file, " | MACH_RPC_MOVE_SEND");
    break;
2118
  case  MACH_MSG_TYPE_MOVE_SEND_ONCE:
    fprintf(file, " | MACH_RPC_MOVE_SEND_ONCE");
    break;
2122
  case  MACH_MSG_TYPE_COPY_SEND:
    fprintf(file, " | MACH_RPC_COPY_SEND");
    break;
2126
  case  MACH_MSG_TYPE_MAKE_SEND:
    fprintf(file, " | MACH_RPC_MAKE_SEND");
    break;
2130
  case  MACH_MSG_TYPE_MAKE_SEND_ONCE:
    fprintf(file, " | MACH_RPC_MAKE_SEND_ONCE");
    break;
}
2135}
2136
2137static void
2138WriteRPCArgDescriptor(FILE *file, argument_t *arg, int offset)
2139{
fprintf(file, "            {\n                0 ");
if (RPCPort(arg)) {
  fprintf(file, "| MACH_RPC_PORT ");
  if (arg->argType->itNumber > 1)
    fprintf(file, "| MACH_RPC_ARRAY ");
  if (arg->argType->itVarArray)
    fprintf(file, "| MACH_RPC_VARIABLE ");
  WriteRPCPortDisposition(file, arg);
}
else if (RPCPortArray(arg)) {
  fprintf(file, "| MACH_RPC_PORT_ARRAY ");
  if (arg->argType->itVarArray)
    fprintf(file, "| MACH_RPC_VARIABLE ");
  WriteRPCPortDisposition(file, arg);
}
else if (RPCFixedArray(arg))
  fprintf(file, "| MACH_RPC_ARRAY_FIXED ");
else if (RPCVariableArray(arg))
  fprintf(file, "| MACH_RPC_ARRAY_VARIABLE ");
if (argIsIn(arg))
  fprintf(file, " | MACH_RPC_IN ");
if (argIsOut(arg))
  fprintf(file, " | MACH_RPC_OUT ");
if ((! arg->argType->itInLine) && (! arg->argType->itMigInLine))
  fprintf(file, " | MACH_RPC_POINTER ");
if (arg->argFlags & flDealloc)
  fprintf(file, " | MACH_RPC_DEALLOCATE ");
if (arg->argFlags & flPhysicalCopy)
  fprintf(file, " | MACH_RPC_PHYSICAL_COPY ");
fprintf(file, ",\n");
fprintf(file, "                %d,\n", (arg->argType->itSize / 8));
fprintf(file, "                %d,\n", arg->argType->itNumber);
fprintf(file, "                %d,\n            },\n", offset);
2173}
2174
2175void
2176WriteRPCRoutineDescriptor(FILE *file, routine_t *rt, int arg_count, int descr_count, string_t stub_routine, string_t sig_array)
2177{
fprintf(file, "          { (mig_impl_routine_t) 0,\n\
        (mig_stub_routine_t) %s, ", stub_routine);
fprintf(file, "%d, %d, %s}", arg_count, descr_count, sig_array);
2181}
2182
2183void
2184WriteRPCRoutineArgDescriptor(FILE *file, routine_t *rt)
2185{
argument_t *arg;
int offset = 0;
int size = 0;
2189
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  boolean_t compound = arg->argType->itStruct && arg->argType->itInLine;
2192
  if (RPCPort(arg) || RPCPortArray(arg) ||
      RPCFixedArray(arg) || RPCVariableArray(arg)) {
    WriteRPCArgDescriptor(file, arg, offset);
    size = 4;
  }
  if (! size) {
    if (compound)
      size = arg->argType->itNumber * (arg->argType->itSize / 8);
    else
      size = (arg->argType->itSize / 8);
  }
  if (akCheck(arg->argKind, akbServerArg))
    offset += size;
  size = 0;
}
2208}
2209
2210
2211static void
2212WriteRPCSignature(FILE *file, routine_t *rt)
2213{
int arg_count = 0;
int descr_count = 0;
2216
fprintf(file, "    kern_return_t rtn;\n");
descr_count = rtCountArgDescriptors(rt->rtArgs, &arg_count);
fprintf(file, "    const static struct\n    {\n");
fprintf(file, "        struct rpc_routine_descriptor rd;\n");
fprintf(file, "        struct rpc_routine_arg_descriptor rad[%d];\n", descr_count);
fprintf(file, "    } sig =\n    {\n");
WriteRPCRoutineDescriptor(file, rt, arg_count, descr_count, "0", "sig.rad, 0");
fprintf(file, ",\n");
fprintf(file, "        {\n");
WriteRPCRoutineArgDescriptor(file, rt);
fprintf(file, "\n        }\n");
fprintf(file, "\n    };\n\n");
2229}
2230
2231static void
2232WriteRPCCall(FILE *file, routine_t *rt)
2233{
argument_t *arg;
int i;
2236
i = 0;
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  if (akIdent(arg->argKind) == akeRequestPort) {
    fprintf(file, "    rtn = (MACH_RPC(&sig, (mach_msg_size_t)sizeof(sig), %d, %s,\n", rt->rtNumber + SubsystemBase, arg->argVarName);
    fprintf(file, "                   (%s", arg->argVarName);
  }
  else if (akCheck(arg->argKind, akbServerArg)) {
    if (i && (i++ % 6 == 0))
      fprintf(file, ",\n                    ");
    else
      fprintf(file, ", ");
    fprintf(file, "%s", arg->argVarName);
  }
}
fprintf(file, ")));\n");
fprintf(file, "\n");
fprintf(file, "    if (rtn != KERN_NO_ACCESS) return rtn;\n\n");
fprintf(file, "/* The following message rpc code is generated for the network case */\n\n");
2255}
2256
2257static int
2258CheckRPCCall(routine_t *rt)
2259{
argument_t *arg;
int i;
2262
i = 0;
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  if (akCheck(arg->argKind, akbUserArg) &&
      ((arg->argType->itOutName == -1) || (arg->argType->itInName == -1))) {
    return FALSE;
  }
  if (arg->argFlags & flMaybeDealloc) {
    return FALSE;
  }
}
return TRUE;
2274}
2275
2276static void
2277WriteRPCRoutine(FILE *file, routine_t *rt)
2278{
if (CheckRPCCall(rt)) {
  WriteRPCSignature(file, rt);
  WriteRPCCall(file, rt);
}
2283}
2284
2285/********************** End UserRPCTrap Routines*************************/
2286
2287/* Process an IN/INOUT arg before the short-circuited RPC */
2288static void
2289WriteShortCircInArgBefore(FILE *file, argument_t *arg)
2290{
ipc_type_t *it = arg->argType;
char size[128];
2293
fprintf(file, "\n\t/* IN %s: */\n", arg->argVarName);
2295
if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD)) {
  switch (arg->argKPD_Type) {
2298
    case MACH_MSG_PORT_DESCRIPTOR:
      break;
2301
    case MACH_MSG_OOL_DESCRIPTOR:
      /* Arg is an out-of-line array: */
      if (!(arg->argFlags & flDealloc) &&
          (!(arg->argFlags & flAuto) || !(arg->argFlags & flConst))) {
        /* Need to map a copy of the array: */
        GetArraySize(arg, size);
        fprintf(file, "\t(void)vm_read(mach_task_self(),\n");
        fprintf(file, "\t\t      (vm_address_t) %s%s, %s, (vm_address_t *) &_%sTemp_, &_MIG_Ignore_Count_);\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, size, arg->argVarName);
        /* Point argument at the copy: */
        fprintf(file, "\t*(char **)&%s%s = _%sTemp_;\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, arg->argVarName);
      }
      else if ((arg->argFlags & flDealloc) &&
                 ((arg->argFlags & flAuto) || it->itMigInLine)) {
        /* Point the temp var at the original argument: */
        fprintf(file, "\t_%sTemp_ = (char *) %s%s;\n", arg->argVarName, (arg->argByReferenceUser ? "*" : ""), arg->argVarName);
      }
      break;
2319
    case MACH_MSG_OOL_PORTS_DESCRIPTOR:
      break;
2322
    default:
      printf("MiG internal error: type of kernel processed data unknown\n");
      exit(1);
  }   /* end of switch */
}
else if (it->itNumber > 1) {
  if (it->itStruct) {
    /* Arg is a struct -- nothing to do. */
  }
  else {
    /* Arg is a C string or an in-line array: */
    if (!argIsOut(arg) && !(arg->argFlags & flConst)) {
      /* Have to copy it into a temp.  Use a stack var, if this would
       * not overflow the -maxonstack specification:
       * Conservatively assume ILP32 thresholds
       */
      if (it->itTypeSize <= sizeof(natural_t) ||
          rtMessOnStack(arg->argRoutine) ||
          arg->argRoutine->rtTempBytesOnStack +
          it->itTypeSize <= MaxMessSizeOnStack) {
        fprintf(file, "\t{   char _%sTemp_[%d];\n", arg->argVarName, it->itTypeSize);
        arg->argRoutine->rtTempBytesOnStack += it->itTypeSize;
        arg->argTempOnStack = TRUE;
      }
      else {
        fprintf(file, "\t{   _%sTemp_ = (char *) %s(%d);\n", arg->argVarName, MessAllocRoutine, it->itTypeSize);
        arg->argTempOnStack = FALSE;
      }
      WriteCopyArg(file, arg, TRUE, "_%sTemp_", "/* %s */ (char *) %s", arg->argVarName, arg->argVarName);
      /* Point argument at temp: */
      fprintf(file, "\t    *(char **)&%s%s = _%sTemp_;\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, arg->argVarName);
      fprintf(file, "\t}\n");
    }
  }
}
2358}
2359
2360
2361/* Process an INOUT/OUT arg before the short-circuited RPC */
2362static void
2363WriteShortCircOutArgBefore(FILE *file, argument_t *arg)
2364{
ipc_type_t *it = arg->argType;
2366
fprintf(file, "\n\t/* OUT %s: */\n", arg->argVarName);
2368
if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD)) {
  switch (arg->argKPD_Type) {
2371
    case MACH_MSG_PORT_DESCRIPTOR:
      break;
2374
    case MACH_MSG_OOL_DESCRIPTOR:
      /* Arg is an out-of-line array: */
      if (!argIsIn(arg) && (arg->argFlags & flOverwrite)) {
        /* Point the temp var at the original argument: */
        fprintf(file, "\t    _%sTemp_ = (char *) %s%s;\n", arg->argVarName, (arg->argByReferenceUser ? "*" : ""), arg->argVarName);
      }
      break;
2382
    case MACH_MSG_OOL_PORTS_DESCRIPTOR:
      break;
2385
    default:
      printf("MiG internal error: type of kernel processed data unknown\n");
      exit(1);
  }   /* end of switch */
}
else if (it->itNumber > 1) {
  /* Arg is an in-line array: */
}
2394}
2395
2396
2397
2398/* Process an IN arg after the short-circuited RPC */
2399static void
2400WriteShortCircInArgAfter(FILE *file, argument_t *arg)
2401{
ipc_type_t *it = arg->argType;
char size[128];
2404
fprintf(file, "\n\t/* IN %s: */\n", arg->argVarName);
2406
if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD)) {
  switch (arg->argKPD_Type) {
2409
    case MACH_MSG_PORT_DESCRIPTOR:
      break;
2412
    case MACH_MSG_OOL_DESCRIPTOR:
      /* Arg is an out-of-line array: */
      GetArraySize(arg, size);
      if ((!(arg->argFlags & flAuto) && it->itMigInLine) ||
          ((arg->argFlags & flAuto) &&
           ((arg->argFlags & flDealloc) ||
            !(arg->argFlags & flConst))
           )) {
            /* Need to dealloc the temporary: */
            fprintf(file, "\t(void)vm_deallocate(mach_task_self(),");
        fprintf(file, " (vm_address_t *) _%sTemp_, %s);\n", arg->argVarName, size);
          }
      break;
2426
    case MACH_MSG_OOL_PORTS_DESCRIPTOR:
      break;
2429
    default:
      printf("MiG internal error: type of kernel processed data unknown\n");
      exit(1);
  }   /* end of switch */
}
else if (it->itNumber > 1) {
  if (it->itStruct) {
    /* Arg is a struct -- nothing to do. */
  }
  else {
    /* Arg is a C string or an in-line array: */
    if (!argIsOut(arg) && !(arg->argFlags & flConst)) {
      /* A temp needs to be deallocated, if not on stack: */
      if (!arg->argTempOnStack) {
        fprintf(file, "\t%s(_%sTemp_, %d);\n", MessFreeRoutine, arg->argVarName, it->itTypeSize);
      }
    }
  }
}
2449}
2450
2451static void
2452WriteShortCircOutArgAfter(FILE *file, argument_t *arg)
2453{
ipc_type_t *it = arg->argType;
char size[128];
2456
fprintf(file, "\n\t/* OUT %s: */\n", arg->argVarName);
2458
if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD)) {
  switch (arg->argKPD_Type) {
2461
    case MACH_MSG_PORT_DESCRIPTOR:
      break;
2464
    case MACH_MSG_OOL_DESCRIPTOR:
      /* Arg is an out-of-line array: */
2467
      /* Calculate size of array: */
      GetArraySize(arg, size);
      if (!(arg->argFlags & flDealloc) || (arg->argFlags & flOverwrite)) {
        /* Copy argument to vm_allocated Temp: */
        fprintf(file, "\t(void)vm_read(mach_task_self(),\n");
        fprintf(file, "\t\t      (vm_address_t) %s%s, %s, (vm_address_t *) &_%sTemp_, &_MIG_Ignore_Count_);\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, size, arg->argVarName);
        if (!argIsIn(arg) && (arg->argFlags & flDealloc) &&
            (arg->argFlags & flOverwrite)) {
          /* Deallocate argument returned by server */
          fprintf(file, "\t(void)vm_deallocate(mach_task_self(),");
          fprintf(file, " (vm_address_t *) %s%s, %s);\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, size);
        }
        /* Point argument at new temporary: */
        fprintf(file, "\t*(char **)&%s%s = _%sTemp_;\n", (arg->argByReferenceUser ? "*" : ""), arg->argVarName, arg->argVarName);
      }
      break;
2484
    case MACH_MSG_OOL_PORTS_DESCRIPTOR:
      break;
2487
    default:
      printf("MiG internal error: type of kernel processed data unknown\n");
      exit(1);
  }   /* end of switch */
}
else if (it->itNumber != 1) {
  /* Arg is an in-line array: */
}
2496}
2497
2498
2499static void
2500WriteShortCircRPC(FILE *file, routine_t *rt)
2501{
argument_t *arg;
int server_argc, i;
boolean_t ShortCircOkay = TRUE;
boolean_t first_OOL_arg = TRUE;
2506
fprintf(file, "    if (0 /* Should be: !(%s & 0x3) XXX */) {\n", rt->rtRequestPort->argVarName);
2508
if (rt->rtOneWay) {
  /* Do not short-circuit simple routines: */
  ShortCircOkay = FALSE;
}
else {
  /* Scan for any types we can't yet handle.  If found, give up on short-
   * circuiting and fall back to mach_msg:
   */
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
    if (arg->argFlags & flMaybeDealloc) {
      ShortCircOkay = FALSE;
      break;
    }
    /* Can't yet handle ports: */
    if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD) &&
        (arg->argKPD_Type == MACH_MSG_PORT_DESCRIPTOR ||
         arg->argKPD_Type == MACH_MSG_OOL_PORTS_DESCRIPTOR)) {
          ShortCircOkay = FALSE;
          break;
        }
  }
}
2531
if (ShortCircOkay) {
2533
  fprintf(file,"      rpc_subsystem_t subsystem = ((rpc_port_t)%s)->rp_subsystem;\n", rt->rtRequestPort->argVarName);
  fprintf(file, "\n");
  fprintf(file, "      if (subsystem && subsystem->start == %d) {\n", SubsystemBase);
  fprintf(file, "\tkern_return_t rtn;\n");
  fprintf(file, "\n");
2539
  /* Declare temp vars for out-of-line array args, and for all array
   * args, if -maxonstack has forced us to allocate in-line arrays
   * off the stack:
   */
  rt->rtTempBytesOnStack = 0;
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
    arg->argTempOnStack = FALSE;
    if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD) &&
        arg->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
      if (first_OOL_arg) {
        /* Need a garbage temporary to hold the datacount
         * returned by vm_read, which we always ignore:
         */
        fprintf(file, "\tmach_msg_type_number_t _MIG_Ignore_Count_;\n");
        first_OOL_arg = FALSE;
      }
    }
    else if (!rtMessOnStack(rt) &&
               arg->argType->itNumber > 1 && !arg->argType->itStruct) {
    }
    else
      continue;
    fprintf(file, "\tchar *_%sTemp_;\n", arg->argVarName);
    /* Conservatively assume ILP32 thresholds */
    rt->rtTempBytesOnStack += sizeof(natural_t);
  }
2566
  /* Process the IN arguments, in order: */
2568
  fprintf(file, "\t/* Pre-Process the IN arguments: */\n");
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
    if (argIsIn(arg))
      WriteShortCircInArgBefore(file, arg);
    if (argIsOut(arg))
      WriteShortCircOutArgBefore(file, arg);
  }
  fprintf(file, "\n");
2577
  /* Count the number of server args: */
  server_argc = 0;
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
    if (akCheck(arg->argKind, akbServerArg))
      server_argc++;
2583
  /* Call RPC_SIMPLE to switch to server stack and function: */
  i = 0;
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
    if (akIdent(arg->argKind) == akeRequestPort) {
      fprintf(file, "\trtn = RPC_SIMPLE(%s, %d, %d, (", arg->argVarName, rt->rtNumber + SubsystemBase, server_argc);
      fprintf(file, "%s", arg->argVarName);
    }
    else if (akCheck(arg->argKind, akbServerArg)) {
      if (i++ % 6 == 0)
        fprintf(file, ",\n\t\t");
      else
        fprintf(file, ", ");
      fprintf(file, "%s", arg->argVarName);
    }
  }
  fprintf(file, "));\n");
  fprintf(file, "\n");
2601
  /* Process the IN and OUT arguments, in order: */
  fprintf(file, "\t/* Post-Process the IN and OUT arguments: */\n");
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)  {
    if (argIsIn(arg))
      WriteShortCircInArgAfter(file, arg);
    if (argIsOut(arg))
      WriteShortCircOutArgAfter(file, arg);
  }
  fprintf(file, "\n");
2611
  fprintf(file, "\treturn rtn;\n");
  fprintf(file, "      }\n");
}
2615
/* In latest design, the following is not necessary, because in
 * kernel-loaded tasks, the Mach port name is the same as the handle
 * used by the RPC mechanism, namely a pointer to the ipc_port, and
 * in user-mode tasks, the Mach port name gets renamed to be a pointer
 * to the user-mode rpc_port_t struct.
 */
2622#if 0
if (IsKernelUser)
  fprintf(file, "      %s = (ipc_port_t)%s->rp_receiver_name;\n", rt->rtRequestPort->argVarName, rt->rtRequestPort->argVarName);
else
  fprintf(file, "      %s = ((rpc_port_t)%s)->rp_receiver_name;\n", rt->rtRequestPort->argVarName, rt->rtRequestPort->argVarName);
2627#endif
2628
fprintf(file, "    }\n");
2630}
2631
2632static void
2633WriteStubDecl(FILE *file, routine_t *rt)
2634{
fprintf(file, "\n");
fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName);
fprintf(file, "mig_external %s %s\n", ReturnTypeStr(rt), rt->rtUserName);
if (BeAnsiC) {
  fprintf(file, "(\n");
  WriteList(file, rt->rtArgs, WriteUserVarDecl, akbUserArg, ",\n", "\n");
  fprintf(file, ")\n");
}
else {
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "(\n");
  WriteList(file, rt->rtArgs, WriteUserVarDecl, akbUserArg, ",\n", "\n");
  fprintf(file, ")\n");
  fprintf(file, "#else\n");
  fprintf(file, "\t(");
  WriteList(file, rt->rtArgs, WriteNameDecl, akbUserArg, ", ", "");
  fprintf(file, ")\n");
  WriteList(file, rt->rtArgs, WriteUserVarDecl, akbUserArg, ";\n", ";\n");
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
fprintf(file, "{\n");
2656}
2657
2658static void
2659InitKPD_Disciplines(argument_t *args)
2660{
argument_t *arg;
extern void KPD_noop(FILE *file, argument_t *arg);
extern void KPD_error(FILE *file, argument_t *arg);
extern void WriteTemplateKPD_port(FILE *file, argument_t *arg, boolean_t in);
extern void WriteTemplateKPD_ool(FILE *file, argument_t *arg, boolean_t in);
extern void WriteTemplateKPD_oolport(FILE *file, argument_t *arg, boolean_t in);
2667
/*
 * WriteKPD_port,  WriteExtractKPD_port,
 * WriteKPD_ool,  WriteExtractKPD_ool,
 * WriteKPD_oolport,  WriteExtractKPD_oolport
 * are local to this module (which is the reason why this initialization
 * takes place here rather than in utils.c).
 * Common routines for user and server will be established SOON, and
 * all of them (including the initialization) will be transfert to
 * utils.c
 * All the KPD disciplines are defaulted to be KPD_error().
 * Note that akbSendKPD and akbReturnKPd are not exclusive,
 * because of inout type of parameters.
 */
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, akbSendKPD|akbReturnKPD))
    switch (arg->argKPD_Type) {
2684
      case MACH_MSG_PORT_DESCRIPTOR:
        arg->argKPD_Init = KPD_noop;
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Template = WriteTemplateKPD_port;
          arg->argKPD_Pack = WriteKPD_port;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_Extract = WriteExtractKPD_port;
          arg->argKPD_TypeCheck = WriteTCheckKPD_port;
        }
        break;
2696
      case MACH_MSG_OOL_DESCRIPTOR:
        arg->argKPD_Init = KPD_noop;
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Template = WriteTemplateKPD_ool;
          arg->argKPD_Pack = WriteKPD_ool;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_TypeCheck = WriteTCheckKPD_ool;
          arg->argKPD_Extract = WriteExtractKPD_ool;
        }
        break;
2708
      case MACH_MSG_OOL_PORTS_DESCRIPTOR:
        arg->argKPD_Init = KPD_noop;
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Template = WriteTemplateKPD_oolport;
          arg->argKPD_Pack = WriteKPD_oolport;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_TypeCheck = WriteTCheckKPD_oolport;
          arg->argKPD_Extract = WriteExtractKPD_oolport;
        }
        break;
2720
      default:
        printf("MiG internal error: type of kernel processed data unknown\n");
        exit(1);
    }   /* end of switch */
2725}
2726
2727static void
2728WriteLimitCheck(FILE *file, routine_t *rt)
2729{
if (MaxMessSizeOnStack == -1 || UserTypeLimit == -1)
  return;
if (!rt->rtRequestUsedLimit && !rt->rtReplyUsedLimit)
  return;
fprintf(file, "#if LimitCheck\n");
if (rt->rtRequestUsedLimit) {
  if (rt->rtRequestFits) {
    fprintf(file, "\tif ((sizeof(Request) - %d) > %d)\n", rt->rtRequestSizeKnown, UserTypeLimit);
    fprintf(file, "\t    __RequestOnStackAbort(%d, \"%s\");\n", SubsystemBase + rt->rtNumber, rt->rtName);
  }
  else if (rt->rtReplyFits) {
    fprintf(file, "\tif (sizeof(Request) < %d)\n", MaxMessSizeOnStack);
    fprintf(file, "\t    __MessageOffStackNote(%d, \"%s\");\n", SubsystemBase + rt->rtNumber, rt->rtName);
  }
}
if (rt->rtReplyUsedLimit) {
  if (rt->rtReplyFits) {
    fprintf(file, "\tif ((sizeof(Reply) - %d) > %d)\n", rt->rtReplySizeKnown, UserTypeLimit);
    fprintf(file, "\t    __ReplyOnStackAbort(%d, \"%s\");\n", SubsystemBase + rt->rtNumber, rt->rtName);
  }
  else if (rt->rtRequestFits) {
    fprintf(file, "\tif (sizeof(Reply) < %d)\n", MaxMessSizeOnStack);
    fprintf(file, "\t    __MessageOffStackNote(%d, \"%s\");\n", SubsystemBase + rt->rtNumber, rt->rtName);
  }
}
if (rt->rtRequestUsedLimit && rt->rtReplyUsedLimit &&
    ! (rt->rtRequestFits || rt->rtReplyFits)) {
  fprintf(file, "\tif (sizeof(Request) < %d \n", MaxMessSizeOnStack);
  fprintf(file, "&& sizeof(Reply) < %d)\n", MaxMessSizeOnStack);
  fprintf(file, "\t    __MessageOffStackNote(%d, \"%s\");\n", SubsystemBase + rt->rtNumber, rt->rtName);
}
fprintf(file, "#endif /* LimitCheck */\n");
2762}
2763
2764static void
2765WriteOOLSizeCheck(FILE *file, routine_t *rt)
2766{
/* Emit code to validate the actual size of ool data vs. the reported size */
argument_t  *argPtr;
boolean_t   openedTypeCheckConditional = FALSE;
2770
// scan through arguments to see if there are any ool data blocks
for (argPtr = rt->rtArgs; argPtr != NULL; argPtr = argPtr->argNext) {
  if (akCheck(argPtr->argKind, akbReturnKPD)) {
    ipc_type_t *it = argPtr->argType;
    boolean_t multiple_kpd = IS_MULTIPLE_KPD(it);
    char string[MAX_STR_LEN];
    boolean_t test;
    argument_t  *argCountPtr;
    char *tab;
2780
    if (argPtr->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
2782
      if (multiple_kpd) {
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2788
        WriteKPD_Iterator(file, FALSE, FALSE, FALSE, argPtr, TRUE);
        tab = "\t";
        sprintf(string, "ptr->");
        test = !it->itVarArray && !it->itElement->itVarArray;
        it = it->itElement; // point to element descriptor, so size calculation is correct
        argCountPtr = argPtr->argSubCount;
      } else {
        tab = "";
        sprintf(string, "Out%dP->%s.", argPtr->argReplyPos, argPtr->argMsgField);
        test = !it->itVarArray;
        argCountPtr = argPtr->argCount;
      }
2801
      if (!test) {
        int multiplier = (argCountPtr->argMultiplier > 1 || it->itSize > 8) ? argCountPtr->argMultiplier * it->itSize / 8 : 1;
2804
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2809
        fprintf(file, "\t%s" "if (%ssize ", tab, string);
        if (multiplier > 1)
          fprintf(file, "/ %d ", multiplier);
        fprintf(file,"!= Out%dP->%s%s", argCountPtr->argReplyPos, argCountPtr->argVarName, multiple_kpd ? "[i]" : "");
        if (it->itOOL_Number) {
          fprintf(file," || Out%dP->%s%s > %d", argCountPtr->argReplyPos,
     argCountPtr->argVarName, multiple_kpd ? "[i]" : "", it->itOOL_Number);
        }
        fprintf(file,")\n");
        fprintf(file, "\t\t%s" "return MIG_TYPE_ERROR;\n", tab);
      }
2821
      if (multiple_kpd)
        fprintf(file, "\t    }\n\t}\n");
    } else if (argPtr->argKPD_Type == MACH_MSG_OOL_PORTS_DESCRIPTOR) {
if (multiple_kpd) {
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2830
        WriteKPD_Iterator(file, FALSE, FALSE, FALSE, argPtr, TRUE);
        tab = "\t";
        sprintf(string, "ptr->");
        test = !it->itVarArray && !it->itElement->itVarArray;
        it = it->itElement; // point to element descriptor, so size calculation is correct
        argCountPtr = argPtr->argSubCount;
      } else {
        tab = "";
        sprintf(string, "Out%dP->%s.", argPtr->argReplyPos, argPtr->argMsgField);
        test = !it->itVarArray;
        argCountPtr = argPtr->argCount;
      }
2843
      if (!test) {
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2849
        fprintf(file, "\t%s" "if (%scount ", tab, string);
        fprintf(file,"!= Out%dP->%s%s", argCountPtr->argReplyPos, argCountPtr->argVarName, multiple_kpd ? "[i]" : "");
        if (it->itOOL_Number) {
          fprintf(file," || Out%dP->%s%s > %d", argCountPtr->argReplyPos,
     argCountPtr->argVarName, multiple_kpd ? "[i]" : "", it->itOOL_Number);
        }
        fprintf(file,")\n");
        fprintf(file, "\t\t%s" "return MIG_TYPE_ERROR;\n", tab);
      }
2859
if (multiple_kpd)
        fprintf(file, "\t    }\n\t}\n");
    }
  }
}
2865
if ( openedTypeCheckConditional )
  fputs("#endif" "\t" "/* __MigTypeCheck */" "\n\n", file);
2868}
2869
2870static void
2871WriteCheckReply(FILE *file, routine_t *rt)
2872{
int i;
2874
/* initialize the disciplines for the handling of KPDs */
InitKPD_Disciplines(rt->rtArgs);
2877
if (rt->rtOneWay)
  return;
2880
fprintf(file, "\n");
fprintf(file, "#if ( __MigTypeCheck ");
if (CheckNDR)
 fprintf(file, "|| __NDR_convert__ ");
fprintf(file, ")\n");
fprintf(file, "#if __MIG_check__Reply__%s_subsystem__\n", SubsystemName);
fprintf(file, "#if !defined(__MIG_check__Reply__%s_t__defined)\n", rt->rtName);
fprintf(file, "#define __MIG_check__Reply__%s_t__defined\n", rt->rtName);
if (CheckNDR && akCheck(rt->rtNdrCode->argKind, akbReply)) {
  WriteList(file, rt->rtArgs, WriteReplyNDRConvertIntRepArgDecl, akbReturnNdr, "\n", "\n");
  WriteList(file, rt->rtArgs, WriteReplyNDRConvertCharRepArgDecl, akbReturnNdr, "\n", "\n");
  WriteList(file, rt->rtArgs, WriteReplyNDRConvertFloatRepArgDecl, akbReturnNdr, "\n", "\n");
}
fprintf(file, "\n");
fprintf(file, "mig_internal kern_return_t __MIG_check__Reply__%s_t(__Reply__%s_t *Out0P", rt->rtName, rt->rtName);
for (i = 1; i <= rt->rtMaxReplyPos; i++)
  fprintf(file, ", __Reply__%s_t **Out%dPP", rt->rtName, i);
fprintf(file, ")\n{\n");
2899
2900
fprintf(file, "\n\ttypedef __Reply__%s_t __Reply __attribute__((unused));\n", rt->rtName);
for (i = 1; i <= rt->rtMaxReplyPos; i++)
  fprintf(file, "\t__Reply *Out%dP;\n", i);
if (!rt->rtSimpleReply)
  fprintf(file, "\tboolean_t msgh_simple;\n");
if (!rt->rtNoReplyArgs) {
  fprintf(file, "#if\t__MigTypeCheck\n");
  fprintf(file, "\tunsigned int msgh_size;\n");
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
if (rt->rtMaxReplyPos > 0)
  fprintf(file, "\tunsigned int msgh_size_delta;\n");
if (rt->rtNumReplyVar > 0 || rt->rtMaxReplyPos > 0)
  fprintf(file, "\n");
2915
/* Check the values that are returned in the reply message */
2917
WriteCheckIdentity(file, rt);
2919
/* Check the remote port is NULL */
fprintf(file, "#if\t__MigTypeCheck\n");
fprintf(file, "\tif (Out0P->Head.msgh_request_port != MACH_PORT_NULL) {\n");
fprintf(file, "\t\treturn MIG_TYPE_ERROR;\n");
fprintf(file, "\t}\n");
fprintf(file, "#endif\t/* __MigTypeCheck */\n");
2926
/* If the reply message has no Out parameters or return values
   other than the return code, we can type-check it and
   return it directly. */
2930
if (rt->rtNoReplyArgs && !rt->rtUserImpl) {
  if (CheckNDR && akCheck(rt->rtNdrCode->argKind, akbReply) && rt->rtRetCode)
    WriteReplyNDRConvertIntRepOneArgUse(file, rt->rtRetCode);
  WriteReturn(file, rt, "\t", stRetCode, "\n", FALSE);
}
else {
  if (UseEventLogger)
    WriteLogMsg(file, rt, LOG_USER, LOG_REPLY);
2939
  WriteRetCodeCheck(file, rt);
2941
  /* Type Checking for the Out parameters which are typed */
  WriteList(file, rt->rtArgs, WriteTypeCheck, akbReturnKPD, "\n", "\n");
2944
  {
    argument_t *arg, *lastVarArg;
2947
    lastVarArg = argNULL;
    for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
      /*
       * Advance message pointer if the last reply argument was
       * variable-length and the reply position will change.
       */
      if (lastVarArg != argNULL &&
          lastVarArg->argReplyPos < arg->argReplyPos) {
        WriteAdjustReplyMsgPtr(file, lastVarArg);
        lastVarArg = argNULL;
      }
2959
      if (akCheckAll(arg->argKind, akbReturnRcv|akbReturnBody)) {
        if (akCheck(arg->argKind, akbVariable)) {
          WriteCheckMsgSize(file, arg);
          lastVarArg = arg;
        }
      }
    }
  }
2968
  if (CheckNDR && akCheck(rt->rtNdrCode->argKind, akbReply)) {
    fprintf(file, "#if\t");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertIntRepArgCond, akbReturnNdr, " || \\\n\t", "\n");
    fprintf(file, "\tif (Out0P->NDR.int_rep != NDR_record.int_rep) {\n");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertIntRepArgUse, akbReturnNdr, "", "");
    fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__int_rep...) */\n\n");
2975
    WriteOOLSizeCheck(file, rt);
2977
    fprintf(file, "#if\t");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertCharRepArgCond, akbReturnNdr, " || \\\n\t", "\n");
    fprintf(file, "\tif (Out0P->NDR.char_rep != NDR_record.char_rep) {\n");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertCharRepArgUse, akbReturnNdr, "", "");
    fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__char_rep...) */\n\n");
2983
    fprintf(file, "#if\t");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertFloatRepArgCond, akbReturnNdr, " || \\\n\t", "\n");
    fprintf(file, "\tif (Out0P->NDR.float_rep != NDR_record.float_rep) {\n");
    WriteList(file, rt->rtArgs, WriteReplyNDRConvertFloatRepArgUse, akbReturnNdr, "", "");
    fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__float_rep...) */\n\n");
  } else {
      WriteOOLSizeCheck(file, rt);
  }
  fprintf(file, "\treturn MACH_MSG_SUCCESS;\n");
}
fprintf(file, "}\n");
fprintf(file, "#endif /* !defined(__MIG_check__Reply__%s_t__defined) */\n", rt->rtName);
fprintf(file, "#endif /* __MIG_check__Reply__%s_subsystem__ */\n", SubsystemName);
fprintf(file, "#endif /* ( __MigTypeCheck ");
if (CheckNDR)
 fprintf(file, "|| __NDR_convert__ ");
fprintf(file, ") */\n\n");
3001}
3002
3003static void
3004WriteCheckReplyCall(FILE *file, routine_t *rt)
3005{
int i;
3007
fprintf(file, "\n");
fprintf(file, "#if\tdefined(__MIG_check__Reply__%s_t__defined)\n", rt->rtName);
fprintf(file, "\tcheck_result = __MIG_check__Reply__%s_t((__Reply__%s_t *)Out0P", rt->rtName, rt->rtName);
for (i = 1; i <= rt->rtMaxReplyPos; i++)
  fprintf(file, ", (__Reply__%s_t **)&Out%dP", rt->rtName, i);
fprintf(file, ");\n");
fprintf(file, "\tif (check_result != MACH_MSG_SUCCESS) {\n");
if (IsKernelUser) {
    fprintf(file, "#if\t__MigKernelSpecificCode\n");
    fprintf(file, "\t\tmach_msg_destroy_from_kernel(&Out0P->Head);\n");
    fprintf(file, "#endif\t/* __MigKernelSpecificCode */\n");
} else {
    fprintf(file, "\t\tmach_msg_destroy(&Out0P->Head);\n");
}
WriteReturnMsgError(file, rt, TRUE, argNULL, "check_result");
fprintf(file, "\t}\n");
fprintf(file, "#endif\t/* defined(__MIG_check__Reply__%s_t__defined) */\n", rt->rtName);
fprintf(file, "\n");
3026}
3027
3028void
3029WriteCheckReplies(FILE *file, statement_t *stats)
3030{
statement_t *stat;
3032
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine)
    WriteCheckReply(file, stat->stRoutine);
3036}
3037
3038static void
3039WriteCheckReplyTrailerArgs(FILE *file, routine_t *rt)
3040{
argument_t *arg;
3042
if (rt->rtUserImpl)
  WriteCheckTrailerHead(file, rt, TRUE);
3045
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  if (akCheck(arg->argKind, akbUserImplicit))
    WriteCheckTrailerSize(file, TRUE, arg);
}
if (rt->rtUserImpl)
  fprintf(file, "\n");
3052}
3053
3054
3055/*************************************************************
*  Writes all the code comprising a routine body. Called by
*  WriteUser for each routine.
*************************************************************/
3059static void
3060WriteRoutine(FILE *file, routine_t *rt)
3061{
/* write the stub's declaration */
WriteStubDecl(file, rt);
3064
/* Use the RPC trap for user-user and user-kernel RPC */
if (UseRPCTrap)
  WriteRPCRoutine(file, rt);
3068
/* write the code for doing a short-circuited RPC: */
if (ShortCircuit)
  WriteShortCircRPC(file, rt);
3072
/* typedef of structure for Request and Reply messages */
WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "Request", rt->rtSimpleRequest, FALSE, FALSE, FALSE);
if (!rt->rtOneWay) {
  WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply, "Reply", rt->rtSimpleReply, TRUE, rt->rtUserImpl, FALSE);
  WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply, "__Reply", rt->rtSimpleReply, FALSE, FALSE, FALSE);
}
if (rt->rtOverwrite)
  WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply|akbOverwrite, "OverwriteTemplate", FALSE, TRUE, FALSE, TRUE);
/*
 * Define a Minimal Reply structure to be used in case of errors
 */
fprintf(file, "\t/*\n");
fprintf(file, "\t * typedef struct {\n");
fprintf(file, "\t * \tmach_msg_header_t Head;\n");
fprintf(file, "\t * \tNDR_record_t NDR;\n");
fprintf(file, "\t * \tkern_return_t RetCode;\n");
fprintf(file, "\t * } mig_reply_error_t;\n");
fprintf(file, "\t */\n");
fprintf(file, "\n");
3092
3093
/* declarations for local vars: Union of Request and Reply messages,
   InP, OutP and return value */
3096
WriteVarDecls(file, rt);
3098
/* declarations and initializations of the mach_msg_type_descriptor_t variables
   for each argument that is a Kernel Processed Data */
3101
WriteList(file, rt->rtArgs, WriteTemplateDeclIn, akbRequest | akbSendKPD, "\n", "\n");
3103
WriteLimitCheck(file, rt);
WriteRetCodeArg(file, rt);
3106
/* fill in the fields that are non related to parameters */
3108
if (!rt->rtSimpleRequest)
  fprintf(file, "\tInP->msgh_body.msgh_descriptor_count = %d;\n", rt->rtRequestKPDs);
3111
/* fill in all the request message types and then arguments */
3113
WriteRequestArgs(file, rt);
3115
/* fill in request message head */
3117
WriteRequestHead(file, rt);
fprintf(file, "\n");
3120
/* give the application a chance to do some stuff. */
WriteApplMacro(file, "Send", "Before", rt);
3123
/* Write the send/receive or rpc call */
3125
if (UseEventLogger)
  WriteLogMsg(file, rt, LOG_USER, LOG_REQUEST);
3128
3129
if (rt->rtOneWay) {
  WriteMsgSend(file, rt);
}
else {
  if (UseMsgRPC
3135#if USE_IMMEDIATE_SEND_TIMEOUT
      && (rt->rtWaitTime == argNULL)
3137#endif
      ) {
    /* overwrite mode meaningful only when UseMsgRPC is enabled */
    if (rt->rtOverwrite)
      WriteOverwriteTemplate(file, rt);
    WriteMsgRPC(file, rt);
  }
  else
    WriteMsgSendReceive(file, rt);
3146
  WriteCheckReplyCall(file, rt);
  WriteCheckReplyTrailerArgs(file, rt);
3149
  if (UseEventLogger)
    WriteLogMsg(file, rt, LOG_USER, LOG_REPLY);
3152
  WriteReplyArgs(file, rt);
}
/* return the return value, if any */
if (!rt->rtOneWay)  // WriteMsgSend() already wrote the 'return'
  WriteReturnValue(file, rt);
fprintf(file, "}\n");
3159}
3160
3161static void
3162WriteRPCClientFunctions(FILE *file, statement_t *stats)
3163{
statement_t *stat;
char *fname;
char *argfmt = "(mach_port_t, char *, mach_msg_type_number_t)";
3167
fprintf(file, "#ifdef AUTOTEST\n");
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    fname = stat->stRoutine->rtName;
    fprintf(file, "extern void client_%s%s;\n", fname, argfmt);
  }
fprintf(file, "function_table_entry %s_client_functions[] =\n", SubsystemName);
fprintf(file, "{\n");
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    fname = stat->stRoutine->rtName;
    fprintf(file, "    { \"%s\", client_%s },\n", fname, fname);
  }
fprintf(file, "    { (char *) 0, (function_ptr_t) 0 }\n");
fprintf(file, "};\n");
fprintf(file, "#endif /* AUTOTEST */\n");
3184}
3185
3186/*************************************************************
*  Writes out the xxxUser.c file. Called by mig.c
*************************************************************/
3189void
3190WriteUser(FILE *file, statement_t *stats)
3191{
statement_t *stat;
3193
WriteProlog(file, stats);
if (TestRPCTrap)
  WriteRPCClientFunctions(file, stats);
for (stat = stats; stat != stNULL; stat = stat->stNext)
  switch (stat->stKind) {
3199
    case skRoutine:
      WriteCheckReply(file, stat->stRoutine);
      WriteRoutine(file, stat->stRoutine);
      break;
3204
    case skImport:
    case skUImport:
    case skSImport:
    case skDImport:
    case skIImport:
      break;
3211
    default:
    fatal("WriteUser(): bad statement_kind_t (%d)", (int) stat->stKind);
  }
WriteEpilog(file);
3216}
3217
3218/*************************************************************
*  Writes out individual .c user files for each routine.  Called by mig.c
*************************************************************/
3221void
3222WriteUserIndividual(statement_t *stats)
3223{
statement_t *stat;
3225
for (stat = stats; stat != stNULL; stat = stat->stNext)
  switch (stat->stKind) {
3228
    case skRoutine: {
      FILE *file;
      char *filename;
3232
      filename = strconcat(UserFilePrefix, strconcat(stat->stRoutine->rtName, ".c"));
      file = fopen(filename, "w");
      if (file == NULL)
        fatal("fopen(%s): %s", filename, strerror(errno));
      WriteProlog(file, stats);
      WriteRoutine(file, stat->stRoutine);
      WriteEpilog(file);
      fclose(file);
      strfree(filename);
    }
      break;
3244
    case skImport:
    case skUImport:
    case skSImport:
    case skDImport:
    case skIImport:
      break;
3251
    default:
      fatal("WriteUserIndividual(): bad statement_kind_t (%d)", (int) stat->stKind);
  }
3255}