bootstrap_cmds/migcom.tproj/server.c

bootstrap_cmds source @ c71d2d7 2025-04-30 · 2939 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/*
* @OSF_COPYRIGHT@
*/
26/*
* 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 "AS IS"
* 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 Mellon
* the rights to redistribute these changes.
*/
51
52#include <assert.h>
53#include <stdlib.h>
54
55#include <mach/message.h>
56#include "write.h"
57#include "utils.h"
58#include "global.h"
59#include "error.h"
60
61#ifndef max
62#define max(a,b) (((a) > (b)) ? (a) : (b))
63#endif  /* max */
64
65void WriteLogDefines(FILE *file, string_t who);
66void WriteIdentificationString(FILE *file);
67static void WriteFieldDecl(FILE *file, argument_t *arg);
68
69#define InHeadSeg  (UseMachMsg2 ? "InKP" : "In0P")
70#define OutHeadSeg (UseMachMsg2 ? "OutKP" : "OutP")
71
72/* Bear Trap: Certain MIG features are left unimplemented for mach_msg2() KernelServer */
73#define __KernelServer_unreachable() \
74do {\
if (UseMachMsg2) \
  fatal("mach_msg2 KernelServer support for this code block is unimplemented."); \   
77} while (0)
78
79static void
80WriteKPD_Iterator(FILE *file, boolean_t in, boolean_t varying, argument_t *arg, boolean_t bracket)
81{
ipc_type_t *it = arg->argType;
char string[MAX_STR_LEN];
84
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");
91
if (in)
  sprintf(string, "%s", arg->argInSegment);
else
  sprintf(string, "%s", arg->argOutSegment);
96
fprintf(file, "\t    ptr = &%s->%s[0];\n", string, arg->argMsgField);
98
if (varying) {
  argument_t *count = arg->argCount;
101
  if (in)
    fprintf(file, "\t    for (i = 0; i < %s->%s; ptr++, i++) %s\n", count->argInSegment, count->argMsgField, (bracket) ? "{" : "");
  else {
    fprintf(file, "\t    j = min(%d, ", it->itKPD_Number);
    if (akCheck(count->argKind, akbVarNeeded))
      fprintf(file, "%s);\n", count->argName);
    else
      fprintf(file, "%s->%s);\n", string, count->argMsgField);
    fprintf(file, "\t    for (i = 0; i < j; ptr++, i++) %s\n", (bracket) ? "{" : "");
  }
112}
else
  fprintf(file, "\t    for (i = 0; i < %d; ptr++, i++) %s\n", it->itKPD_Number, (bracket) ? "{" : "");
115}
116
117static void
118WriteMyIncludes(FILE *file, statement_t *stats)
119{
if (ServerHeaderFileName == strNULL || UseSplitHeaders)
  WriteIncludes(file, FALSE, FALSE);
if (ServerHeaderFileName != strNULL)
{
  char *cp;
125
  /* Strip any leading path from ServerHeaderFileName. */
  cp = strrchr(ServerHeaderFileName, '/');
  if (cp == 0)
    cp = ServerHeaderFileName;
  else
    cp++;       /* skip '/' */
  fprintf(file, "#include \"%s\"\n", cp);
}
if (ServerHeaderFileName == strNULL || UseSplitHeaders)
  WriteImplImports(file, stats, FALSE);
if (UseEventLogger) {
  if (IsKernelServer) {
    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");
}
146
fprintf(file, "\n");
148}
149
150static void
151WriteGlobalDecls(FILE *file)
152{
if (BeAnsiC) {
  fprintf(file, "#define novalue void\n");
}
else {
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "#define novalue void\n");
  fprintf(file, "#else\n");
  fprintf(file, "#define novalue int\n");
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
fprintf(file, "\n");
164
if (RCSId != strNULL)
  WriteRCSDecl(file, strconcat(SubsystemName, "_server"), RCSId);
167
/* Used for locations in the request message, *not* reply message.
 Reply message locations aren't dependent on IsKernelServer. */
170
if (IsKernelServer) {
  fprintf(file, "#if\t__MigKernelSpecificCode\n");
  fprintf(file, "#define msgh_request_port\tmsgh_remote_port\n");
  fprintf(file, "#define MACH_MSGH_BITS_REQUEST(bits)");
  fprintf(file, "\tMACH_MSGH_BITS_REMOTE(bits)\n");
  fprintf(file, "#define msgh_reply_port\t\tmsgh_local_port\n");
  fprintf(file, "#define MACH_MSGH_BITS_REPLY(bits)");
  fprintf(file, "\tMACH_MSGH_BITS_LOCAL(bits)\n");
  fprintf(file, "#else\n");
}
fprintf(file, "#define msgh_request_port\tmsgh_local_port\n");
fprintf(file, "#define MACH_MSGH_BITS_REQUEST(bits)");
fprintf(file, "\tMACH_MSGH_BITS_LOCAL(bits)\n");
fprintf(file, "#define msgh_reply_port\t\tmsgh_remote_port\n");
fprintf(file, "#define MACH_MSGH_BITS_REPLY(bits)");
fprintf(file, "\tMACH_MSGH_BITS_REMOTE(bits)\n");
if (IsKernelServer) {
  fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
}
fprintf(file, "\n");
if (UseEventLogger)
  WriteLogDefines(file, "MACH_MSG_LOG_SERVER");
fprintf(file, "#define MIG_RETURN_ERROR(X, code)\t{\\\n");
fprintf(file, "\t\t\t\t((mig_reply_error_t *)X)->RetCode = code;\\\n");
fprintf(file, "\t\t\t\t((mig_reply_error_t *)X)->NDR = NDR_record;\\\n");
fprintf(file, "\t\t\t\treturn;\\\n");
fprintf(file, "\t\t\t\t}\n");
fprintf(file, "\n");
199}
200
201
202static void
203WriteForwardDeclarations(FILE *file, statement_t *stats)
204{
statement_t *stat;
206
fprintf(file, "/* Forward Declarations */\n\n");
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    fprintf(file, "\nmig_internal novalue _X%s\n", stat->stRoutine->rtName);
    if (!UseMachMsg2) {
      fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);\n");
    } else {
      fprintf(file, "\t(mach_msg_header_t *InHeadP, void *InDataP, mach_msg_max_trailer_t *InTrailerP, "
        "mach_msg_header_t *OutHeadP, void *OutDataP);\n");
    }
  }
fprintf(file, "\n");
219}
220
221static void
222WriteMIGCheckDefines(FILE *file)
223{
 fprintf(file, "#define\t__MIG_check__Request__%s_subsystem__ 1\n", SubsystemName);
 fprintf(file, "\n");
226}
227
228static void
229WriteNDRDefines(FILE *file)
230{
 fprintf(file, "#define\t__NDR_convert__Request__%s_subsystem__ 1\n", SubsystemName);
 fprintf(file, "\n");
233}
234
235static void
236WriteProlog(FILE *file, statement_t *stats)
237{
WriteIdentificationString(file);
fprintf(file, "\n");
fprintf(file, "/* Module %s */\n", SubsystemName);
fprintf(file, "\n");
WriteMIGCheckDefines(file);
if (CheckNDR)
 WriteNDRDefines(file);
WriteMyIncludes(file, stats);
WriteBogusDefines(file);
WriteApplDefaults(file, "Rcv");
WriteGlobalDecls(file);
if (ServerHeaderFileName == strNULL) {
  WriteRequestTypes(file, stats);
  WriteReplyTypes(file, stats);
  WriteServerReplyUnion(file, stats);
}
254}
255
256static void
257WriteSymTabEntries(FILE *file, statement_t *stats)
258{
statement_t *stat;
u_int current = 0;
261
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    int num = stat->stRoutine->rtNumber;
    char  *name = stat->stRoutine->rtName;
    while (++current <= num)
      fprintf(file,"\t\t\t{ \"\", 0, 0 },\n");
    fprintf(file, "\t{ \"%s\", %d, _X%s },\n", name, SubsystemBase + current - 1, name);
  }
while (++current <= rtNumber)
  fprintf(file,"\t{ \"\", 0, 0 },\n");
272}
273
274static void
275WriteRoutineEntries(FILE *file, statement_t *stats)
276{
u_int current = 0;
statement_t *stat;
char *sig_array, *rt_name;
int arg_count, descr_count;
int offset = 0;
size_t serverSubsysNameLen = strlen(ServerSubsys);
char *kern_ = UseMachMsg2 ? "kern_" : "";
284
fprintf(file, "\t{\n");
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    routine_t *rt = stat->stRoutine;
    size_t       rtNameLen = strlen(rt->rtName);
290
    if (MaxServerReplyDescrs >= 0 && rt->rtReplyKPDs > MaxServerReplyDescrs) {
      fatal("WriteRoutine(): method %s uses %d reply descriptors (larger than %d)",
        rt->rtName, rt->rtReplyKPDs, MaxServerReplyDescrs);
    }
    if (MaxServerDescrs >= 0 && rt->rtRequestKPDs > MaxServerDescrs) {
      fatal("WriteRoutine(): method %s uses %d descriptors (larger than %d)",
        rt->rtName, rt->rtRequestKPDs, MaxServerDescrs);
    }
299
    // Include length of rt->rtName in calculation of necessary buffer size, since that string
    // is actually written into the buffer along with the Server Subsystem name.
    sig_array = (char *) malloc(serverSubsysNameLen + rtNameLen + 80);
    rt_name = (char *) malloc(rtNameLen + 5);
    while (current++ < rt->rtNumber)
      fprintf(file, "\t\t{0, 0, 0, 0, 0, 0},\n");
    // NOTE: if either of the two string constants in the sprintf() function calls below get
    // much longer, be sure to increase the constant '80' (in the first malloc() call) to ensure
    // that the allocated buffer is large enough. (Currently, I count 66 characters in the first
    // string constant, 65 in the second. 80 ought to be enough for now...)
    if (UseRPCTrap) {
      sprintf(sig_array, "&%s.arg_descriptor[%d], (mach_msg_size_t)sizeof(__Reply__%s_t)", ServerSubsys, offset, rt->rtName);
    }
    else {
      if (!UseMachMsg2) {
        sprintf(sig_array, "(routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__%s_t)", rt->rtName);
      } else {
        sprintf(sig_array, "%d, (mach_msg_size_t)sizeof(__Reply__%s_t)", rt->rtReplyKPDs, rt->rtName);
      }
    }
    sprintf(rt_name, "_X%s", rt->rtName);
    descr_count = rtCountArgDescriptors(rt->rtArgs, &arg_count);
    offset += descr_count;
323
    fprintf(file, "          { (mig_impl_routine_t) 0,\n\
        (mig_stub_%sroutine_t) %s, ", kern_, rt_name);
    fprintf(file, "%d, %d, %s}", arg_count, (UseRPCTrap) ? descr_count : 0, sig_array);
327
    fprintf(file, ",\n");
    free(sig_array);
    free(rt_name);
  }
while (current++ < rtNumber)
  fprintf(file, "\t\t{0, 0, 0, 0, 0, 0},\n");
334
fprintf(file, "\t}");
336}
337
338static void
339WriteArgDescriptorEntries(FILE *file, statement_t *stats)
340{
statement_t *stat;
342
fprintf(file, ",\n\n\t{\n");
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    routine_t *rt = stat->stRoutine;
347
    /* For each arg of the routine, write an arg descriptor:
     */
    WriteRPCRoutineArgDescriptor(file, rt);
  }
fprintf(file, "\t},\n\n");
353}
354
355
356/*
* Write out the description of this subsystem, for use in direct RPC
*/
359static void
360WriteSubsystem(FILE *file, statement_t *stats)
361{
statement_t *stat;
int descr_count = 0;
char *kern_ = "";
char *k = "";
char *kernel = "";
367
if (UseMachMsg2) {
  kern_ = "kern_";
  k = "k";
  kernel = "kernel ";
}
373
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    routine_t *rt = stat->stRoutine;
    descr_count += rtCountArgDescriptors(rt->rtArgs, (int *) 0);
  }
fprintf(file, "\n");
if (ServerHeaderFileName == strNULL) {
  WriteMigExternal(file);
  fprintf(file, "boolean_t %s(", ServerDemux);
  if (BeAnsiC) {
    fprintf(file, "\n\t\tmach_msg_header_t *InHeadP,");
    if (!UseMachMsg2) {
      fprintf(file, "\n\t\tmach_msg_header_t *OutHeadP");
    } else {
      fprintf(file, "\n\t\tvoid *InDataP,");
      fprintf(file, "\n\t\tmach_msg_header_t *OutHeadP,");
      fprintf(file, "\n\t\tvoid *OutDataP");
    }
  }
  fprintf(file, ");\n\n");
394
  WriteMigExternal(file);
  fprintf(file, "mig_%sroutine_t %s_routine(", kern_, ServerDemux);
  if (BeAnsiC) {
    fprintf(file, "\n\t\tmach_msg_header_t *InHeadP");
  }
  fprintf(file, ");\n\n");
}
fprintf(file, "\n/* Description of this %ssubsystem, for use in direct RPC */\n", kernel);
if (ServerHeaderFileName == strNULL) {
  fprintf(file, "const struct %s {\n", ServerSubsys);
  if (UseRPCTrap) {
    __KernelServer_unreachable();
    fprintf(file, "\tstruct subsystem *\tsubsystem;\t/* Reserved for system use */\n");
  }
  else {
    fprintf(file, "\tmig_%sserver_routine_t \t%sserver;\t/* Server routine */\n", kern_, k);
  }
  fprintf(file, "\tmach_msg_id_t\tstart;\t/* Min routine number */\n");
  fprintf(file, "\tmach_msg_id_t\tend;\t/* Max routine number + 1 */\n");
  fprintf(file, "\tunsigned int\tmaxsize;\t/* Max msg size */\n");
  if (UseRPCTrap) {
    fprintf(file, "\tvm_address_t\tbase_addr;\t/* Base address */\n");
    fprintf(file, "\tstruct rpc_routine_descriptor\t/* Array of routine descriptors */\n");
  }
  else {
    fprintf(file, "\tvm_address_t\treserved;\t/* Reserved */\n");
    fprintf(file, "\tstruct %sroutine_descriptor\t/* Array of routine descriptors */\n", kern_);
  }
  fprintf(file, "\t\t%sroutine[%d];\n", k, rtNumber);
  if (UseRPCTrap) {
    fprintf(file, "\tstruct rpc_routine_arg_descriptor\t/*Array of arg descriptors */\n");
    fprintf(file, "\t\targ_descriptor[%d];\n", descr_count);
  }
  fprintf(file, "} %s = {\n", ServerSubsys);
}
else {
  fprintf(file, "const struct %s %s = {\n", ServerSubsys, ServerSubsys);
}
if (UseRPCTrap) {
  fprintf(file, "\t0,\n");
}
else {
  fprintf(file, "\t%s_routine,\n", ServerDemux);
}
fprintf(file, "\t%d,\n", SubsystemBase);
fprintf(file, "\t%d,\n", SubsystemBase + rtNumber);
fprintf(file, "\t(mach_msg_size_t)sizeof(union __ReplyUnion__%s),\n", ServerSubsys);
if (UseRPCTrap) {
  fprintf(file, "\t(vm_address_t)&%s,\n", ServerSubsys);
}
else {
  fprintf(file, "\t(vm_address_t)0,\n");
}
WriteRoutineEntries(file, stats);
449
if (UseRPCTrap)
  WriteArgDescriptorEntries(file, stats);
else
  fprintf(file, "\n");
454
fprintf(file, "};\n\n");
456}
457
458#if NOT_CURRENTLY_USED
459
460static void
461WriteArraySizes(FILE *file, statement_t *stats)
462{
u_int current = 0;
statement_t *stat;
465
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine) {
    routine_t *rt = stat->stRoutine;
469
    while (current++ < rt->rtNumber)
      fprintf(file, "\t\t0,\n");
    fprintf(file, "\t\t(mach_msg_size_t)sizeof(__Reply__%s_t),\n", rt->rtName);
  }
while (current++ < rtNumber)
  fprintf(file, "\t\t\t0,\n");
476}
477
478#endif /* NOT_CURRENTLY_USED */
479
480void
481WriteServerRequestUnion(FILE *file, statement_t *stats)
482{
statement_t *stat;
484
fprintf(file, "\n");
fprintf(file, "/* union of all requests */\n\n");
fprintf(file, "#ifndef __RequestUnion__%s__defined\n", ServerSubsys);
fprintf(file, "#define __RequestUnion__%s__defined\n", ServerSubsys);
fprintf(file, "union __RequestUnion__%s {\n", ServerSubsys);
for (stat = stats; stat != stNULL; stat = stat->stNext) {
  if (stat->stKind == skRoutine) {
    routine_t *rt;
493
    rt = stat->stRoutine;
    fprintf(file, "\t__Request__%s_t Request_%s;\n", rt->rtName, rt->rtName);
  }
}
fprintf(file, "};\n");
fprintf(file, "#endif /* __RequestUnion__%s__defined */\n", ServerSubsys);
500}
501
502void
503WriteServerReplyUnion(FILE *file, statement_t *stats)
504{
statement_t *stat;
506
fprintf(file, "\n");
fprintf(file, "/* union of all replies */\n\n");
fprintf(file, "#ifndef __ReplyUnion__%s__defined\n", ServerSubsys);
fprintf(file, "#define __ReplyUnion__%s__defined\n", ServerSubsys);
fprintf(file, "union __ReplyUnion__%s {\n", ServerSubsys);
for (stat = stats; stat != stNULL; stat = stat->stNext) {
  if (stat->stKind == skRoutine) {
    routine_t *rt;
515
    rt = stat->stRoutine;
    fprintf(file, "\t__Reply__%s_t Reply_%s;\n", rt->rtName, rt->rtName);
  }
}
fprintf(file, "};\n");
fprintf(file, "#endif /* __ReplyUnion__%s__defined */\n", ServerSubsys);
522}
523
524static void
525WriteDispatcher(FILE *file, statement_t *stats)
526{
char *k = "";
char *kern_ = "";
529
if (UseMachMsg2) {
  k = "k";
  kern_ = "kern_";
}
534
/*
 * Write the subsystem stuff.
 */
fprintf(file, "\n");
WriteSubsystem(file, stats);
540
/*
 * Then, the server routine
 */
fprintf(file, "mig_external boolean_t %s\n", ServerDemux);
if (BeAnsiC) {
  if (!UseMachMsg2) {
    fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n");
  } else {
    fprintf(file, "\t(mach_msg_header_t *InHeadP, void *InDataP, mach_msg_max_trailer_t *InTrailerP,"
      " mach_msg_header_t *OutHeadP, void *OutDataP)\n");
  }
}
else {
  __KernelServer_unreachable();
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n");
  fprintf(file, "#else\n");
  fprintf(file, "\t(InHeadP, OutHeadP)\n");
  fprintf(file, "\tmach_msg_header_t *InHeadP, *OutHeadP;\n");
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
562
fprintf(file, "{\n");
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");
572
fprintf(file, "\tmig_%sroutine_t routine;\n", kern_);
fprintf(file, "\n");
575
fprintf(file, "\tOutHeadP->msgh_bits = ");
fprintf(file, "MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);\n");
fprintf(file, "\tOutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;\n");
fprintf(file, "\t/* Minimal size: routine() will update it if different */\n");
fprintf(file, "\tOutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);\n");
fprintf(file, "\tOutHeadP->msgh_local_port = MACH_PORT_NULL;\n");
fprintf(file, "\tOutHeadP->msgh_id = InHeadP->msgh_id + 100;\n");
fprintf(file, "\tOutHeadP->msgh_reserved = 0;\n");
fprintf(file, "\n");
585
fprintf(file, "\tif ((InHeadP->msgh_id > %d) || (InHeadP->msgh_id < %d) ||\n", SubsystemBase + rtNumber - 1, SubsystemBase);
fprintf(file, "\t    ((routine = %s.%sroutine[InHeadP->msgh_id - %d].%sstub_routine) == 0)) {\n", ServerSubsys, k, SubsystemBase, k);
fprintf(file, "\t\t((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;\n");
fprintf(file, "\t\t((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;\n");
if (UseEventLogger) {
  fprintf(file, "#if  MIG_DEBUG\n");
  fprintf(file, "\t\tLOG_ERRORS(MACH_MSG_LOG_SERVER, MACH_MSG_ERROR_UNKNOWN_ID,\n");
  fprintf(file, "\t\t\t&InHeadP->msgh_id, __FILE__, __LINE__);\n");
  fprintf(file, "#endif /* MIG_DEBUG */\n");
}
fprintf(file, "\t\treturn FALSE;\n");
fprintf(file, "\t}\n");
598
/* Call appropriate routine */
if (!UseMachMsg2)
  fprintf(file, "\t(*routine) (InHeadP, OutHeadP);\n");
else
  fprintf(file, "\t(*routine) (InHeadP, InDataP, InTrailerP, OutHeadP, OutDataP);\n");
604
fprintf(file, "\treturn TRUE;\n");
fprintf(file, "}\n");
fprintf(file, "\n");
608
/*
 * Then, the <subsystem>_server_routine routine
 */
fprintf(file, "mig_external mig_%sroutine_t %s_routine\n", kern_, ServerDemux);
if (BeAnsiC) {
  fprintf(file, "\t(mach_msg_header_t *InHeadP)\n");
}
else {
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "\t(mach_msg_header_t *InHeadP)\n");
  fprintf(file, "#else\n");
  fprintf(file, "\t(InHeadP)\n");
  fprintf(file, "\tmach_msg_header_t *InHeadP;\n");
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
624
fprintf(file, "{\n");
fprintf(file, "\tint msgh_id;\n");
fprintf(file, "\n");
fprintf(file, "\tmsgh_id = InHeadP->msgh_id - %d;\n", SubsystemBase);
fprintf(file, "\n");
fprintf(file, "\tif ((msgh_id > %d) || (msgh_id < 0))\n", rtNumber - 1);
fprintf(file, "\t\treturn 0;\n");
fprintf(file, "\n");
fprintf(file, "\treturn %s.%sroutine[msgh_id].%sstub_routine;\n", ServerSubsys, k, k);
fprintf(file, "}\n");
635
/* symtab */
637
if (GenSymTab) {
  fprintf(file,"\nmig_symtab_t _%sSymTab[] = {\n",SubsystemName);
  WriteSymTabEntries(file,stats);
  fprintf(file,"};\n");
  fprintf(file,"int _%sSymTabBase = %d;\n",SubsystemName,SubsystemBase);
  fprintf(file,"int _%sSymTabEnd = %d;\n",SubsystemName,SubsystemBase+rtNumber);
}
645}
646
647#if NOT_CURRENTLY_USED
648/*
*  Returns the return type of the server-side work function.
*  Suitable for "extern %s serverfunc()".
*/
652static char *
653ServerSideType(routine_t *rt)
654{
return rt->rtRetCode->argType->itTransType;
656}
657#endif /* NOT_CURRENTLY_USED */
658
659static void
660WriteRetCode(FILE *file, argument_t *ret)
661{
ipc_type_t *it = ret->argType;
663
if (akCheck(ret->argKind, akbVarNeeded)) {
  fprintf(file, "\t%s %s;\n", it->itTransType, ret->argVarName);
}
667}
668
669static void
670WriteLocalVarDecl(FILE *file, argument_t *arg)
671{
ipc_type_t *it = arg->argType;
ipc_type_t *btype = it->itElement;
674
if (IS_VARIABLE_SIZED_UNTYPED(it))
  fprintf(file, "\t%s %s[%d]", btype->itTransType, arg->argVarName, btype->itNumber ? it->itNumber/btype->itNumber : 0);
else if (IS_MULTIPLE_KPD(it)) {
  if (btype->itTransType != strNULL)
    fprintf(file, "\t%s %s[%d]", btype->itTransType, arg->argVarName, it->itKPD_Number);
  else
  /* arrays of ool or oolport */
    fprintf(file, "\tvoid *%s[%d]", arg->argVarName, it->itKPD_Number);
}
else
  fprintf(file, "\t%s %s", it->itTransType, arg->argVarName);
686}
687
688#if NOT_CURRENTLY_USED
689static void
690WriteServerArgDecl(FILE *file, argument_t *arg)
691{
fprintf(file, "%s %s%s", arg->argType->itTransType, arg->argByReferenceServer ? "*" : "", arg->argVarName);
693}
694#endif /* NOT_CURRENTLY_USED */
695
696/*
*  Writes the local variable declarations which are always
*  present:  InP, OutP, the server-side work function.
*/
700static void
701WriteVarDecls(FILE *file, routine_t *rt)
702{
int i;
704
if (!UseMachMsg2) {
  fprintf(file, "\tRequest *In0P = (Request *) InHeadP;\n");
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, "\tRequest *In%dP;\n", i);
  fprintf(file, "\tReply *OutP = (Reply *) OutHeadP;\n");
} else {
  fprintf(file, "\tRequestK *InKP = (RequestK *) InHeadP;\n");
  fprintf(file, "\tRequestU *In0UP = (RequestU *) InDataP;\n");
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, "\tRequestU *In%dUP;\n", i);
  fprintf(file, "\tReplyK *OutKP = (ReplyK *) OutHeadP;\n");
  fprintf(file, "\tReplyU *OutUP = (ReplyU *) OutDataP;\n");
  fprintf(file, "\t(void)OutUP;\n");
}
719
/* if reply is variable, we may need msgh_size_delta and msgh_size */
if (rt->rtNumReplyVar > 1)
  fprintf(file, "\tunsigned int msgh_size;\n");
if (rt->rtMaxReplyPos > 0)
  fprintf(file, "\tunsigned int msgh_size_delta;\n");
if (rt->rtNumReplyVar > 1 || rt->rtMaxReplyPos > 0)
  fprintf(file, "\n");
727
if (rt->rtServerImpl) {
  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, "#ifdef\t__MIG_check__Request__%s_t__defined\n", rt->rtName);
fprintf(file, "\tkern_return_t check_result;\n");
fprintf(file, "#endif\t/* __MIG_check__Request__%s_t__defined */\n", rt->rtName);
fprintf(file, "\n");
738}
739
740static void
741WriteReplyInit(FILE *file, routine_t *rt)
742{
fprintf(file, "\n");
if (!UseMachMsg2 && (rt->rtNumReplyVar > 1 || rt->rtMaxReplyPos))
  /* WritheAdjustMsgSize() has been executed at least once! */
  fprintf(file, "\tOutP = (Reply *) OutHeadP;\n");
747
if (!rt->rtSimpleReply)  /* complex reply message */
  fprintf(file, "\t%s->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;\n", OutHeadSeg);
750
if (rt->rtNumReplyVar == 0) {
  fprintf(file, "\t%s->Head.msgh_size = ", OutHeadSeg);
  rtMinReplySize(file, rt, "Reply");
  fprintf(file, ";\n");
}
else if (rt->rtNumReplyVar > 1)
  fprintf(file, "\t%s->Head.msgh_size = msgh_size;\n", OutHeadSeg);
/* the case rt->rtNumReplyVar = 1 is taken care of in WriteAdjustMsgSize() */
759}
760
761static void
762WriteRetCArgCheckError(FILE *file, routine_t *rt)
763{
fprintf(file, "\tif (!(%s->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) &&\n", InHeadSeg);
fprintf(file, "\t    (%s->Head.msgh_size == (mach_msg_size_t)sizeof(mig_reply_error_t)))\n", InHeadSeg);
fprintf(file, "\t{\n");
767}
768
769static void
770WriteRetCArgFinishError(FILE *file, routine_t *rt)
771{
argument_t *retcode = rt->rtRetCArg;
773
fprintf(file, "\treturn;\n");
fprintf(file, "\t}\n");
retcode->argMsgField = "KERN_SUCCESS";
777}
778
779static void
780WriteCheckHead(FILE *file, routine_t *rt)
781{
fprintf(file, "#if\t__MigTypeCheck\n");
if (rt->rtNumRequestVar > 0)
  fprintf(file, "\tmsgh_size = %s->Head.msgh_size;\n", InHeadSeg);
785
if (rt->rtSimpleRequest) {
  /* Expecting a simple message. */
  fprintf(file, "\tif ((%s->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n", InHeadSeg);
  if (rt->rtNumRequestVar > 0) {
    fprintf(file, "\t    (msgh_size < ");
    rtMinRequestSize(file, rt, "__Request");
    fprintf(file, ") ||  (msgh_size > (mach_msg_size_t)sizeof(__Request)))\n");
  }
  else
    fprintf(file, "\t    (%s->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))\n", InHeadSeg);
}
else {
  /* Expecting a complex message. */
799
  fprintf(file, "\tif (");
  if (rt->rtRetCArg != argNULL)
    fprintf(file, "(");
  fprintf(file, "!(%s->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n", InHeadSeg);
  fprintf(file, "\t    (%s->msgh_body.msgh_descriptor_count != %d) ||\n", InHeadSeg, rt->rtRequestKPDs);
  if (rt->rtNumRequestVar > 0) {
    fprintf(file, "\t    (msgh_size < ");
    rtMinRequestSize(file, rt, "__Request");
    fprintf(file, ") ||  (msgh_size > (mach_msg_size_t)sizeof(__Request))");
  }
  else
    fprintf(file, "\t    (%s->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))", InHeadSeg);
  if (rt->rtRetCArg == argNULL)
    fprintf(file, ")\n");
  else {
    fprintf(file, ") &&\n");
    fprintf(file, "\t    ((%s->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n", InHeadSeg);
    fprintf(file, "\t    %s->Head.msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||\n", InHeadSeg);
    fprintf(file, "\t    ((mig_reply_error_t *)%s)->RetCode == KERN_SUCCESS))\n", InHeadSeg);
  }
}
fprintf(file, "\t\treturn MIG_BAD_ARGUMENTS;\n");
fprintf(file, "#endif\t/* __MigTypeCheck */\n");
fprintf(file, "\n");
824}
825
826void
827WriteRequestNDRConvertIntRepArgCond(FILE *file, argument_t *arg)
828{
routine_t *rt = arg->argRoutine;
830
fprintf(file, "defined(__NDR_convert__int_rep__Request__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
832}
833
834void
835WriteRequestNDRConvertCharRepArgCond(FILE *file, argument_t *arg)
836{
routine_t *rt = arg->argRoutine;
838
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  fprintf(file, "defined(__NDR_convert__char_rep__Request__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
else
  fprintf(file, "0");
843}
844
845void
846WriteRequestNDRConvertFloatRepArgCond(FILE *file, argument_t *arg)
847{
routine_t *rt = arg->argRoutine;
849
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  fprintf(file, "defined(__NDR_convert__float_rep__Request__%s_t__%s__defined)", rt->rtName, arg->argMsgField);
else
  fprintf(file, "0");
854}
855
856void
857WriteRequestNDRConvertIntRepArgDecl(FILE *file, argument_t *arg)
858{
WriteNDRConvertArgDecl(file, arg, "int_rep", "Request");
860}
861
862void
863WriteRequestNDRConvertCharRepArgDecl(FILE *file, argument_t *arg)
864{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  WriteNDRConvertArgDecl(file, arg, "char_rep", "Request");
867}
868
869void
870WriteRequestNDRConvertFloatRepArgDecl(FILE *file, argument_t *arg)
871{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  WriteNDRConvertArgDecl(file, arg, "float_rep", "Request");
874}
875
876void
877WriteRequestNDRConvertArgUse(FILE *file, argument_t *arg, char *convert)
878{
routine_t *rt = arg->argRoutine;
argument_t *count = arg->argCount;
char argname[MAX_STR_LEN];
882
if ((akIdent(arg->argKind) == akeCount || akIdent(arg->argKind) == akeCountInOut) &&
    (arg->argParent && akCheck(arg->argParent->argKind, akbSendNdr)))
  return;
886
if (arg->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
  if (count && !arg->argSameCount && !strcmp(convert, "int_rep")) {
    fprintf(file, "#if defined(__NDR_convert__int_rep__Request__%s_t__%s__defined)\n", rt->rtName, count->argMsgField);
    fprintf(file, "\t\t__NDR_convert__int_rep__Request__%s_t__%s(&In%dP->%s, In%dP->NDR.int_rep);\n", rt->rtName, count->argMsgField, count->argRequestPos, count->argMsgField, count->argRequestPos);
    fprintf(file, "#endif\t/* __NDR_convert__int_rep__Request__%s_t__%s__defined */\n", rt->rtName, count->argMsgField);
  }
893
  sprintf(argname, "(%s)(In%dP->%s.address)", FetchServerType(arg->argType), arg->argRequestPos, arg->argMsgField);
}
else {
  sprintf(argname, "&In%dP->%s", arg->argRequestPos, arg->argMsgField);
}
899
fprintf(file, "#if defined(__NDR_convert__%s__Request__%s_t__%s__defined)\n", convert, rt->rtName, arg->argMsgField);
fprintf(file, "\t\t__NDR_convert__%s__Request__%s_t__%s(%s, In0P->NDR.%s", convert, rt->rtName, arg->argMsgField, argname, convert);
if (count)
  fprintf(file, ", In%dP->%s", count->argRequestPos, count->argMsgField);
fprintf(file, ");\n");
fprintf(file, "#endif\t/* __NDR_convert__%s__Request__%s_t__%s__defined */\n", convert, rt->rtName, arg->argMsgField);
906}
907
908void
909WriteRequestNDRConvertIntRepOneArgUse(FILE *file, argument_t *arg)
910{
routine_t *rt = arg->argRoutine;
char *where = UseMachMsg2 ? "UP" : "P";
913
fprintf(file, "#if defined(__NDR_convert__int_rep__Request__%s_t__%s__defined)\n", rt->rtName, arg->argMsgField);
fprintf(file, "\tif (In0%s->NDR.int_rep != NDR_record.int_rep)\n", where);
fprintf(file, "\t\t__NDR_convert__int_rep__Request__%s_t__%s(&%s->%s, %s->NDR.int_rep);\n", rt->rtName,
  arg->argMsgField, arg->argInSegment, arg->argMsgField, arg->argInSegment);
fprintf(file, "#endif\t/* __NDR_convert__int_rep__Request__%s_t__%s__defined */\n", rt->rtName, arg->argMsgField);
919}
920
921void
922WriteRequestNDRConvertIntRepArgUse(FILE *file, argument_t *arg)
923{
WriteRequestNDRConvertArgUse(file, arg, "int_rep");
925}
926
927void
928WriteRequestNDRConvertCharRepArgUse(FILE *file, argument_t *arg)
929{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  WriteRequestNDRConvertArgUse(file, arg, "char_rep");
932}
933
934void
935WriteRequestNDRConvertFloatRepArgUse(FILE *file, argument_t *arg)
936{
if (akIdent(arg->argKind) != akeCount && akIdent(arg->argKind) != akeCountInOut)
  WriteRequestNDRConvertArgUse(file, arg, "float_rep");
939}
940
941static void
942WriteCalcArgSize(FILE *file, argument_t *arg)
943{
ipc_type_t *ptype = arg->argType;
945
if (PackMsg == FALSE) {
  fprintf(file, "%d", ptype->itTypeSize + ptype->itPadSize);
  return;
}
950
if (IS_OPTIONAL_NATIVE(ptype))
  fprintf(file, "(%s->__Present__%s ? _WALIGNSZ_(%s) : 0)" , arg->argInSegment, arg->argMsgField, ptype->itServerType);
else {
  ipc_type_t *btype = ptype->itElement;
  argument_t *count = arg->argCount;
  int multiplier = btype->itTypeSize;
957
  if (btype->itTypeSize % itWordAlign != 0)
    fprintf(file, "_WALIGN_");
  fprintf(file, "(");
961
  if (multiplier > 1)
    fprintf(file, "%d * ", multiplier);
  fprintf(file, "%s->%s", count->argInSegment, count->argMsgField);
  fprintf(file, ")");
}
967}
968
969static void
970WriteCheckArgSize(FILE *file, routine_t *rt, argument_t *arg, const char *comparator)
971{
ipc_type_t *ptype = arg->argType;
973
974
fprintf(file, "\tif (((msgh_size - ");
rtMinRequestSize(file, rt, "__Request");
fprintf(file, ") ");
if (PackMsg == FALSE) {
 fprintf(file, "%s %d)", comparator, ptype->itTypeSize + ptype->itPadSize);
} else if (IS_OPTIONAL_NATIVE(ptype)) {
 fprintf(file, "%s (%s->__Present__%s ? _WALIGNSZ_(%s) : 0))" , comparator, arg->argInSegment, arg->argMsgField, ptype->itServerType);
} else {
  ipc_type_t *btype = ptype->itElement;
  argument_t *count = arg->argCount;
  int multiplier = btype->itTypeSize;
986
  if (multiplier > 1)
    fprintf(file, "/ %d ", multiplier);
  fprintf(file, "< %s->%s) ||\n", count->argInSegment, count->argMsgField);
  fprintf(file, "\t    (msgh_size %s ", comparator);
  rtMinRequestSize(file, rt, "__Request");
  fprintf(file, " + ");
  WriteCalcArgSize(file, arg);
  fprintf(file, ")");
}
fprintf(file, ")\n\t\treturn MIG_BAD_ARGUMENTS;\n");
997}
998
999static void
1000WriteCheckMsgSize(FILE *file, argument_t *arg)
1001{
routine_t *rt = arg->argRoutine;
ipc_type_t *it = arg->argType;
ipc_type_t *btype = it->itElement;
1005
if (arg->argCount && !arg->argSameCount)
  WriteRequestNDRConvertIntRepOneArgUse(file, arg->argCount);
if (arg->argRequestPos == rt->rtMaxRequestPos)  {
  fprintf(file, "#if\t__MigTypeCheck\n");
1010
  /* verify that the user-code-provided count does not exceed the maximum count allowed by the type. */
  fprintf(file, "\t" "if (%s->%s > %d)\n", arg->argCount->argInSegment,
   arg->argCount->argMsgField, it->itNumber/btype->itNumber);
  fputs("\t\t" "return MIG_BAD_ARGUMENTS;\n", file);
  /* ...end... */
1016
  WriteCheckArgSize(file, rt, arg, "!=");
1018
  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. */
1025
  boolean_t LastVarArg = arg->argRequestPos+1 == rt->rtNumRequestVar;
1027
  /* 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). */
1033
  fprintf(file, "\tmsgh_size_delta = ");
  WriteCalcArgSize(file, arg);
  fprintf(file, ";\n");
  fprintf(file, "#if\t__MigTypeCheck\n");
1038
  /* verify that the user-code-provided count does not exceed the maximum count allowed by the type. */
  fprintf(file, "\t" "if (%s->%s > %d)\n", arg->argCount->argInSegment,
   arg->argCount->argMsgField, it->itNumber/btype->itNumber);
  fputs("\t\t" "return MIG_BAD_ARGUMENTS;\n", file);
  /* ...end... */
1044
  /* Don't decrement msgh_size until we've checked that
     it won't underflow. */
  WriteCheckArgSize(file, rt, arg, LastVarArg ? "!=" : "<");
1048
  if (!LastVarArg)
    fprintf(file, "\tmsgh_size -= msgh_size_delta;\n");
1051
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
fprintf(file, "\n");
1055}
1056
1057static char *
1058InArgMsgField(argument_t *arg,  char *str)
1059{
static char buffer[MAX_STR_LEN];
char who[20] = {0};
1062
/*
 * Inside the kernel, the request and reply port fields
 * really hold ipc_port_t values, not mach_port_t values.
 * Hence we must cast the values.
 */
1068
if (!(arg->argFlags & flRetCode)) {
  if (akCheck(arg->argKind, akbServerImplicit))
    sprintf(who, "TrailerP->");
  else
    sprintf(who, "%s->", arg->argInSegment);
}
1075
1076#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelServer &&
    ((akIdent(arg->argKind) == akeRequestPort) ||
     (akIdent(arg->argKind) == akeReplyPort)))
  sprintf(buffer, "(ipc_port_t) %s%s%s", who, str, (arg->argSuffix != strNULL) ? arg->argSuffix : arg->argMsgField);
else
1082#endif
  sprintf(buffer, "%s%s%s", who, str, (arg->argSuffix != strNULL) ? arg->argSuffix : arg->argMsgField);
1084
return buffer;
1086}
1087
1088static void
1089WriteExtractArgValue(FILE *file, argument_t *arg)
1090{
ipc_type_t *it = arg->argType;
string_t recast;
1093
1094#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelServer && it->itPortType && streql(it->itServerType, "ipc_port_t")
    && akIdent(arg->argKind) != akeRequestPort
    && akIdent(arg->argKind) != akeReplyPort)
  recast = "(mach_port_t)";
else
1100#endif
  recast = "";
if (it->itInTrans != strNULL)
  WriteCopyType(file, it, FALSE, "%s", "/* %s */ %s(%s%s)", arg->argVarName, it->itInTrans, recast, InArgMsgField(arg, ""));
else
  WriteCopyType(file, it, FALSE, "%s", "/* %s */ %s%s", arg->argVarName, recast, InArgMsgField(arg, ""));
1106
fprintf(file, "\n");
1108}
1109
1110/*
* argKPD_Extract discipline for Port types.
*/
1113static void
1114WriteExtractKPD_port(FILE *file, argument_t *arg)
1115{
ipc_type_t *it = arg->argType;
char *recast = "";
1118
WriteKPD_Iterator(file, TRUE, it->itVarArray, arg, FALSE);
/* translation function do not apply to complex types */
1121#ifdef MIG_KERNEL_PORT_CONVERSION
if (IsKernelServer)
  recast = "(mach_port_t)";
1124#endif
fprintf(file, "\t\t%s[i] = %sptr->name;\n", arg->argVarName, recast);
fprintf(file, "\t}\n");
1127}
1128
1129/*
* argKPD_Extract discipline for out-of-line types.
*/
1132static void
1133WriteExtractKPD_ool(FILE *file, argument_t *arg)
1134{
ipc_type_t *it = arg->argType;
1136
WriteKPD_Iterator(file, TRUE, it->itVarArray, arg, FALSE);
fprintf(file, "\t\t%s[i] = ptr->address;\n", arg->argVarName);
fprintf(file, "\t}\n");
1140}
1141
1142/*
* argKPD_Extract discipline for out-of-line Port types.
*/
1145static void
1146WriteExtractKPD_oolport(FILE *file, argument_t *arg)
1147{
ipc_type_t *it = arg->argType;
1149
WriteKPD_Iterator(file, TRUE, it->itVarArray, arg, FALSE);
fprintf(file, "\t\t%s[i] = ptr->address;\n", arg->argVarName);
fprintf(file, "\t}\n");
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbSendRcv)) {
  argument_t *poly = arg->argPoly;
  char *pref = poly->argByReferenceServer ? "*" : "";
1156
  fprintf(file, "\t%s%s = %s->%s[0].disposition;\n", pref, poly->argVarName, arg->argInSegment, arg->argMsgField);
}
1159}
1160
1161
1162static void
1163WriteInitializeCount(FILE *file, argument_t *arg)
1164{
ipc_type_t *ptype = arg->argParent->argType;
ipc_type_t *btype = ptype->itElement;
char newstr[MAX_STR_LEN];
1168
/*
 * Initialize 'count' argument for variable-length inline OUT parameter
 * with maximum allowed number of elements.
 */
1173
if (akCheck(arg->argKind, akbVarNeeded))
  sprintf(newstr, "%s", arg->argMsgField);
else
  sprintf(newstr, "%s->%s", arg->argOutSegment, arg->argMsgField);
1178
fprintf(file, "\t%s = ", newstr);
if (IS_MULTIPLE_KPD(ptype))
  fprintf(file, "%d;\n", ptype->itKPD_Number);
else
  fprintf(file, "%d;\n", btype->itNumber? ptype->itNumber/btype->itNumber : 0);
1184
/*
 * If the user passed in a count, then we use the minimum.
 * We can't let the user completely override our maximum,
 * or the user might convince the server to overwrite the buffer.
 */
1190
if (arg->argCInOut != argNULL) {
  char *msgfield = InArgMsgField(arg->argCInOut, "");
1193
  fprintf(file, "\tif (%s < %s)\n", msgfield, newstr);
  fprintf(file, "\t\t%s = %s;\n", newstr, msgfield);
}
1197
fprintf(file, "\n");
1199}
1200
1201static void
1202WriteAdjustRequestMsgPtr(FILE *file, argument_t *arg)
1203{
ipc_type_t *ptype = arg->argType;
char *where = UseMachMsg2 ? "UP" : "P";
char *castType = UseMachMsg2 ? "__RequestU" : "__Request";
1207
if (PackMsg == FALSE) {
  fprintf(file, "\t*In%d%sP = In%d%s = (%s *) ((pointer_t) %s);\n\n",
    arg->argRequestPos+1, where, arg->argRequestPos+1, where, castType, arg->argInSegment);
  return;
}
1213
fprintf(file, "\t*In%d%sP = In%d%s = (%s *) ((pointer_t) %s + msgh_size_delta - ",
  arg->argRequestPos+1, where, arg->argRequestPos+1, where, castType, arg->argInSegment);
if (IS_OPTIONAL_NATIVE(ptype))
  fprintf(file, "_WALIGNSZ_(%s)", ptype->itUserType);
else
  fprintf(file, "%d", ptype->itTypeSize + ptype->itPadSize);
fprintf(file, ");\n\n");
1221}
1222
1223static void
1224WriteCheckRequestTrailerArgs(FILE *file, routine_t *rt)
1225{
argument_t *arg;
1227
if (rt->rtServerImpl)
  WriteCheckTrailerHead(file, rt, FALSE);
1230
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  if (akCheck(arg->argKind, akbServerImplicit))
    WriteCheckTrailerSize(file, FALSE, arg);
}
1235}
1236
1237static void
1238WriteExtractArg(FILE *file, argument_t *arg)
1239{
if (akCheckAll(arg->argKind, akbSendRcv|akbVarNeeded)) {
  if (akCheck(arg->argKind, akbSendKPD))
    (*arg->argKPD_Extract)(file, arg);
  else
    WriteExtractArgValue(file, arg);
}
1246
if ((akIdent(arg->argKind) == akeCount) &&
    akCheck(arg->argKind, akbReturnSnd)) {
1249
  ipc_type_t *ptype = arg->argParent->argType;
  /*
   * the count will be initialized to 0 in the case of
   * unbounded arrays (MigInLine = TRUE): this is because
   * the old interface used to pass to the target procedure
   * the maximum in-line size (it was 2048 bytes)
   */
  if (IS_VARIABLE_SIZED_UNTYPED(ptype) ||
      IS_MIG_INLINE_EMUL(ptype) ||
      (IS_MULTIPLE_KPD(ptype) && ptype->itVarArray))
    WriteInitializeCount(file, arg);
}
1262}
1263
1264static void
1265WriteServerCallArg(FILE *file, argument_t *arg)
1266{
ipc_type_t *it = arg->argType;
boolean_t NeedClose = FALSE;
u_int elemsize = 0;
string_t  at = (arg->argByReferenceServer ||
                it->itNativePointer) ? "&" : "";
string_t  star = (arg->argByReferenceServer) ? " *" : "";
string_t  msgfield =
(arg->argSuffix != strNULL) ? arg->argSuffix : arg->argMsgField;
1275
if ((it->itInTrans != strNULL) &&
    akCheck(arg->argKind, akbSendRcv) &&
    !akCheck(arg->argKind, akbVarNeeded)) {
  fprintf(file, "%s%s(", at, it->itInTrans);
  NeedClose = TRUE;
}
1282
if (akCheckAll(arg->argKind, akbVarNeeded|akbServerArg))
  fprintf(file, "%s%s", at, arg->argVarName);
else if (akCheckAll(arg->argKind, akbSendRcv|akbSendKPD)) {
  if (!it->itInLine)
    /* recast the void *, although it is not necessary */
    fprintf(file, "(%s%s)%s(%s)", it->itTransType, star, at, InArgMsgField(arg, ""));
  else
1290#ifdef MIG_KERNEL_PORT_CONVERSION
    if (IsKernelServer && streql(it->itServerType, "ipc_port_t"))
      /* recast the port to the kernel internal form value */
      fprintf(file, "(ipc_port_t%s)%s(%s)", star, at, InArgMsgField(arg, ""));
    else
1295#endif
      fprintf(file, "%s%s", at, InArgMsgField(arg, ""));
}
else if (akCheck(arg->argKind, akbSendRcv)) {
  if (IS_OPTIONAL_NATIVE(it)) {
    fprintf(file, "(%s ? ", InArgMsgField(arg, "__Present__"));
    fprintf(file, "%s%s.__Real__%s : %s)", at, InArgMsgField(arg, ""), arg->argMsgField, it->itBadValue);
  }
  else {
    if (akIdent(arg->argKind) == akeCount && arg->argParent) {
        char *suffix = arg->argParent->argSuffix;
        ipc_type_t *elemType = arg->argParent->argType->itElement;
        /* temporarily squash any name suffix such as ".address" (we'll be adding our own) */
        arg->argParent->argSuffix = NULL;
        switch (arg->argParent->argKPD_Type) {
        case MACH_MSG_OOL_PORTS_DESCRIPTOR:
          /* count of the number of descriptors */
          fprintf(file, "%s%s.count", at, InArgMsgField(arg->argParent, ""));
          break;
        case MACH_MSG_OOL_DESCRIPTOR:
          /* descriptor buffer size / element size */
          if (!(arg->argByReferenceServer || it->itNativePointer)) {
            fprintf(file, "%s%s.size", at, InArgMsgField(arg->argParent, ""));
            elemsize = ((elemType->itNumber * elemType->itSize) + 7) / 8;
            if (elemsize > 1) {
              fprintf(file, " / %d", elemsize);
            }
          } else {
            fprintf(file, "%s%s", at, InArgMsgField(arg, ""));
          }
          break;
        default:
          fprintf(file, "%s%s", at, InArgMsgField(arg, ""));
          break;
        }
        arg->argParent->argSuffix = suffix;
    } else {
      fprintf(file, "%s%s", at, InArgMsgField(arg, ""));
    }
  }
}
else if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnKPD)) {
  if (!it->itInLine)
    /* recast the void *, although it is not necessary */
    fprintf(file, "(%s%s)%s(%s->%s)", it->itTransType, star, at, arg->argOutSegment, msgfield);
  else
1341#ifdef MIG_KERNEL_PORT_CONVERSION
    if (IsKernelServer && streql(it->itServerType, "ipc_port_t"))
    /* recast the port to the kernel internal form value */
      fprintf(file, "(mach_port_t%s)%s(%s->%s)", star, at, arg->argOutSegment, msgfield);
    else
1346#endif
      fprintf(file, "%s%s->%s", at, arg->argOutSegment, msgfield);
1348
}
else  if (akCheck(arg->argKind, akbReturnSnd))
  fprintf(file, "%s%s->%s", at, arg->argOutSegment, msgfield);
1352
if (NeedClose)
  fprintf(file, ")");
1355}
1356
1357/*
* Shrunk version of WriteServerCallArg, to implement the RetCode functionality:
* we have received a mig_reply_error_t, therefore we want to call the target
* routine with all 0s except for the error code (and the implicit data).
* We know that we are a SimpleRoutine.
*/
1363static void
1364WriteConditionalCallArg(FILE *file, argument_t *arg)
1365{
ipc_type_t *it = arg->argType;
boolean_t NeedClose = FALSE;
1368
if ((it->itInTrans != strNULL) &&
    akCheck(arg->argKind, akbSendRcv) &&
    !akCheck(arg->argKind, akbVarNeeded)) {
  fprintf(file, "%s(", it->itInTrans);
  NeedClose = TRUE;
}
1375
if (akCheck(arg->argKind, akbSendRcv)) {
  if (akIdent(arg->argKind) == akeRequestPort ||
      akCheck(arg->argKind, akbServerImplicit))
    fprintf(file, "%s", InArgMsgField(arg, ""));
  else if (akIdent(arg->argKind) == akeRetCode) {
    assert(arg->argRequestPos == 0);
    fprintf(file, "((mig_reply_error_t *)%s)->RetCode", arg->argInSegment);
  } else
    fprintf(file, "(%s)(0)", it->itTransType);
}
1386
if (NeedClose)
  fprintf(file, ")");
1389}
1390
1391static void
1392WriteDestroyArg(FILE *file, argument_t *arg)
1393{
ipc_type_t *it = arg->argType;
1395
/*
 * Deallocate IN/INOUT out-of-line args if specified by "auto" flag.
 *
 * We also have to deallocate in the cases where the target routine
 * is given a itInLine semantic whereas the underlying transmission
 * was out-of-line
 */
if ((argIsIn(arg) && akCheck(arg->argKind, akbSendKPD|akbReturnKPD) &&
     arg->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR &&
     (arg->argFlags & flAuto))
    ||
    IS_MIG_INLINE_EMUL(it)
    ) {
  /*
   * Deallocate only if out-of-line.
   */
  argument_t *count = arg->argCount;
  ipc_type_t *btype = it->itElement;
  int multiplier = btype->itNumber ? btype->itSize / (8 * btype->itNumber) : 0;
1415
  if (IsKernelServer) {
    fprintf(file, "#if __MigKernelSpecificCode\n");
    fprintf(file, "\tvm_map_copy_discard(%s);\n", InArgMsgField(arg, ""));
    fprintf(file, "#else\n");
  }
  fprintf(file, "\tmig_deallocate((vm_offset_t) %s, ", InArgMsgField(arg, ""));
  if (it->itVarArray) {
    char *suffix = arg->argSuffix;
    /*
     * temporarily squash any name suffix such as ".address"
     * (we'll be adding our own)
     */
    arg->argSuffix = NULL;
    switch (arg->argKPD_Type) {
    case MACH_MSG_OOL_PORTS_DESCRIPTOR:
      if (multiplier > 1) {
        fprintf(file, "%d * ", multiplier);
      }
      fprintf(file, "%s.count);\n", InArgMsgField(arg, ""));
      break;
    case MACH_MSG_OOL_DESCRIPTOR:
      fprintf(file, "%s.size);\n", InArgMsgField(arg, ""));
      break;
    default:
      if (multiplier > 1) {
        fprintf(file, "%d * ", multiplier);
      }
      fprintf(file, "%s);\n", InArgMsgField(count, ""));
      break;
    }
    arg->argSuffix = suffix;
  }
  else
    fprintf(file, "%d);\n", (it->itNumber * it->itSize + 7) / 8);
  if (IsKernelServer) {
    fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
  }
  fprintf(file, "\t%s = (void *) 0;\n", InArgMsgField(arg, ""));
  fprintf(file, "\t%s->%s.%s = (mach_msg_size_t) 0;\n", arg->argInSegment,
    arg->argMsgField, (RPCPortArray(arg) ? "count" : "size"));
}
else {
  if (akCheck(arg->argKind, akbVarNeeded))
    fprintf(file, "\t%s(%s);\n", it->itDestructor, arg->argVarName);
  else
    fprintf(file, "\t%s(%s);\n", it->itDestructor, InArgMsgField(arg, ""));
}
1463}
1464
1465static void
1466WriteDestroyPortArg(FILE *file, argument_t *arg)
1467{
ipc_type_t *it = arg->argType;
1469
/*
 * If a translated port argument occurs in the body of a request
 * message, and the message is successfully processed, then the
 * port right should be deallocated.  However, the called function
 * didn't see the port right; it saw the translation.  So we have
 * to release the port right for it.
 *
 *  The test over it->itInTrans will exclude any complex type
 *  made out of ports
 */
if ((it->itInTrans != strNULL) &&
    (it->itOutName == MACH_MSG_TYPE_PORT_SEND)) {
  fprintf(file, "\tipc_port_release_send((ipc_port_t)%s);\n", InArgMsgField(arg, ""));
}
1484}
1485
1486/*
* Check whether WriteDestroyPortArg would generate any code for arg.
*/
1489boolean_t
1490CheckDestroyPortArg(argument_t *arg)
1491{
ipc_type_t *it = arg->argType;
1493
if ((it->itInTrans != strNULL) &&
    (it->itOutName == MACH_MSG_TYPE_PORT_SEND))  {
  return TRUE;
}
return FALSE;
1499}
1500
1501static void
1502WriteServerCall(FILE *file, routine_t *rt,  void (*func)(FILE *, argument_t *))
1503{
argument_t *arg = rt->rtRetCode;
ipc_type_t *it = arg->argType;
boolean_t NeedClose = FALSE;
1507
fprintf(file, "\t");
if (akCheck(arg->argKind, akbVarNeeded))
  fprintf(file, "%s = ", arg->argMsgField);
else
  fprintf(file, "%s->%s = ", arg->argOutSegment, arg->argMsgField);
if (it->itOutTrans != strNULL) {
  fprintf(file, "%s(", it->itOutTrans);
  NeedClose = TRUE;
}
fprintf(file, "%s(", rt->rtServerName);
WriteList(file, rt->rtArgs, func, akbServerArg, ", ", "");
if (NeedClose)
  fprintf(file, ")");
fprintf(file, ");\n");
1522}
1523
1524static void
1525WriteCheckReturnValue(FILE *file, routine_t *rt)
1526{
argument_t *arg = rt->rtRetCode;
char string[MAX_STR_LEN];
1529
if (akCheck(arg->argKind, akbVarNeeded))
  sprintf(string, "%s", arg->argMsgField);
else
  sprintf(string, "%s->%s", arg->argOutSegment, arg->argMsgField);
fprintf(file, "\tif (%s != KERN_SUCCESS) {\n", string);
fprintf(file, "\t\tMIG_RETURN_ERROR(%s, %s);\n", OutHeadSeg, string);
fprintf(file, "\t}\n");
1537}
1538
1539/*
* WriteInitKPD_port, WriteInitKPD_ool, WriteInitKPD_oolport
* initializes the OutP KPD fields (this job cannot be done once
* the target routine has been called, otherwise informations
* would be lost)
*/
1545/*
* argKPD_Init discipline for Port types.
*/
1548static void
1549WriteInitKPD_port(FILE *file, argument_t *arg)
1550{
ipc_type_t *it = arg->argType;
char *subindex = "";
boolean_t close = FALSE;
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
1556
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  subindex = "[i]";
  close = TRUE;
}
else {
  (void)sprintf(firststring, "%s->%s", arg->argOutSegment, arg->argMsgField);
  (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
}
1568
fprintf(file, "#if\tUseStaticTemplates\n");
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
fprintf(file, "#else\t/* UseStaticTemplates */\n");
if (IS_MULTIPLE_KPD(it) && it->itVarArray)
  fprintf(file, "\t%sname = MACH_PORT_NULL;\n", string);
if (arg->argPoly == argNULL) {
  if (IsKernelServer) {
    fprintf(file, "#if __MigKernelSpecificCode\n");
    fprintf(file, "\t%sdisposition = %s;\n", string, it->itOutNameStr);
    fprintf(file, "#else\n");
  }
  fprintf(file, "\t%sdisposition = %s;\n", string, it->itInNameStr);
  if (IsKernelServer)
    fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
}
fprintf(file, "#if !(defined(KERNEL) && defined(__LP64__))\n");
fprintf(file, "\t%spad1 = 0;\n", string);
fprintf(file, "#endif\n");
fprintf(file, "\t%spad2 = 0;\n", string);
fprintf(file, "\t%stype = MACH_MSG_PORT_DESCRIPTOR;\n", string);
fprintf(file, "#if defined(KERNEL)\n");
fprintf(file, "\t%spad_end = 0;\n", string);
fprintf(file, "#endif\n");
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
if (close)
  fprintf(file, "\t    }\n\t}\n");
fprintf(file, "\n");
1596}
1597
1598/*
* argKPD_Init discipline for out-of-line types.
*/
1601static void
1602WriteInitKPD_ool(FILE *file, argument_t *arg)
1603{
ipc_type_t *it = arg->argType;
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
boolean_t VarArray;
u_int howmany, howbig;
1609
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  howmany = it->itElement->itNumber;
  howbig = it->itElement->itSize;
}
else {
  (void)sprintf(firststring, "%s->%s", arg->argOutSegment, arg->argMsgField);
  (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
  VarArray = it->itVarArray;
  howmany = it->itNumber;
  howbig = it->itSize;
}
1625
fprintf(file, "#if\tUseStaticTemplates\n");
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
fprintf(file, "#else\t/* UseStaticTemplates */\n");
if (!VarArray)
  fprintf(file, "\t%ssize = %d;\n", string, (howmany * howbig + 7)/8);
if (arg->argDeallocate != d_MAYBE)
  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");
1634#ifdef ALIGNMENT
fprintf(file, "\t%salignment = MACH_MSG_ALIGN_%d;\n", string, arg->argMsgField, (howbig < 8) ? 1 : howbig / 8);
1636#endif
fprintf(file, "\t%spad1 = 0;\n", string);
fprintf(file, "\t%stype = MACH_MSG_OOL_DESCRIPTOR;\n", string);
fprintf(file, "#if defined(KERNEL) && !defined(__LP64__)\n");
fprintf(file, "\t%spad_end = 0;\n", string);
fprintf(file, "#endif\n");
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
1643
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
fprintf(file, "\n");
1647}
1648
1649/*
* argKPD_Init discipline for out-of-line Port types.
*/
1652static void
1653WriteInitKPD_oolport(FILE *file, argument_t *arg)
1654{
ipc_type_t *it = arg->argType;
boolean_t VarArray;
ipc_type_t *howit;
u_int howmany;
char firststring[MAX_STR_LEN];
char string[MAX_STR_LEN];
1661
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, FALSE, arg, TRUE);
  (void)sprintf(firststring, "\t*ptr");
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  howmany = it->itElement->itNumber;
  howit = it->itElement;
}
else {
  (void)sprintf(firststring, "%s->%s", arg->argOutSegment, arg->argMsgField);
  (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
  VarArray = it->itVarArray;
  howmany = it->itNumber;
  howit = it;
}
1677
fprintf(file, "#if\tUseStaticTemplates\n");
fprintf(file, "\t%s = %s;\n", firststring, arg->argTTName);
fprintf(file, "#else\t/* UseStaticTemplates */\n");
1681
if (!VarArray)
  fprintf(file, "\t%scount = %d;\n", string, howmany);
if (arg->argPoly == argNULL) {
  if (IsKernelServer) {
    fprintf(file, "#if\t__MigKernelSpecificCode\n");
    fprintf(file, "\t%sdisposition = %s;\n", string, howit->itOutNameStr);
    fprintf(file, "#else\n");
  }
  fprintf(file, "\t%sdisposition = %s;\n", string, howit->itInNameStr);
  if (IsKernelServer)
    fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
}
if (arg->argDeallocate != d_MAYBE)
  fprintf(file, "\t%sdeallocate =  %s;\n", string, (arg->argDeallocate == d_YES) ? "TRUE" : "FALSE");
fprintf(file, "\t%stype = MACH_MSG_OOL_PORTS_DESCRIPTOR;\n", string);
fprintf(file, "#endif\t/* UseStaticTemplates */\n");
1698
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
fprintf(file, "\n");
1702}
1703
1704static void
1705WriteInitKPDValue(FILE *file, argument_t *arg)
1706{
(*arg->argKPD_Init)(file, arg);
1708}
1709
1710static void
1711WriteAdjustMsgCircular(FILE *file, argument_t *arg)
1712{
fprintf(file, "\n");
1714
fprintf(file,"#if\t__MigKernelSpecificCode\n");
if (arg->argType->itOutName == MACH_MSG_TYPE_POLYMORPHIC)
  fprintf(file, "\tif (%s == MACH_MSG_TYPE_PORT_RECEIVE)\n", arg->argPoly->argVarName);
1718
/*
 * The carried port right can be accessed in OutP->XXXX.  Normally
 * the server function stuffs it directly there.  If it is InOut,
 * then it has already been copied into the reply message.
 * If the server function deposited it into a variable (perhaps
 * because the reply message is variable-sized) then it has already
 * been copied into the reply message.
 *
 *  The old MiG does not check for circularity in the case of
 *  array of ports. So do I ...
 */
1730
fprintf(file, "\t  if (IP_VALID((ipc_port_t) %s->Head.msgh_reply_port) &&\n", InHeadSeg);
fprintf(file, "\t    IP_VALID((ipc_port_t) %s->%s.name) &&\n", arg->argOutSegment, arg->argMsgField);
fprintf(file, "\t    ipc_port_check_circularity((ipc_port_t) %s->%s.name, (ipc_port_t) %s->Head.msgh_reply_port))\n",
  arg->argOutSegment, arg->argMsgField, InHeadSeg);
fprintf(file, "\t\t%s->Head.msgh_bits |= MACH_MSGH_BITS_CIRCULAR;\n", OutHeadSeg);
fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
1737}
1738
1739/*
* argKPD_Pack discipline for Port types.
*/
1742static void
1743WriteKPD_port(FILE *file, argument_t *arg)
1744{
ipc_type_t *it = arg->argType;
char *subindex = "";
char *recast = "";
boolean_t close = FALSE;
char string[MAX_STR_LEN];
ipc_type_t *real_it;
1751
if (akCheck(arg->argKind, akbVarNeeded)) {
  if (IS_MULTIPLE_KPD(it)) {
    WriteKPD_Iterator(file, FALSE, it->itVarArray, arg, TRUE);
    (void)sprintf(string, "\tptr->");
    subindex = "[i]";
    close = TRUE;
    real_it = it->itElement;
  }
  else {
    (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
    real_it = it;
  }
1764#ifdef MIG_KERNEL_PORT_CONVERSIONS
  if (IsKernelServer && streql(real_it->itTransType, "ipc_port_t"))
    recast = "(mach_port_t)";
1767#endif
1768
  if (it->itOutTrans != strNULL && !close)
    fprintf(file, "\t%sname = (mach_port_t)%s(%s);\n", string, it->itOutTrans, arg->argVarName);
  else
    fprintf(file, "\t%sname = %s%s%s;\n", string, recast, arg->argVarName, subindex);
  if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbReturnSnd)) {
    argument_t *poly = arg->argPoly;
1775
    if  (akCheck(arg->argPoly->argKind, akbVarNeeded))
      fprintf(file, "\t%sdisposition = %s;\n", string, poly->argVarName);
    else if (close)
      fprintf(file, "\t%sdisposition = %s->%s;\n", string, poly->argOutSegment, poly->argSuffix);
  }
  if (close)
    fprintf(file, "\t    }\n\t}\n");
  fprintf(file, "\n");
}
else  if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbReturnSnd|akbVarNeeded))
  fprintf(file, "\t%s->%s.disposition = %s;\n", arg->argOutSegment, arg->argMsgField, arg->argPoly->argVarName);
/*
 * If this is a KernelServer, and the reply message contains
 * a receive right, we must check for the possibility of a
 * port/message circularity.  If queueing the reply message
 * would cause a circularity, we mark the reply message
 * with the circular bit.
 */
if (IsKernelServer && !(IS_MULTIPLE_KPD(it)) &&
    ((arg->argType->itOutName == MACH_MSG_TYPE_PORT_RECEIVE) ||
     (arg->argType->itOutName == MACH_MSG_TYPE_POLYMORPHIC)))
  WriteAdjustMsgCircular(file, arg);
1798}
1799
1800/*
* argKPD_Pack discipline for out-of-line types.
*/
1803static void
1804WriteKPD_ool(FILE *file, argument_t *arg)
1805{
ipc_type_t *it = arg->argType;
char string[MAX_STR_LEN];
boolean_t VarArray;
argument_t *count;
u_int howbig;
char *subindex;
1812
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, it->itVarArray, arg, TRUE);
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  count = arg->argSubCount;
  howbig = it->itElement->itSize;
  subindex = "[i]";
}
else {
  (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
  VarArray = it->itVarArray;
  count = arg->argCount;
  howbig = it->itSize;
  subindex = "";
}
1828
if (akCheck(arg->argKind, akbVarNeeded))
  fprintf(file, "\t%saddress = (void *)%s%s;\n", string, arg->argMsgField, subindex);
if (arg->argDealloc != argNULL)
  if (akCheck(arg->argDealloc->argKind, akbVarNeeded) || IS_MULTIPLE_KPD(it))
    fprintf(file, "\t%sdeallocate = %s;\n", string, arg->argDealloc->argVarName);
if (VarArray) {
  fprintf(file, "\t%ssize = ", string);
  if (akCheck(count->argKind, akbVarNeeded))
    fprintf(file, "%s%s", count->argName, subindex);
  else if (akCheck(arg->argKind, akbReplyCopy))
    /* Fixed an ancient bug here, first %s should be the position of count, not arg */
    fprintf(file, "%s->%s%s", count->argInSegment, count->argMsgField, subindex);
  else
    fprintf(file, "%s->%s%s", count->argOutSegment, count->argMsgField, subindex);
1843
  if (count->argMultiplier > 1 || howbig > 8)
    fprintf(file, " * %d;\n", count->argMultiplier * howbig / 8);
  else
    fprintf(file, ";\n");
}
1849
if (IS_MULTIPLE_KPD(it)) {
  fprintf(file, "\t    }\n");
  if (it->itVarArray && !it->itElement->itVarArray) {
    fprintf(file, "\t    for (i = j; i < %d; ptr++, i++)\n", it->itKPD_Number);
    /* since subordinate arrays aren't variable, they are initialized from template:
     here we must no-op 'em */
    fprintf(file, "\t\tptr->size = 0;\n");
  }
  fprintf(file, "\t}\n");
}
fprintf(file, "\n");
1861}
1862
1863/*
* argKPD_Pack discipline for out-of-line Port types.
*/
1866static void
1867WriteKPD_oolport(FILE *file, argument_t *arg)
1868{
ipc_type_t *it = arg->argType;
boolean_t VarArray;
argument_t *count;
char *subindex, string[MAX_STR_LEN];
1873
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, FALSE, it->itVarArray, arg, TRUE);
  (void)sprintf(string, "\tptr->");
  VarArray = it->itElement->itVarArray;
  count = arg->argSubCount;
  subindex = "[i]";
}
else {
  (void)sprintf(string, "%s->%s.", arg->argOutSegment, arg->argMsgField);
  VarArray = it->itVarArray;
  count = arg->argCount;
  subindex = "";
}
1887
if (akCheck(arg->argKind, akbVarNeeded))
  fprintf(file, "\t%saddress = (void *)%s%s;\n", string, arg->argMsgField, subindex);
if (arg->argDealloc != argNULL)
  if (akCheck(arg->argDealloc->argKind, akbVarNeeded) || IS_MULTIPLE_KPD(it))
    fprintf(file, "\t%sdeallocate = %s;\n", string, arg->argDealloc->argVarName);
if (VarArray) {
  fprintf(file, "\t%scount = ", string);
  if (akCheck(count->argKind, akbVarNeeded))
    fprintf(file, "%s%s;\n", count->argName, subindex);
  else if (akCheck(arg->argKind, akbReplyCopy))
    /* Fixed an ancient bug here, first %s should be the position of count, not arg */
    fprintf(file, "%s->%s%s;\n", count->argInSegment, count->argMsgField, subindex);
  else
    fprintf(file, "%s->%s%s;\n", count->argOutSegment, count->argMsgField, subindex);
}
if (arg->argPoly != argNULL && akCheckAll(arg->argPoly->argKind, akbReturnSnd))
  if (akCheck(arg->argPoly->argKind, akbVarNeeded) || IS_MULTIPLE_KPD(it))
    fprintf(file, "\t%sdisposition = %s;\n", string, arg->argPoly->argVarName);
if (IS_MULTIPLE_KPD(it)) {
  fprintf(file, "\t    }\n");
  if (it->itVarArray && !it->itElement->itVarArray) {
    fprintf(file, "\t    for (i = j; i < %d; ptr++, i++)\n", it->itKPD_Number);
    /* since subordinate arrays aren't variable, they are initialized from template:
     here we must no-op 'em */
    fprintf(file, "\t%scount = 0;\n", string);
  }
  fprintf(file, "\t}\n");
}
fprintf(file, "\n");
1917}
1918
1919/*
* argKPD_TypeCheck discipline for Port types.
*/
1922static void
1923WriteTCheckKPD_port(FILE *file, argument_t *arg)
1924{
ipc_type_t *it = arg->argType;
char *tab = "";
char string[MAX_STR_LEN];
boolean_t close = FALSE;
1929
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, FALSE, arg, TRUE);
  (void)sprintf(string, "ptr->");
  tab = "\t";
  close = TRUE;
}
else
  (void)sprintf(string, "%s->%s.", arg->argInSegment, arg->argMsgField);
1938
fprintf(file, "\t%sif (%stype != MACH_MSG_PORT_DESCRIPTOR", tab, string);
/*
 * We can't check disposition on varArray
 * (because some of the entries could be empty).
 */
if (!it->itVarArray) {
  if (arg->argPoly != argNULL) {
    switch (it->itOutName) {
1947
      case MACH_MSG_TYPE_MOVE_RECEIVE:
        fprintf(file, " || \n\t%s    %sdisposition != MACH_MSG_TYPE_MOVE_RECEIVE", tab, string);
        break;
1951
      case MACH_MSG_TYPE_MOVE_SEND_ONCE:
        fprintf(file, " || (\n\t%s    %sdisposition != MACH_MSG_TYPE_MOVE_SEND_ONCE", tab, string);
        fprintf(file, " &&  \n\t%s    %sdisposition != MACH_MSG_TYPE_MAKE_SEND_ONCE)", tab, string);
        break;
1956
      case MACH_MSG_TYPE_MOVE_SEND:
        fprintf(file, " || (\n\t%s    %sdisposition != MACH_MSG_TYPE_MOVE_SEND", tab, string);
        fprintf(file, " &&  \n\t%s    %sdisposition != MACH_MSG_TYPE_MAKE_SEND", tab, string);
        fprintf(file, " &&  \n\t%s    %sdisposition != MACH_MSG_TYPE_COPY_SEND)", tab, string);
        break;
    }
  }
  else {
    fprintf(file, " ||\n\t%s    %sdisposition != %s", tab, string, it->itOutNameStr);
  }
}
fprintf(file, ")\n");
fprintf(file, "\t\treturn MIG_TYPE_ERROR;\n");
if (close)
  fprintf(file, "\t    }\n\t}\n");
1972}
1973
1974/*
* argKPD_TypeCheck discipline for out-of-line types.
*/
1977static void
1978WriteTCheckKPD_ool(FILE *file, argument_t *arg)
1979{
ipc_type_t *it = arg->argType;
char *tab, string[MAX_STR_LEN];
boolean_t test;
u_int howmany, howbig;
1984
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, FALSE, arg, TRUE);
  tab = "\t\t\t";
  sprintf(string, "ptr->");
  howmany = it->itElement->itNumber;
  howbig = it->itElement->itSize;
  test = !it->itVarArray && !it->itElement->itVarArray;
}
else {
  tab = "";
  sprintf(string, "%s->%s.", arg->argInSegment, arg->argMsgField);
  howmany = it->itNumber;
  howbig = it->itSize;
  test = !it->itVarArray;
}
2000
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);
}
2006
fprintf(file, ")\n");
fprintf(file, "\t\t%s" "return MIG_TYPE_ERROR;\n", tab);
2009
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
2012}
2013
2014/*
* argKPD_TypeCheck discipline for out-of-line Port types.
*/
2017static void
2018WriteTCheckKPD_oolport(FILE *file, argument_t *arg)
2019{
ipc_type_t *it = arg->argType;
char *tab, string[MAX_STR_LEN];
boolean_t test;
u_int howmany;
char *howstr;
2025
if (IS_MULTIPLE_KPD(it)) {
  WriteKPD_Iterator(file, TRUE, 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, "%s->%s.", arg->argInSegment, arg->argMsgField);
  howmany = it->itNumber;
  test = !it->itVarArray;
  howstr = it->itOutNameStr;
}
2041
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");
fprintf(file, "\t\treturn MIG_TYPE_ERROR;\n");
2050
if (IS_MULTIPLE_KPD(it))
  fprintf(file, "\t    }\n\t}\n");
2053}
2054
2055/*************************************************************
*  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 in && typed argument in the request message.
*************************************************************/
2060static void
2061WriteTypeCheck(FILE *file, argument_t *arg)
2062{
fprintf(file, "#if\t__MigTypeCheck\n");
(*arg->argKPD_TypeCheck)(file, arg);
fprintf(file, "#endif\t/* __MigTypeCheck */\n");
2066}
2067
2068static void
2069WritePackArgValueNormal(FILE *file, argument_t *arg)
2070{
ipc_type_t *it = arg->argType;
2072
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\t%s->%s = (%s) mig_strncpy_zerofill(%s->%s, %s, %d);\n",
      arg->argCount->argOutSegment, arg->argCount->argMsgField, arg->argCount->argType->itTransType,
      arg->argOutSegment, arg->argMsgField, arg->argVarName, it->itNumber);
    fprintf(file, "\t} else {\n");
    fprintf(file, "#endif /* USING_MIG_STRNCPY_ZEROFILL */\n");
2087
    fprintf(file, "\t\t%s->%s = (%s) mig_strncpy(%s->%s, %s, %d);\n",
      arg->argCount->argOutSegment, arg->argCount->argMsgField, arg->argCount->argType->itTransType,
      arg->argOutSegment, arg->argMsgField, arg->argVarName, it->itNumber);
2091
    fprintf(file, "#ifdef USING_MIG_STRNCPY_ZEROFILL\n");
    fprintf(file, "\t}\n");
    fprintf(file, "#endif /* USING_MIG_STRNCPY_ZEROFILL */\n");
2095
    fprintf(file, "\t%s->%sOffset = 0;\n", arg->argOutSegment, arg->argMsgField);
  }
  else if (it->itNoOptArray)
    fprintf(file, "\t(void)memcpy((char *) %s->%s, (const char *) %s, %d);\n",
      arg->argOutSegment, arg->argMsgField, arg->argVarName, it->itTypeSize);
  else {
    argument_t *count = arg->argCount;
    ipc_type_t *btype = it->itElement;
    identifier_t newstr;
    char tmpstr[MAX_STR_LEN];
2106
    /* Note btype->itNumber == count->argMultiplier */
2108
    fprintf(file, "\t(void)memcpy((char *) %s->%s, (const char *) %s, ",
      arg->argOutSegment, arg->argMsgField, arg->argVarName);
    if (btype->itTypeSize > 1)
      fprintf(file, "%d * ", btype->itTypeSize);
    /* count is a akbVarNeeded if arg is akbVarNeeded */
    if (akCheck(count->argKind, akbVarNeeded)) {
      newstr = count->argVarName;
    } else {
      sprintf("%s->%s", count->argOutSegment, count->argMsgField);
      newstr = tmpstr;
    }
    fprintf(file, "%s);\n", newstr);
  }
}
else if (it->itOutTrans != strNULL)
  WriteCopyType(file, it, TRUE, "%s->%s",
    "/* %s %s */ %s(%s)", arg->argOutSegment, arg->argMsgField,
    it->itOutTrans, arg->argVarName);
else
  WriteCopyType(file, it, TRUE, "%s->%s",
    "/* %s %s */ %s", arg->argOutSegment, arg->argMsgField,
    arg->argVarName);
2131
if (arg->argPadName != NULL && it->itPadSize != 0) {
  fprintf(file, "\t    for (int i = 0; i < %d; i++)\n", it->itPadSize);
  fprintf(file, "\t\t    %s->%s[i] = 0;\n", arg->argOutSegment, arg->argPadName);
}
2136}
2137
2138static void
2139WritePackArgValueVariable(FILE *file, argument_t *arg)
2140{
ipc_type_t *it = arg->argType;
2142
/*
 * only itString are treated here so far
 */
if (it->itString) {
  /*
   * Emit logic to call strlen to calculate the size of the argument, and ensure that it fits within the 32-bit result field
   * in the Reply, when targeting a 64-bit architecture. If a 32-bit architecture is the target, we emit code to just call
   * strlen() directly (since it'll return a 32-bit value that is guaranteed to fit).
   */
  fputs("#ifdef __LP64__\n", file);
  fprintf(file, "\t{\n"
                "\t\t" "size_t strLength = strlen(%s->%s) + 1;\n", arg->argOutSegment, arg->argMsgField);
  fprintf(file,        "\t\t" "if (strLength > 0xffffffff)\n"
                "\t\t\t"  "MIG_RETURN_ERROR(%s, MIG_BAD_ARGUMENTS);\n", OutHeadSeg);
  fprintf(file, "\t\t" "%s->%s = (mach_msg_type_number_t) strLength;\n"
                "\t}\n", arg->argCount->argOutSegment, arg->argCount->argMsgField);
  fputs("#else\n", file);
  fprintf(file, "\t%s->%s = (mach_msg_type_number_t) strlen(%s->%s) + 1;\n",
    arg->argCount->argOutSegment, arg->argCount->argMsgField, arg->argOutSegment, arg->argMsgField);
  fputs("#endif /* __LP64__ */\n", file);
  fprintf(file, "\t%s->%sOffset = 0;\n", arg->argCount->argOutSegment, arg->argMsgField);
}
2165}
2166
2167static void
2168WriteCopyArgValue(FILE *file, argument_t *arg)
2169{
fprintf(file, "\n");
char *field =  (arg->argSuffix != strNULL) ? arg->argSuffix : arg->argMsgField;
WriteCopyType(file, arg->argType, TRUE, "%s->%s",
  "/* %s %s */ %s->%s",arg->argOutSegment, field, arg->argInSegment, field);
2174}
2175
2176static void
2177WriteInitArgValue(FILE *file, argument_t *arg)
2178{
fprintf(file, "\n");
fprintf(file, "\t%s->%s = %s;\n\n", arg->argOutSegment, arg->argMsgField, arg->argVarName);
2181}
2182
2183/*
* Calculate the size of a variable-length message field.
*/
2186static void
2187WriteArgSize(FILE *file, argument_t *arg)
2188{
ipc_type_t *ptype = arg->argType;
int bsize = ptype->itElement->itTypeSize;
argument_t *count = arg->argCount;
2192
/* 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_");
2197
/* Here, we generate ((value + %d) & ~%d). We have to put two (( at the
 * the beginning.
 */
fprintf(file, "((");
if (bsize > 1)
  fprintf(file, "%d * ", bsize);
if (ptype->itString || !akCheck(count->argKind, akbVarNeeded))
  /* get count from descriptor in message */
  fprintf(file, "%s->%s", count->argOutSegment, count->argMsgField);
else
  /* get count from argument */
  fprintf(file, "%s", count->argVarName);
2210
/*
 * If the base type size is not a multiple of sizeof(natural_t),
 * we have to round up.
 */
if (bsize % sizeof(natural_t) != 0)
  fprintf(file, " + %d) & ~%d)", (int)sizeof(natural_t)-1, (int)sizeof(natural_t)-1);
else
  fprintf(file, "))");
2219}
2220
2221/*
* Adjust message size and advance reply pointer.
* Called after packing a variable-length argument that
* has more arguments following.
*/
2226static void
2227WriteAdjustMsgSize(FILE *file, argument_t *arg)
2228{
routine_t *rt = arg->argRoutine;
ipc_type_t *ptype = arg->argType;
2231
/* There are more Out arguments.  We need to adjust msgh_size
   and advance OutP, so we save the size of the current field
   in msgh_size_delta. */
2235
fprintf(file, "\tmsgh_size_delta = ");
WriteArgSize(file, arg);
fprintf(file, ";\n");
2239
if (rt->rtNumReplyVar == 1) {
  /* We can still address the message header directly.  Fill
     in the size field. */
2243
  fprintf(file, "\t%s->Head.msgh_size = ", OutHeadSeg);
  rtMinReplySize(file, rt, "Reply");
  fprintf(file, " + msgh_size_delta;\n");
}
else if (arg->argReplyPos == 0) {
  /* First variable-length argument.  The previous msgh_size value
     is the minimum reply size. */
2251
  fprintf(file, "\tmsgh_size = ");
  rtMinReplySize(file, rt, "Reply");
  fprintf(file, " + msgh_size_delta;\n");
}
else
  fprintf(file, "\tmsgh_size += msgh_size_delta;\n");
2258
if (!UseMachMsg2) {
  fprintf(file, "\tOutP = (Reply *) ((pointer_t) OutP + msgh_size_delta - %d);\n",
    ptype->itTypeSize + ptype->itPadSize);
} else {
  fprintf(file, "\tOutUP = (ReplyU *) ((pointer_t) OutUP + msgh_size_delta - %d);\n",
    ptype->itTypeSize + ptype->itPadSize);
}
2266}
2267
2268/*
* Calculate the size of the message.  Called after the
* last argument has been packed.
*/
2272static void
2273WriteFinishMsgSize(FILE *file, argument_t *arg)
2274{
/* No more Out arguments.  If this is the only variable Out
   argument, we can assign to msgh_size directly. */
2277
if (arg->argReplyPos == 0) {
  fprintf(file, "\t%s->Head.msgh_size = ", OutHeadSeg);
  rtMinReplySize(file, arg->argRoutine, "Reply");
  fprintf(file, " + (");
  WriteArgSize(file, arg);
  fprintf(file, ");\n");
}
else {
  fprintf(file, "\tmsgh_size += ");
  WriteArgSize(file, arg);
  fprintf(file, ";\n");
}
2290}
2291
2292/*
* Handle reply arguments - fill in message types and copy arguments
* that need to be copied.
*/
2296static void
2297WriteReplyArgs(FILE *file, routine_t *rt)
2298{
argument_t *arg;
argument_t *lastVarArg;
2301
/*
 * 1. The Kernel Processed Data
 */
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnKPD))
    (*arg->argKPD_Pack)(file, arg);
/*
 * 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->argReplyPos < arg->argReplyPos) {
    WriteAdjustMsgSize(file, lastVarArg);
    lastVarArg = argNULL;
  }
2323
  if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnBody|akbVarNeeded))
    WritePackArgValueNormal(file, arg);
  else if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnBody|akbVariable))
    WritePackArgValueVariable(file, arg);
2328
  if (akCheck(arg->argKind, akbReplyCopy))
    WriteCopyArgValue(file, arg);
  if (akCheck(arg->argKind, akbReplyInit))
    WriteInitArgValue(file, arg);
  /*
   * Remember whether this was variable-length.
   */
  if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnBody|akbVariable))
    lastVarArg = arg;
}
/*
 * Finish the message size.
 */
if (lastVarArg != argNULL)
  WriteFinishMsgSize(file, lastVarArg);
2344}
2345
2346static void
2347WriteFieldDecl(FILE *file, argument_t *arg)
2348{
if (akCheck(arg->argKind, akbSendKPD) ||
    akCheck(arg->argKind, akbReturnKPD))
  WriteFieldDeclPrim(file, arg, FetchKPDType);
else
  WriteFieldDeclPrim(file, arg, FetchServerType);
2354}
2355
2356static void
2357InitKPD_Disciplines(argument_t *args)
2358{
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);
2365
/*
 * WriteInitKPD_port, WriteKPD_port,  WriteExtractKPD_port,
 * WriteInitKPD_ool, WriteKPD_ool,  WriteExtractKPD_ool,
 * WriteInitKPD_oolport, 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) {
2382
      case MACH_MSG_PORT_DESCRIPTOR:
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Extract =
          (IS_MULTIPLE_KPD(arg->argType)) ? WriteExtractKPD_port : WriteExtractArgValue;
          arg->argKPD_TypeCheck = WriteTCheckKPD_port;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_Template = WriteTemplateKPD_port;
          arg->argKPD_Init = WriteInitKPD_port;
          arg->argKPD_Pack = WriteKPD_port;
        }
        break;
2395
      case MACH_MSG_OOL_DESCRIPTOR:
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Extract =
          (IS_MULTIPLE_KPD(arg->argType)) ? WriteExtractKPD_ool : WriteExtractArgValue;
          arg->argKPD_TypeCheck = WriteTCheckKPD_ool;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_Template = WriteTemplateKPD_ool;
          arg->argKPD_Init = WriteInitKPD_ool;
          arg->argKPD_Pack = WriteKPD_ool;
        }
        break;
2408
      case MACH_MSG_OOL_PORTS_DESCRIPTOR:
        if akCheck(arg->argKind, akbSendKPD) {
          arg->argKPD_Extract =
          (IS_MULTIPLE_KPD(arg->argType)) ? WriteExtractKPD_oolport : WriteExtractArgValue;
          arg->argKPD_TypeCheck = WriteTCheckKPD_oolport;
        }
        if akCheck(arg->argKind, akbReturnKPD) {
          arg->argKPD_Template = WriteTemplateKPD_oolport;
          arg->argKPD_Init = WriteInitKPD_oolport;
          arg->argKPD_Pack = WriteKPD_oolport;
        }
        break;
2421
      default:
        printf("MiG internal error: type of kernel processed data unknown\n");
        exit(1);
    }   /* end of switch */
2426}
2427
2428static void WriteStringTerminatorCheck(FILE *file, routine_t *rt)
2429{
// generate code to verify that the length of a C string is not greater than the size of the
// buffer in which it is stored.
argument_t  *argPtr;
int msg_limit_calculated = FALSE;
int found_string_argument = FALSE;
int variable_length_args_present = (rt->rtMaxRequestPos > 0);
2436
// scan through arguments to see if there are any strings
for (argPtr = rt->rtArgs; argPtr != NULL; argPtr = argPtr->argNext) {
  if ((argPtr->argKind & akbRequest) && argPtr->argType->itString) {
    found_string_argument = TRUE;
    break;
  }
}
2444
if (found_string_argument) {
  // create a new scope, for local variables
  fputs("#if __MigTypeCheck\n" "\t" "{" "\n", file);
2448
  for (argPtr = rt->rtArgs; argPtr != NULL; argPtr = argPtr->argNext) {
    if ((argPtr->argKind & akbRequest) && argPtr->argType->itString) {
      //fprintf(stderr, "### found itString: variable name = %s, max length = %d\n", argPtr->argName, argPtr->argType->itNumber);
2452
      if (!msg_limit_calculated) {
        msg_limit_calculated = TRUE; // only need to do this once
        if (!UseMachMsg2) {
          fprintf(file, "\t\t" "char * msg_limit = ((char *) In0P) + In0P->Head.msgh_size;\n");
        } else {
          fprintf(file, "\t\t" "char * msg_limit = (char *) InTrailerP;\n");
        }
        if (IsKernelServer) {
          fputs("#if __MigKernelSpecificCode\n", file);
          fputs("\t\t" "size_t strnlen_limit;" "\n", file);
          fputs("#else\n", file);
        }
        fputs("\t\t" "size_t memchr_limit;" "\n", file);
        if (IsKernelServer) {
          fputs("#endif /* __MigKernelSpecificCode */" "\n", file);
        }
        fputc('\n', file);
      }
2471
      // I would really prefer to use strnlen() here, to ensure that the byte scanning logic does not extend beyond
      // the end of the buffer, but it's not necessarily guaranteed to be available. Instead, I'll use memchr(),
      // and let it look for the terminating null byte.
      // (later...)
      // It turns out that the kernel does not have memchr() available, but strnlen() IS available, so we'll just
      // have to emit some conditional code to use the appropriate runtime environment scanning function.
      //
      if (!variable_length_args_present) {
        assert(argPtr->argRequestPos == 0);
      }
      if (IsKernelServer) {
        fputs("#if __MigKernelSpecificCode\n", file);
        fputs("\t\t" "strnlen_limit = min((msg_limit - ", file);
        // If there are variable-length arguments within the message, the proper (adjusted)
        // pointers must be used to access those strings
        fprintf(file, "%s->%s),  %d);" "\n", argPtr->argInSegment, argPtr->argName, argPtr->argType->itNumber);
        fputs("\t\t" "if (", file);
        fprintf(file, "( strnlen(%s->%s, strnlen_limit) >= %d + 1 )", argPtr->argInSegment, argPtr->argName, argPtr->argType->itNumber);
        fputs(")" "\n" "\t\t\t" "return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!" "\n", file);
        fputs("#else\n", file);
      }
      // If there are variable-length arguments within the message, the proper (adjusted)
      // pointers must be used to access those strings
      fprintf(file, "\t\t" "memchr_limit = min((msg_limit - %s->%s), %d);" "\n",
        argPtr->argInSegment, argPtr->argName, argPtr->argType->itNumber);
      fputs("\t\t" "if (", file);
      fprintf(file, "( memchr(%s->%s, '\\0', memchr_limit) == NULL )", argPtr->argInSegment, argPtr->argName);
      fputs(")" "\n" "\t\t\t" "return MIG_BAD_ARGUMENTS; // string length exceeds buffer length!" "\n", file);
      if (IsKernelServer) {
        fputs("#endif /* __MigKernelSpecificCode */" "\n", file);
      }
    }
  }
  fputs("\t" "}" "\n" "#endif" "\t" "/* __MigTypeCheck */" "\n\n", file); // terminate new scope
}
2507
return;
2509}
2510
2511static void
2512WriteOOLSizeCheck(FILE *file, routine_t *rt)
2513{
/* Emit code to validate the actual size of ool data vs. the reported size */
2515
argument_t  *argPtr;
boolean_t   openedTypeCheckConditional = FALSE;
2518
// 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, akbSendKPD)) {
    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;
2528
    if (argPtr->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR) {
2530
      if (multiple_kpd) {
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
        WriteKPD_Iterator(file, TRUE, 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, "%s->%s.", argPtr->argInSegment, argPtr->argMsgField);
        test = !it->itVarArray;
        argCountPtr = argPtr->argCount;
      }
2548
      if (!test) {
        int multiplier = (argCountPtr->argMultiplier > 1 || it->itSize > 8) ? argCountPtr->argMultiplier * it->itSize / 8 : 1;
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2555
        fprintf(file, "\t%s" "if (%ssize ", tab, string);
        if (multiplier > 1)
          fprintf(file, "/ %d ", multiplier);
        fprintf(file,"!= %s->%s%s", argCountPtr->argInSegment, argCountPtr->argVarName, multiple_kpd ? "[i]" : "");
        if (it->itOOL_Number) {
          fprintf(file," || %s->%s%s > %d", argCountPtr->argInSegment,
           argCountPtr->argVarName, multiple_kpd ? "[i]" : "", it->itOOL_Number);
        }
2564
        fprintf(file,")\n");
        fprintf(file, "\t\t%s" "return MIG_TYPE_ERROR;\n", tab);
      }
2568
      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);
        }
        WriteKPD_Iterator(file, TRUE, 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, "%s->%s.", argPtr->argInSegment, argPtr->argMsgField);
        test = !it->itVarArray;
        argCountPtr = argPtr->argCount;
      }
2589
      if (!test) {
        if ( !openedTypeCheckConditional ) {
          openedTypeCheckConditional = TRUE;
          fputs("#if __MigTypeCheck\n", file);
        }
2595
        fprintf(file, "\t%s" "if (%scount ", tab, string);
        fprintf(file,"!= %s->%s%s", argCountPtr->argInSegment, argCountPtr->argVarName, multiple_kpd ? "[i]" : "");
        if (it->itOOL_Number) {
          fprintf(file," || %s->%s%s > %d", argCountPtr->argInSegment,
            argCountPtr->argVarName, multiple_kpd ? "[i]" : "", it->itOOL_Number);
        }
        fprintf(file,")\n");
        fprintf(file, "\t\t%s" "return MIG_TYPE_ERROR;\n", tab);
      }
2605
      if (multiple_kpd)
        fprintf(file, "\t    }\n\t}\n");
    }
  }
}
2611
if ( openedTypeCheckConditional )
  fputs("#endif" "\t" "/* __MigTypeCheck */" "\n\n", file);
2614}
2615
2616
2617void
2618WriteCheckRequest(FILE *file, routine_t *rt)
2619{
int i;
2621
/* initialize the disciplines for the handling of KPDs */
InitKPD_Disciplines(rt->rtArgs);
2624
fprintf(file, "\n");
fprintf(file, "#if ( __MigTypeCheck ");
if (CheckNDR)
 fprintf(file, "|| __NDR_convert__ ");
fprintf(file, ")\n");
fprintf(file, "#if __MIG_check__Request__%s_subsystem__\n", SubsystemName);
fprintf(file, "#if !defined(__MIG_check__Request__%s_t__defined)\n", rt->rtName);
fprintf(file, "#define __MIG_check__Request__%s_t__defined\n", rt->rtName);
if (CheckNDR && akCheck(rt->rtNdrCode->argKind, akbRequest)) {
  __KernelServer_unreachable();
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertIntRepArgDecl, akbSendNdr, "", "");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertCharRepArgDecl, akbSendNdr, "", "");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertFloatRepArgDecl, akbSendNdr, "", "");
}
fprintf(file, "\n");
if (!UseMachMsg2) {
  fprintf(file, "mig_internal kern_return_t __MIG_check__Request__%s_t(__attribute__((__unused__)) __Request__%s_t *In0P",
    rt->rtName, rt->rtName);
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, ", __attribute__((__unused__)) __Request__%s_t **In%dPP", rt->rtName, i);
} else {
  fprintf(file, "mig_internal kern_return_t __MIG_check__Request__%s_t(\n"
    "\t__attribute__((__unused__)) __RequestKData__%s_t *InKP,\n"
    "\t__attribute__((__unused__)) __RequestUData__%s_t *In0UP,\n"
    "\t__attribute__((__unused__)) mach_msg_max_trailer_t *InTrailerP",
    rt->rtName, rt->rtName, rt->rtName);
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, ",\n\t__attribute__((__unused__)) __RequestUData__%s_t **In%dUPP", rt->rtName, i);
}
fprintf(file, ")\n{\n");
2655
fprintf(file, "\n\ttypedef __Request__%s_t __Request;\n", rt->rtName);
if (!UseMachMsg2) {
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, "\t__Request *In%dP;\n", i);
} else {
  fprintf(file, "\ttypedef __RequestUData__%s_t __RequestU __attribute__((unused));\n", rt->rtName);
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, "\t__RequestU *In%dUP;\n", i);
}
2665
if (rt->rtNumRequestVar > 0) {
  fprintf(file, "#if\t__MigTypeCheck\n");
  fprintf(file, "\tunsigned int msgh_size;\n");
  fprintf(file, "#endif\t/* __MigTypeCheck */\n");
}
if (rt->rtMaxRequestPos > 0)
  fprintf(file, "\tunsigned int msgh_size_delta;\n");
if (rt->rtNumRequestVar > 0 || rt->rtMaxRequestPos > 0)
  fprintf(file, "\n");
2675
WriteCheckHead(file, rt);
2677
WriteList(file, rt->rtArgs, WriteTypeCheck, akbSendKPD, "\n", "\n");
2679
{
  argument_t *arg, *lastVarArg;
2682
  lastVarArg = argNULL;
  for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
    if (lastVarArg != argNULL &&
        lastVarArg->argRequestPos < arg->argRequestPos) {
      WriteAdjustRequestMsgPtr(file, lastVarArg);
      lastVarArg = argNULL;
    }
    if (akCheckAll(arg->argKind, akbSendRcv|akbSendBody)) {
      if (akCheck(arg->argKind, akbVariable)) {
        WriteCheckMsgSize(file, arg);
        lastVarArg = arg;
      }
    }
  }
}
2698
if (CheckNDR && akCheck(rt->rtNdrCode->argKind, akbRequest)) {
  __KernelServer_unreachable();
  fprintf(file, "#if\t");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertIntRepArgCond, akbSendNdr, " || \\\n\t", "\n");
  fprintf(file, "\tif (In0P->NDR.int_rep != NDR_record.int_rep) {\n");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertIntRepArgUse, akbSendNdr, "", "");
  fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__int_rep...) */\n\n");
2706
  WriteOOLSizeCheck(file, rt);
2708
  fprintf(file, "#if\t");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertCharRepArgCond, akbSendNdr, " || \\\n\t", "\n");
  fprintf(file, "\tif (In0P->NDR.char_rep != NDR_record.char_rep) {\n");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertCharRepArgUse, akbSendNdr, "", "");
  fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__char_rep...) */\n\n");
2714
  fprintf(file, "#if\t");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertFloatRepArgCond, akbSendNdr, " || \\\n\t", "\n");
  fprintf(file, "\tif (In0P->NDR.float_rep != NDR_record.float_rep) {\n");
  WriteList(file, rt->rtArgs, WriteRequestNDRConvertFloatRepArgUse, akbSendNdr, "", "");
  fprintf(file, "\t}\n#endif\t/* defined(__NDR_convert__float_rep...) */\n\n");
} else {
 WriteOOLSizeCheck(file, rt);
}
2723
WriteStringTerminatorCheck(file, rt);
2725
fprintf(file, "\treturn MACH_MSG_SUCCESS;\n");
fprintf(file, "}\n");
fprintf(file, "#endif /* !defined(__MIG_check__Request__%s_t__defined) */\n", rt->rtName);
fprintf(file, "#endif /* __MIG_check__Request__%s_subsystem__ */\n", SubsystemName);
fprintf(file, "#endif /* ( __MigTypeCheck ");
if (CheckNDR)
 fprintf(file, "|| __NDR_convert__ ");
fprintf(file, ") */\n");
fprintf(file, "\n");
2735}
2736
2737void
2738WriteCheckRequestCall(FILE *file, routine_t *rt)
2739{
int i;
2741
fprintf(file, "\n");
fprintf(file, "#if\tdefined(__MIG_check__Request__%s_t__defined)\n", rt->rtName);
if (!UseMachMsg2) {
  fprintf(file, "\tcheck_result = __MIG_check__Request__%s_t((__Request *)In0P", rt->rtName);
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, ", (__Request **)&In%dP", i);
} else {
  fprintf(file, "\tcheck_result = __MIG_check__Request__%s_t((RequestK *)InKP, (__RequestU *)In0UP, InTrailerP", rt->rtName);
  for (i = 1; i <= rt->rtMaxRequestPos; i++)
    fprintf(file, ", (__RequestU **)&In%dUP", i);
}
fprintf(file, ");\n");
fprintf(file, "\tif (check_result != MACH_MSG_SUCCESS)\n");
fprintf(file, "\t\t{ MIG_RETURN_ERROR(%s, check_result); }\n", OutHeadSeg);
fprintf(file, "#endif\t/* defined(__MIG_check__Request__%s_t__defined) */\n", rt->rtName);
fprintf(file, "\n");
2758}
2759
2760void
2761WriteCheckRequests(FILE *file, statement_t *stats)
2762{
statement_t *stat;
2764
for (stat = stats; stat != stNULL; stat = stat->stNext)
  if (stat->stKind == skRoutine)
    WriteCheckRequest(file, stat->stRoutine);
2768}
2769
2770static void
2771WriteRoutine(FILE *file, routine_t *rt)
2772{
/*  Declare the server work function: */
if (ServerHeaderFileName == strNULL)
  WriteServerRoutine(file, rt);
2776
fprintf(file, "\n");
2778
fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName);
fprintf(file, "mig_internal novalue _X%s\n", rt->rtName);
if (BeAnsiC) {
  if (!UseMachMsg2) {
    fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n");
  } else {
    fprintf(file, "\t(mach_msg_header_t *InHeadP, __attribute__((__unused__)) void *InDataP,\n"
      "\t__attribute__((__unused__)) mach_msg_max_trailer_t *InTrailerP,\n"
      "\tmach_msg_header_t *OutHeadP, __attribute__((__unused__)) void *OutDataP)\n");
  }
}
else {
  __KernelServer_unreachable();
  fprintf(file, "#if\t%s\n", NewCDecl);
  fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n");
  fprintf(file, "#else\n");
  fprintf(file, "\t(InHeadP, OutHeadP)\n");
  fprintf(file, "\tmach_msg_header_t *InHeadP, *OutHeadP;\n");
  fprintf(file, "#endif\t/* %s */\n", NewCDecl);
}
2799
fprintf(file, "{\n");
if (!UseMachMsg2) {
  WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "Request",
    rt->rtSimpleRequest, TRUE, rt->rtServerImpl, FALSE);
} else {
  WriteUDataStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "RequestU",
    rt->rtSimpleRequest, TRUE, rt->rtServerImpl, FALSE);
  fprintf(file, "\ttypedef __RequestKData__%s_t RequestK;\n", rt->rtName);
  fprintf(file, "\ttypedef __RequestUData__%s_t __RequestU;\n", rt->rtName);
  fprintf(file, "\ttypedef __ReplyKData__%s_t ReplyK __attribute__((unused));\n", rt->rtName);
  fprintf(file, "\ttypedef __ReplyUData__%s_t ReplyU __attribute__((unused));\n", rt->rtName);
}
fprintf(file, "\ttypedef __Reply__%s_t Reply __attribute__((unused));\n", rt->rtName);
fprintf(file, "\ttypedef __Request__%s_t __Request __attribute__((unused));\n\n", rt->rtName);
2814
/*
 * 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");
2826
WriteVarDecls(file, rt);
2828
if (IsKernelServer) {
  fprintf(file, "#if\t__MigKernelSpecificCode\n");
  WriteList(file, rt->rtArgs, WriteTemplateDeclOut, akbReturnKPD, "\n", "\n");
  fprintf(file, "#else\n");
}
WriteList(file, rt->rtArgs, WriteTemplateDeclIn, akbReturnKPD, "\n", "\n");
if (IsKernelServer) {
  fprintf(file, "#endif /* __MigKernelSpecificCode */\n");
}
WriteRetCode(file, rt->rtRetCode);
WriteList(file, rt->rtArgs, WriteLocalVarDecl, akbVarNeeded | akbServerArg, ";\n", ";\n\n");
WriteApplMacro(file, "Rcv", "Declare", rt);
WriteApplMacro(file, "Rcv", "Before", rt);
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  WriteRetCArgCheckError(file, rt);
  if (rt->rtServerImpl)
    WriteCheckTrailerHead(file, rt, FALSE);
  WriteServerCall(file, rt, WriteConditionalCallArg);
  WriteRetCArgFinishError(file, rt);
}
2849
WriteCheckRequestCall(file, rt);
WriteCheckRequestTrailerArgs(file, rt);
2852
/*
 * Initialize the KPD records in the Reply structure with the
 * templates. We do this beforehand because the call to the procedure
 * will overwrite some of the values (after the call it would be impossible
 * to initialize the KPD records from the static Templates, because we
 * would lose data).
 */
WriteList(file, rt->rtArgs, WriteInitKPDValue, akbReturnKPD, "\n", "\n");
2861
WriteList(file, rt->rtArgs, WriteExtractArg, akbNone, "", "");
2863
if (UseEventLogger)
  WriteLogMsg(file, rt, LOG_SERVER, LOG_REQUEST);
2866
WriteServerCall(file, rt, WriteServerCallArg);
2868
WriteReverseList(file, rt->rtArgs, WriteDestroyArg, akbDestroy, "", "");
2870
/*
 * For one-way routines, it doesn`t make sense to check the return
 * code, because we return immediately afterwards.  However,
 * kernel servers may want to deallocate port arguments - and the
 * deallocation must not be done if the return code is not KERN_SUCCESS.
 */
if (rt->rtOneWay || rt->rtNoReplyArgs) {
  if (IsKernelServer) {
    fprintf(file,"#if\t__MigKernelSpecificCode\n");
    if (rtCheckMaskFunction(rt->rtArgs, akbSendKPD, CheckDestroyPortArg)) {
      WriteCheckReturnValue(file, rt);
    }
    WriteReverseList(file, rt->rtArgs, WriteDestroyPortArg, akbSendKPD, "", "");
    fprintf(file,"#endif /* __MigKernelSpecificCode */\n");
  }
  /* although we have an empty reply, we still have to make sure that
   some fields such as NDR get properly initialized */
  if (!rt->rtOneWay)
    WriteList(file, rt->rtArgs, WriteInitArgValue, akbReplyInit, "\n", "\n");
}
else {
  WriteCheckReturnValue(file, rt);
2893
  if (IsKernelServer) {
    fprintf(file,"#if\t__MigKernelSpecificCode\n");
    WriteReverseList(file, rt->rtArgs, WriteDestroyPortArg, akbSendKPD, "", "");
    fprintf(file,"#endif /* __MigKernelSpecificCode */\n");
  }
  WriteReplyArgs(file, rt);
  WriteReplyInit(file, rt);
  if (!rt->rtSimpleReply)
    fprintf(file, "\t%s->msgh_body.msgh_descriptor_count = %d;\n", OutHeadSeg, rt->rtReplyKPDs);
}
if (UseEventLogger)
  WriteLogMsg(file, rt, LOG_SERVER, LOG_REPLY);
2906
WriteApplMacro(file, "Rcv", "After", rt);
fprintf(file, "}\n");
2909}
2910
2911void
2912WriteServer(FILE *file, statement_t *stats)
2913{
statement_t *stat;
2915
WriteProlog(file, stats);
if (BeAnsiC)
  WriteForwardDeclarations(file, stats);
for (stat = stats; stat != stNULL; stat = stat->stNext)
  switch (stat->stKind) {
2921
    case skRoutine:
      WriteCheckRequest(file, stat->stRoutine);
      WriteRoutine(file, stat->stRoutine);
      break;
2926
    case skIImport:
    case skImport:
    case skSImport:
    case skDImport:
    case skUImport:
      break;
2933
    default:
      fatal("WriteServer(): bad statement_kind_t (%d)",
            (int) stat->stKind);
  }
WriteDispatcher(file, stats);
2939}