/* Module process */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif

#define EXPORT_BOOLEAN
#include <mach/boolean.h>
#include <mach/kern_return.h>
#include <mach/message.h>
#include <mach/mig_errors.h>
#include <mach/mig_support.h>

#ifndef	mig_internal
#define	mig_internal	static
#endif

#ifndef	mig_external
#define mig_external
#endif

#ifndef	TypeCheck
#define	TypeCheck 1
#endif

#ifndef	UseExternRCSId
#define	UseExternRCSId		1
#endif

#define BAD_TYPECHECK(type, check) ({\
  union { mach_msg_type_t t; unsigned32_t w; } _t, _c;\
  _t.t = *(type); _c.t = *(check); _t.w != _c.w; })
#define msgh_request_port	msgh_local_port
#define MACH_MSGH_BITS_REQUEST(bits)	MACH_MSGH_BITS_LOCAL(bits)
#define msgh_reply_port		msgh_remote_port
#define MACH_MSGH_BITS_REPLY(bits)	MACH_MSGH_BITS_REMOTE(bits)

#include <hurd/ports.h>
#include <mach/std_types.h>
#include <mach/mach_types.h>
#include <device/device_types.h>
#include <device/net_status.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include <sys/resource.h>
#include <sys/utsname.h>
#include <hurd/hurd_types.h>
#include <fcntl.h>
#include "mig-decls.h"

/* Routine proc_getprivports */
mig_internal void _Xproc_getprivports
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t host_privType;
		mach_port_t host_priv;
		mach_msg_type_t device_masterType;
		mach_port_t device_master;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getprivports
		(pstruct_t process, mach_port_t *host_priv, mach_port_t *device_master);

	const mach_msg_type_t host_privType = {
		/* msgt_name = */		19,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t device_masterType = {
		/* msgt_name = */		19,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getprivports(process, &OutP->host_priv, &OutP->device_master);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 48;

	OutP->host_privType = host_privType;

	OutP->device_masterType = device_masterType;
}

/* Routine proc_getallpids */
mig_internal void _Xproc_getallpids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t pidarrayType;
		pid_t pidarray[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getallpids
		(pstruct_t process, pidarray_t *pidarray, mach_msg_type_number_t *pidarrayCnt);

	boolean_t msgh_simple;
	const mach_msg_type_long_t pidarrayType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_number_t pidarrayCnt;

	pid_t *pidarrayP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	pidarrayP = OutP->pidarray;
	pidarrayCnt = 512;

	OutP->RetCode = S_proc_getallpids(process, &pidarrayP, &pidarrayCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->pidarrayType = pidarrayType;
	if (pidarrayP != OutP->pidarray) {
		OutP->pidarrayType.msgtl_header.msgt_inline = FALSE;
		OutP->pidarrayType.msgtl_header.msgt_deallocate = TRUE;
		*((pid_t **)OutP->pidarray) = pidarrayP;
		msgh_simple = FALSE;
	}

	OutP->pidarrayType.msgtl_number = pidarrayCnt;
	OutP->Head.msgh_size = 44 + ((OutP->pidarrayType.msgtl_header.msgt_inline) ? 4 * pidarrayCnt : sizeof(pid_t *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_setexecdata */
mig_internal void _Xproc_setexecdata
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_long_t portsType;
		mach_port_t ports[512];
		mach_msg_type_long_t intsType;
		int ints[512];
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Request *In1P;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setexecdata
		(pstruct_t process, portarray_t ports, mach_msg_type_number_t portsCnt, intarray_t ints, mach_msg_type_number_t intsCnt);

	unsigned int msgh_size;
	unsigned int msgh_size_delta;

	pstruct_t process;

#if	TypeCheck
	msgh_size = In0P->Head.msgh_size;
	if ((msgh_size < 48) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if ((In0P->portsType.msgtl_header.msgt_longform != TRUE) ||
	    (In0P->portsType.msgtl_name != 17) ||
	    (In0P->portsType.msgtl_size != 32))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	msgh_size_delta = (In0P->portsType.msgtl_header.msgt_inline) ? 4 * In0P->portsType.msgtl_number : sizeof(mach_port_t *);
#if	TypeCheck
	if (msgh_size < 48 + msgh_size_delta)
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
	msgh_size -= msgh_size_delta;
#endif	/* TypeCheck */

	In1P = (Request *) ((char *) In0P + msgh_size_delta - 2048);

#if	TypeCheck
	if ((In1P->intsType.msgtl_header.msgt_longform != TRUE) ||
	    (In1P->intsType.msgtl_name != 2) ||
	    (In1P->intsType.msgtl_size != 32))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 48 + ((In1P->intsType.msgtl_header.msgt_inline) ? 4 * In1P->intsType.msgtl_number : sizeof(int *)))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_setexecdata(process, (In0P->portsType.msgtl_header.msgt_inline) ? In0P->ports : *((mach_port_t **)In0P->ports), In0P->portsType.msgtl_number, (In1P->intsType.msgtl_header.msgt_inline) ? In1P->ints : *((int **)In1P->ints), In1P->intsType.msgtl_number);
	if (OutP->RetCode == KERN_SUCCESS)
		if (!In1P->intsType.msgtl_header.msgt_inline)
			__mig_deallocate(* (vm_offset_t *) In1P->ints, 4 *  In1P->intsType.msgtl_number);
	if (OutP->RetCode == KERN_SUCCESS)
		if (!In0P->portsType.msgtl_header.msgt_inline)
			__mig_deallocate(* (vm_offset_t *) In0P->ports, 4 *  In0P->portsType.msgtl_number);
	end_using_proc(process);
}

/* Routine proc_getexecdata */
mig_internal void _Xproc_getexecdata
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t portsType;
		mach_port_t ports[512];
		mach_msg_type_long_t intsType;
		int ints[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getexecdata
		(pstruct_t process, portarray_t *ports, mach_msg_type_name_t *portsPoly, mach_msg_type_number_t *portsCnt, intarray_t *ints, mach_msg_type_number_t *intsCnt);

	boolean_t msgh_simple;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;

	const mach_msg_type_long_t portsType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	-1,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	const mach_msg_type_long_t intsType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_name_t portsPoly;
	mach_msg_type_number_t portsCnt;
	int ints[512];
	mach_msg_type_number_t intsCnt;

	mach_port_t *portsP;
	int *intsP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	portsP = OutP->ports;
	portsCnt = 512;

	intsP = ints;
	intsCnt = 512;

	OutP->RetCode = S_proc_getexecdata(process, &portsP, &portsPoly, &portsCnt, &intsP, &intsCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->portsType = portsType;
	if (portsP != OutP->ports) {
		OutP->portsType.msgtl_header.msgt_inline = FALSE;
		OutP->portsType.msgtl_header.msgt_deallocate = TRUE;
		*((mach_port_t **)OutP->ports) = portsP;
		msgh_simple = FALSE;
	}

	if (MACH_MSG_TYPE_PORT_ANY(portsPoly))
		msgh_simple = FALSE;

	OutP->portsType.msgtl_name = portsPoly;

	OutP->portsType.msgtl_number = portsCnt;
	msgh_size_delta = (OutP->portsType.msgtl_header.msgt_inline) ? 4 * portsCnt : sizeof(mach_port_t *);
	msgh_size = 56 + msgh_size_delta;
	OutP = (Reply *) ((char *) OutP + msgh_size_delta - 2048);

	OutP->intsType = intsType;

	if (intsP != ints) {
		OutP->intsType.msgtl_header.msgt_inline = FALSE;
		OutP->intsType.msgtl_header.msgt_deallocate = TRUE;
		*((int **)OutP->ints) = intsP;
		msgh_simple = FALSE;
	}
	else {
		memcpy(OutP->ints, ints, 4 * intsCnt);
	}

	OutP->intsType.msgtl_number = intsCnt;
	msgh_size += (OutP->intsType.msgtl_header.msgt_inline) ? 4 * intsCnt : sizeof(int *);

	OutP = (Reply *) OutHeadP;
	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = msgh_size;
}

/* Routine proc_execdata_notify */
mig_internal void _Xproc_execdata_notify
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t notifyType;
		mach_port_t notify;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_execdata_notify
		(pstruct_t process, mach_port_t notify);

	const mach_msg_type_t notifyCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->notifyType, &notifyCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_execdata_notify(process, In0P->notify);
	end_using_proc(process);
}

/* Routine proc_uname */
mig_internal void _Xproc_uname
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t unameType;
		utsname_t uname;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_uname
		(pstruct_t process, utsname_t *uname);

	const mach_msg_type_long_t unameType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	8,
		/* msgtl_size = */	8,
		/* msgtl_number = */	5120,
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_uname(process, &OutP->uname);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 5164;

	OutP->unameType = unameType;
}

/* Routine proc_register_version */
mig_internal void _Xproc_register_version
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t credentialType;
		mach_port_t credential;
		mach_msg_type_t nameType;
		string_t name;
		mach_msg_type_t releaseType;
		string_t release;
		mach_msg_type_t versionType;
		string_t version;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_register_version
		(pstruct_t process, mach_port_t credential, string_t name, string_t release, string_t version);

	const mach_msg_type_t credentialCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t nameCheck = {
		/* msgt_name = */		MACH_MSG_TYPE_STRING_C,
		/* msgt_size = */		8,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t releaseCheck = {
		/* msgt_name = */		MACH_MSG_TYPE_STRING_C,
		/* msgt_size = */		8,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t versionCheck = {
		/* msgt_name = */		MACH_MSG_TYPE_STRING_C,
		/* msgt_size = */		8,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 3116) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->credentialType, &credentialCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->nameType, &nameCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->releaseType, &releaseCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->versionType, &versionCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_register_version(process, In0P->credential, In0P->name, In0P->release, In0P->version);
	end_using_proc(process);
}

/* SimpleRoutine proc_reauthenticate */
mig_internal void _Xproc_reauthenticate
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t rendezvous2Type;
		mach_port_t rendezvous2;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_reauthenticate
		(pstruct_t process, mach_port_t rendezvous2);

	const mach_msg_type_t rendezvous2Check = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->rendezvous2Type, &rendezvous2Check))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_reauthenticate(process, In0P->rendezvous2);
	end_using_proc(process);
}

/* Routine proc_child */
mig_internal void _Xproc_child
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t childType;
		mach_port_t child;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_child
		(pstruct_t process, mach_port_t child);

	const mach_msg_type_t childCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->childType, &childCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_child(process, In0P->child);
	end_using_proc(process);
}

/* Routine proc_setmsgport */
mig_internal void _Xproc_setmsgport
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t newmsgportType;
		mach_port_t newmsgport;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t oldmsgportType;
		mach_port_t oldmsgport;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setmsgport
		(pstruct_t process, mach_port_t reply_port, mach_msg_type_name_t reply_portPoly, mach_port_t newmsgport, mach_port_t *oldmsgport, mach_msg_type_name_t *oldmsgportPoly);

	boolean_t msgh_simple;
	const mach_msg_type_t newmsgportCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t oldmsgportType = {
		/* msgt_name = */		-1,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;
	mach_port_t reply_port;
	mach_port_t newmsgport;
	mach_msg_type_name_t oldmsgportPoly;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->newmsgportType, &newmsgportCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	reply_port = In0P->Head.msgh_reply_port;

	newmsgport = In0P->newmsgport;

	OutP->RetCode = S_proc_setmsgport(process, reply_port, MACH_MSGH_BITS_REPLY(In0P->Head.msgh_bits), newmsgport, &OutP->oldmsgport, &oldmsgportPoly);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;
	OutP->Head.msgh_size = 40;

	OutP->oldmsgportType = oldmsgportType;

	if (MACH_MSG_TYPE_PORT_ANY(oldmsgportPoly))
		msgh_simple = FALSE;

	OutP->oldmsgportType.msgt_name = oldmsgportPoly;

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_reassign */
mig_internal void _Xproc_reassign
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t newtaskType;
		mach_port_t newtask;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_reassign
		(pstruct_t process, mach_port_t newtask);

	const mach_msg_type_t newtaskCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->newtaskType, &newtaskCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_reassign(process, In0P->newtask);
	end_using_proc(process);
}

/* Routine proc_setowner */
mig_internal void _Xproc_setowner
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t ownerType;
		uid_t owner;
		mach_msg_type_t clearType;
		int clear;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setowner
		(pstruct_t process, uid_t owner, int clear);

	const mach_msg_type_t ownerCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t clearCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->ownerType, &ownerCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->clearType, &clearCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_setowner(process, In0P->owner, In0P->clear);
	end_using_proc(process);
}

/* Routine proc_getpids */
mig_internal void _Xproc_getpids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t pidType;
		pid_t pid;
		mach_msg_type_t ppidType;
		pid_t ppid;
		mach_msg_type_t orphanedType;
		int orphaned;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getpids
		(pstruct_t process, pid_t *pid, pid_t *ppid, int *orphaned);

	const mach_msg_type_t pidType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t ppidType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t orphanedType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getpids(process, &OutP->pid, &OutP->ppid, &OutP->orphaned);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 56;

	OutP->pidType = pidType;

	OutP->ppidType = ppidType;

	OutP->orphanedType = orphanedType;
}

/* Routine proc_set_arg_locations */
mig_internal void _Xproc_set_arg_locations
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t argvType;
		vm_address_t argv;
		mach_msg_type_t envpType;
		vm_address_t envp;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_set_arg_locations
		(pstruct_t process, vm_address_t argv, vm_address_t envp);

	const mach_msg_type_t argvCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t envpCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->argvType, &argvCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->envpType, &envpCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_set_arg_locations(process, In0P->argv, In0P->envp);
	end_using_proc(process);
}

/* Routine proc_get_arg_locations */
mig_internal void _Xproc_get_arg_locations
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t argvType;
		vm_address_t argv;
		mach_msg_type_t envpType;
		vm_address_t envp;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_get_arg_locations
		(pstruct_t process, vm_address_t *argv, vm_address_t *envp);

	const mach_msg_type_t argvType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t envpType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_get_arg_locations(process, &OutP->argv, &OutP->envp);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 48;

	OutP->argvType = argvType;

	OutP->envpType = envpType;
}

/* Routine proc_getmsgport */
mig_internal void _Xproc_getmsgport
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t msgportType;
		mach_port_t msgport;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getmsgport
		(pstruct_t process, mach_port_t reply_port, mach_msg_type_name_t reply_portPoly, pid_t pid, mach_port_t *msgport);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t msgportType = {
		/* msgt_name = */		19,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;
	mach_port_t reply_port;
	mach_port_t msgport;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	reply_port = In0P->Head.msgh_reply_port;

	OutP->RetCode = S_proc_getmsgport(process, reply_port, MACH_MSGH_BITS_REPLY(In0P->Head.msgh_bits), In0P->pid, &msgport);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 40;

	OutP->msgportType = msgportType;

	OutP->msgport = msgport;
}

/* Routine proc_wait */
mig_internal void _Xproc_wait
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
		mach_msg_type_t optionsType;
		int options;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t statusType;
		int status;
		mach_msg_type_t sigcodeType;
		int sigcode;
		mach_msg_type_t rusageType;
		rusage_t rusage;
		mach_msg_type_t pid_statusType;
		pid_t pid_status;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_wait
		(pstruct_t process, mach_port_t reply_port, mach_msg_type_name_t reply_portPoly, pid_t pid, int options, int *status, int *sigcode, rusage_t *rusage, pid_t *pid_status);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t optionsCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t statusType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t sigcodeType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t rusageType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		18,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pid_statusType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;
	mach_port_t reply_port;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->optionsType, &optionsCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	reply_port = In0P->Head.msgh_reply_port;

	OutP->RetCode = S_proc_wait(process, reply_port, MACH_MSGH_BITS_REPLY(In0P->Head.msgh_bits), In0P->pid, In0P->options, &OutP->status, &OutP->sigcode, &OutP->rusage, &OutP->pid_status);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 132;

	OutP->statusType = statusType;

	OutP->sigcodeType = sigcodeType;

	OutP->rusageType = rusageType;

	OutP->pid_statusType = pid_statusType;
}

/* Routine proc_dostop */
mig_internal void _Xproc_dostop
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t contthreadType;
		mach_port_t contthread;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_dostop
		(pstruct_t process, mach_port_t contthread);

	const mach_msg_type_t contthreadCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->contthreadType, &contthreadCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_dostop(process, In0P->contthread);
	end_using_proc(process);
}

/* Routine proc_handle_exceptions */
mig_internal void _Xproc_handle_exceptions
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t msgportType;
		mach_port_t msgport;
		mach_msg_type_t forwardportType;
		mach_port_t forwardport;
		mach_msg_type_t flavorType;
		int flavor;
		mach_msg_type_t new_stateType;
		natural_t new_state[1024];
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_handle_exceptions
		(pstruct_t process, mach_port_t msgport, mach_port_t forwardport, int flavor, thread_state_t new_state, mach_msg_type_number_t new_stateCnt);

	unsigned int msgh_size;

	const mach_msg_type_t msgportCheck = {
		/* msgt_name = */		16,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t forwardportCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t flavorCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	msgh_size = In0P->Head.msgh_size;
	if ((msgh_size < 52) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->msgportType, &msgportCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->forwardportType, &forwardportCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->flavorType, &flavorCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if ((In0P->new_stateType.msgt_inline != TRUE) ||
	    (In0P->new_stateType.msgt_longform != FALSE) ||
	    (In0P->new_stateType.msgt_name != 2) ||
	    (In0P->new_stateType.msgt_size != 32))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 52 + (4 * In0P->new_stateType.msgt_number))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_handle_exceptions(process, In0P->msgport, In0P->forwardport, In0P->flavor, In0P->new_state, In0P->new_stateType.msgt_number);
	end_using_proc(process);
}

/* Routine proc_mark_stop */
mig_internal void _Xproc_mark_stop
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t signoType;
		int signo;
		mach_msg_type_t sigcodeType;
		int sigcode;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_stop
		(pstruct_t process, int signo, int sigcode);

	const mach_msg_type_t signoCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t sigcodeCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->signoType, &signoCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->sigcodeType, &sigcodeCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_stop(process, In0P->signo, In0P->sigcode);
	end_using_proc(process);
}

/* Routine proc_mark_cont */
mig_internal void _Xproc_mark_cont
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_cont
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_cont(process);
	end_using_proc(process);
}

/* Routine proc_mark_exit */
mig_internal void _Xproc_mark_exit
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t statusType;
		int status;
		mach_msg_type_t sigcodeType;
		int sigcode;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_exit
		(pstruct_t process, int status, int sigcode);

	const mach_msg_type_t statusCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t sigcodeCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->statusType, &statusCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->sigcodeType, &sigcodeCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_exit(process, In0P->status, In0P->sigcode);
	end_using_proc(process);
}

/* Routine proc_mark_exec */
mig_internal void _Xproc_mark_exec
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_exec
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_exec(process);
	end_using_proc(process);
}

/* Routine proc_mark_traced */
mig_internal void _Xproc_mark_traced
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_traced
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_traced(process);
	end_using_proc(process);
}

/* Routine proc_mod_stopchild */
mig_internal void _Xproc_mod_stopchild
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t doitType;
		int doit;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mod_stopchild
		(pstruct_t process, int doit);

	const mach_msg_type_t doitCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->doitType, &doitCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mod_stopchild(process, In0P->doit);
	end_using_proc(process);
}

/* Routine proc_pid2task */
mig_internal void _Xproc_pid2task
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t taskType;
		mach_port_t task;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_pid2task
		(pstruct_t process, pid_t pid, mach_port_t *task);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t taskType = {
		/* msgt_name = */		19,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_pid2task(process, In0P->pid, &OutP->task);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 40;

	OutP->taskType = taskType;
}

/* Routine proc_task2pid */
mig_internal void _Xproc_task2pid
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t taskType;
		mach_port_t task;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t pidType;
		pid_t pid;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_task2pid
		(pstruct_t process, mach_port_t task, pid_t *pid);

	const mach_msg_type_t taskCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pidType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->taskType, &taskCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_task2pid(process, In0P->task, &OutP->pid);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->pidType = pidType;
}

/* Routine proc_task2proc */
mig_internal void _Xproc_task2proc
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t taskType;
		mach_port_t task;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t procType;
		mach_port_t proc;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_task2proc
		(pstruct_t process, mach_port_t task, mach_port_t *proc);

	const mach_msg_type_t taskCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t procType = {
		/* msgt_name = */		20,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->taskType, &taskCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_task2proc(process, In0P->task, &OutP->proc);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 40;

	OutP->procType = procType;
}

/* Routine proc_proc2task */
mig_internal void _Xproc_proc2task
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t taskType;
		mach_port_t task;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_proc2task
		(pstruct_t process, mach_port_t *task);

	const mach_msg_type_t taskType = {
		/* msgt_name = */		19,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_proc2task(process, &OutP->task);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 40;

	OutP->taskType = taskType;
}

/* Routine proc_pid2proc */
mig_internal void _Xproc_pid2proc
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t procType;
		mach_port_t proc;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_pid2proc
		(pstruct_t process, pid_t pid, mach_port_t *proc);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t procType = {
		/* msgt_name = */		20,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_pid2proc(process, In0P->pid, &OutP->proc);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = 40;

	OutP->procType = procType;
}

/* Routine proc_getprocinfo */
mig_internal void _Xproc_getprocinfo
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t whichType;
		pid_t which;
		mach_msg_type_t flagsType;
		int flags;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t flagsType;
		int flags;
		mach_msg_type_long_t procinfoType;
		int procinfo[512];
		mach_msg_type_long_t threadwaitsType;
		char threadwaits[2048];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getprocinfo
		(pstruct_t process, pid_t which, int *flags, procinfo_t *procinfo, mach_msg_type_number_t *procinfoCnt, data_t *threadwaits, mach_msg_type_number_t *threadwaitsCnt);

	boolean_t msgh_simple;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;

	const mach_msg_type_t whichCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t flagsCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t flagsType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t procinfoType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	const mach_msg_type_long_t threadwaitsType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	8,
		/* msgtl_size = */	8,
		/* msgtl_number = */	2048,
	};

	pstruct_t process;
	mach_msg_type_number_t procinfoCnt;
	char threadwaits[2048];
	mach_msg_type_number_t threadwaitsCnt;

	int *procinfoP;
	char *threadwaitsP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->whichType, &whichCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->flagsType, &flagsCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	procinfoP = OutP->procinfo;
	procinfoCnt = 512;

	threadwaitsP = threadwaits;
	threadwaitsCnt = 2048;

	OutP->RetCode = S_proc_getprocinfo(process, In0P->which, &In0P->flags, &procinfoP, &procinfoCnt, &threadwaitsP, &threadwaitsCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->flagsType = flagsType;

	OutP->flags = In0P->flags;

	OutP->procinfoType = procinfoType;
	if (procinfoP != OutP->procinfo) {
		OutP->procinfoType.msgtl_header.msgt_inline = FALSE;
		OutP->procinfoType.msgtl_header.msgt_deallocate = TRUE;
		*((int **)OutP->procinfo) = procinfoP;
		msgh_simple = FALSE;
	}

	OutP->procinfoType.msgtl_number = procinfoCnt;
	msgh_size_delta = (OutP->procinfoType.msgtl_header.msgt_inline) ? 4 * procinfoCnt : sizeof(int *);
	msgh_size = 64 + msgh_size_delta;
	OutP = (Reply *) ((char *) OutP + msgh_size_delta - 2048);

	OutP->threadwaitsType = threadwaitsType;

	if (threadwaitsP != threadwaits) {
		OutP->threadwaitsType.msgtl_header.msgt_inline = FALSE;
		OutP->threadwaitsType.msgtl_header.msgt_deallocate = TRUE;
		*((char **)OutP->threadwaits) = threadwaitsP;
		msgh_simple = FALSE;
	}
	else {
		memcpy(OutP->threadwaits, threadwaits, threadwaitsCnt);
	}

	OutP->threadwaitsType.msgtl_number = threadwaitsCnt;
	msgh_size += (OutP->threadwaitsType.msgtl_header.msgt_inline) ? (threadwaitsCnt + 3) & ~3 : sizeof(char *);

	OutP = (Reply *) OutHeadP;
	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
	OutP->Head.msgh_size = msgh_size;
}

/* Routine proc_getprocargs */
mig_internal void _Xproc_getprocargs
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t whichType;
		pid_t which;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t procargsType;
		char procargs[2048];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getprocargs
		(pstruct_t process, pid_t which, data_t *procargs, mach_msg_type_number_t *procargsCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t whichCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t procargsType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	8,
		/* msgtl_size = */	8,
		/* msgtl_number = */	2048,
	};

	pstruct_t process;
	mach_msg_type_number_t procargsCnt;

	char *procargsP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->whichType, &whichCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	procargsP = OutP->procargs;
	procargsCnt = 2048;

	OutP->RetCode = S_proc_getprocargs(process, In0P->which, &procargsP, &procargsCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->procargsType = procargsType;
	if (procargsP != OutP->procargs) {
		OutP->procargsType.msgtl_header.msgt_inline = FALSE;
		OutP->procargsType.msgtl_header.msgt_deallocate = TRUE;
		*((char **)OutP->procargs) = procargsP;
		msgh_simple = FALSE;
	}

	OutP->procargsType.msgtl_number = procargsCnt;
	OutP->Head.msgh_size = 44 + ((OutP->procargsType.msgtl_header.msgt_inline) ? (procargsCnt + 3) & ~3 : sizeof(char *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_getprocenv */
mig_internal void _Xproc_getprocenv
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t whichType;
		pid_t which;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t procenvType;
		char procenv[2048];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getprocenv
		(pstruct_t process, pid_t which, data_t *procenv, mach_msg_type_number_t *procenvCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t whichCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t procenvType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	8,
		/* msgtl_size = */	8,
		/* msgtl_number = */	2048,
	};

	pstruct_t process;
	mach_msg_type_number_t procenvCnt;

	char *procenvP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->whichType, &whichCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	procenvP = OutP->procenv;
	procenvCnt = 2048;

	OutP->RetCode = S_proc_getprocenv(process, In0P->which, &procenvP, &procenvCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->procenvType = procenvType;
	if (procenvP != OutP->procenv) {
		OutP->procenvType.msgtl_header.msgt_inline = FALSE;
		OutP->procenvType.msgtl_header.msgt_deallocate = TRUE;
		*((char **)OutP->procenv) = procenvP;
		msgh_simple = FALSE;
	}

	OutP->procenvType.msgtl_number = procenvCnt;
	OutP->Head.msgh_size = 44 + ((OutP->procenvType.msgtl_header.msgt_inline) ? (procenvCnt + 3) & ~3 : sizeof(char *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_make_login_coll */
mig_internal void _Xproc_make_login_coll
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_make_login_coll
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_make_login_coll(process);
	end_using_proc(process);
}

/* Routine proc_getloginid */
mig_internal void _Xproc_getloginid
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t login_idType;
		pid_t login_id;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getloginid
		(pstruct_t process, pid_t pid, pid_t *login_id);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t login_idType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getloginid(process, In0P->pid, &OutP->login_id);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->login_idType = login_idType;
}

/* Routine proc_getloginpids */
mig_internal void _Xproc_getloginpids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t idType;
		pid_t id;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t pidsType;
		pid_t pids[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getloginpids
		(pstruct_t process, pid_t id, pidarray_t *pids, mach_msg_type_number_t *pidsCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t idCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t pidsType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_number_t pidsCnt;

	pid_t *pidsP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->idType, &idCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	pidsP = OutP->pids;
	pidsCnt = 512;

	OutP->RetCode = S_proc_getloginpids(process, In0P->id, &pidsP, &pidsCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->pidsType = pidsType;
	if (pidsP != OutP->pids) {
		OutP->pidsType.msgtl_header.msgt_inline = FALSE;
		OutP->pidsType.msgtl_header.msgt_deallocate = TRUE;
		*((pid_t **)OutP->pids) = pidsP;
		msgh_simple = FALSE;
	}

	OutP->pidsType.msgtl_number = pidsCnt;
	OutP->Head.msgh_size = 44 + ((OutP->pidsType.msgtl_header.msgt_inline) ? 4 * pidsCnt : sizeof(pid_t *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_setlogin */
mig_internal void _Xproc_setlogin
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t lognameType;
		string_t logname;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setlogin
		(pstruct_t process, string_t logname);

	const mach_msg_type_t lognameCheck = {
		/* msgt_name = */		MACH_MSG_TYPE_STRING_C,
		/* msgt_size = */		8,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 1052) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->lognameType, &lognameCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_setlogin(process, In0P->logname);
	end_using_proc(process);
}

/* Routine proc_getlogin */
mig_internal void _Xproc_getlogin
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t lognameType;
		string_t logname;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getlogin
		(pstruct_t process, string_t logname);

	const mach_msg_type_t lognameType = {
		/* msgt_name = */		MACH_MSG_TYPE_STRING_C,
		/* msgt_size = */		8,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getlogin(process, OutP->logname);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 1060;

	OutP->lognameType = lognameType;
}

/* Routine proc_setsid */
mig_internal void _Xproc_setsid
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setsid
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_setsid(process);
	end_using_proc(process);
}

/* Routine proc_getsid */
mig_internal void _Xproc_getsid
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t sidType;
		pid_t sid;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getsid
		(pstruct_t process, pid_t pid, pid_t *sid);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t sidType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getsid(process, In0P->pid, &OutP->sid);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->sidType = sidType;
}

/* Routine proc_getsessionpgids */
mig_internal void _Xproc_getsessionpgids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t sidType;
		pid_t sid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t pgidsetType;
		pid_t pgidset[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getsessionpgids
		(pstruct_t process, pid_t sid, pidarray_t *pgidset, mach_msg_type_number_t *pgidsetCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t sidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t pgidsetType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_number_t pgidsetCnt;

	pid_t *pgidsetP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->sidType, &sidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	pgidsetP = OutP->pgidset;
	pgidsetCnt = 512;

	OutP->RetCode = S_proc_getsessionpgids(process, In0P->sid, &pgidsetP, &pgidsetCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->pgidsetType = pgidsetType;
	if (pgidsetP != OutP->pgidset) {
		OutP->pgidsetType.msgtl_header.msgt_inline = FALSE;
		OutP->pgidsetType.msgtl_header.msgt_deallocate = TRUE;
		*((pid_t **)OutP->pgidset) = pgidsetP;
		msgh_simple = FALSE;
	}

	OutP->pgidsetType.msgtl_number = pgidsetCnt;
	OutP->Head.msgh_size = 44 + ((OutP->pgidsetType.msgtl_header.msgt_inline) ? 4 * pgidsetCnt : sizeof(pid_t *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_getsessionpids */
mig_internal void _Xproc_getsessionpids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t sidType;
		pid_t sid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t pidsetType;
		pid_t pidset[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getsessionpids
		(pstruct_t process, pid_t sid, pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t sidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t pidsetType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_number_t pidsetCnt;

	pid_t *pidsetP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->sidType, &sidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	pidsetP = OutP->pidset;
	pidsetCnt = 512;

	OutP->RetCode = S_proc_getsessionpids(process, In0P->sid, &pidsetP, &pidsetCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->pidsetType = pidsetType;
	if (pidsetP != OutP->pidset) {
		OutP->pidsetType.msgtl_header.msgt_inline = FALSE;
		OutP->pidsetType.msgtl_header.msgt_deallocate = TRUE;
		*((pid_t **)OutP->pidset) = pidsetP;
		msgh_simple = FALSE;
	}

	OutP->pidsetType.msgtl_number = pidsetCnt;
	OutP->Head.msgh_size = 44 + ((OutP->pidsetType.msgtl_header.msgt_inline) ? 4 * pidsetCnt : sizeof(pid_t *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_getsidport */
mig_internal void _Xproc_getsidport
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t sessportType;
		mach_port_t sessport;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getsidport
		(pstruct_t process, mach_port_t *sessport, mach_msg_type_name_t *sessportPoly);

	boolean_t msgh_simple;
	const mach_msg_type_t sessportType = {
		/* msgt_name = */		-1,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;
	mach_msg_type_name_t sessportPoly;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getsidport(process, &OutP->sessport, &sessportPoly);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;
	OutP->Head.msgh_size = 40;

	OutP->sessportType = sessportType;

	if (MACH_MSG_TYPE_PORT_ANY(sessportPoly))
		msgh_simple = FALSE;

	OutP->sessportType.msgt_name = sessportPoly;

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_setpgrp */
mig_internal void _Xproc_setpgrp
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
		mach_msg_type_t pgrpType;
		pid_t pgrp;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_setpgrp
		(pstruct_t process, pid_t pid, pid_t pgrp);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pgrpCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pgrpType, &pgrpCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_setpgrp(process, In0P->pid, In0P->pgrp);
	end_using_proc(process);
}

/* Routine proc_getpgrp */
mig_internal void _Xproc_getpgrp
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t pgrpType;
		pid_t pgrp;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getpgrp
		(pstruct_t process, pid_t pid, pid_t *pgrp);

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pgrpType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getpgrp(process, In0P->pid, &OutP->pgrp);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->pgrpType = pgrpType;
}

/* Routine proc_getpgrppids */
mig_internal void _Xproc_getpgrppids
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t pgrpType;
		pid_t pgrp;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_long_t pidsetType;
		pid_t pidset[512];
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getpgrppids
		(pstruct_t process, pid_t pgrp, pidarray_t *pidset, mach_msg_type_number_t *pidsetCnt);

	boolean_t msgh_simple;
	const mach_msg_type_t pgrpCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_long_t pidsetType = {
	{
		/* msgt_name = */		0,
		/* msgt_size = */		0,
		/* msgt_number = */		0,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		TRUE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	},
		/* msgtl_name = */	2,
		/* msgtl_size = */	32,
		/* msgtl_number = */	512,
	};

	pstruct_t process;
	mach_msg_type_number_t pidsetCnt;

	pid_t *pidsetP;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pgrpType, &pgrpCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	pidsetP = OutP->pidset;
	pidsetCnt = 512;

	OutP->RetCode = S_proc_getpgrppids(process, In0P->pgrp, &pidsetP, &pidsetCnt);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;

	OutP->pidsetType = pidsetType;
	if (pidsetP != OutP->pidset) {
		OutP->pidsetType.msgtl_header.msgt_inline = FALSE;
		OutP->pidsetType.msgtl_header.msgt_deallocate = TRUE;
		*((pid_t **)OutP->pidset) = pidsetP;
		msgh_simple = FALSE;
	}

	OutP->pidsetType.msgtl_number = pidsetCnt;
	OutP->Head.msgh_size = 44 + ((OutP->pidsetType.msgtl_header.msgt_inline) ? 4 * pidsetCnt : sizeof(pid_t *));

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_get_tty */
mig_internal void _Xproc_get_tty
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t target_processType;
		pid_t target_process;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t ttyType;
		mach_port_t tty;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_get_tty
		(pstruct_t calling_process, pid_t target_process, mach_port_t *tty, mach_msg_type_name_t *ttyPoly);

	boolean_t msgh_simple;
	const mach_msg_type_t target_processCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t ttyType = {
		/* msgt_name = */		-1,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t calling_process;
	mach_msg_type_name_t ttyPoly;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->target_processType, &target_processCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		calling_process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		calling_process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_get_tty(calling_process, In0P->target_process, &OutP->tty, &ttyPoly);
	end_using_proc(calling_process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;
	OutP->Head.msgh_size = 40;

	OutP->ttyType = ttyType;

	if (MACH_MSG_TYPE_PORT_ANY(ttyPoly))
		msgh_simple = FALSE;

	OutP->ttyType.msgt_name = ttyPoly;

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_getnports */
mig_internal void _Xproc_getnports
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t whichType;
		pid_t which;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t nportsType;
		mach_msg_type_number_t nports;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_getnports
		(pstruct_t process, pid_t which, mach_msg_type_number_t *nports);

	const mach_msg_type_t whichCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t nportsType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->whichType, &whichCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_getnports(process, In0P->which, &OutP->nports);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->nportsType = nportsType;
}

/* Routine proc_set_init_task */
mig_internal void _Xproc_set_init_task
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t taskType;
		mach_port_t task;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_set_init_task
		(pstruct_t process, mach_port_t task);

	const mach_msg_type_t taskCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->taskType, &taskCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_set_init_task(process, In0P->task);
	end_using_proc(process);
}

/* Routine proc_mark_important */
mig_internal void _Xproc_mark_important
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_mark_important
		(pstruct_t process);

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_mark_important(process);
	end_using_proc(process);
}

/* Routine proc_is_important */
mig_internal void _Xproc_is_important
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t essentialType;
		boolean_t essential;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_is_important
		(pstruct_t process, boolean_t *essential);

	const mach_msg_type_t essentialType = {
		/* msgt_name = */		0,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_is_important(process, &OutP->essential);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->essentialType = essentialType;
}

/* Routine proc_set_code */
mig_internal void _Xproc_set_code
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t start_codeType;
		vm_address_t start_code;
		mach_msg_type_t end_codeType;
		vm_address_t end_code;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_set_code
		(pstruct_t process, vm_address_t start_code, vm_address_t end_code);

	const mach_msg_type_t start_codeCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t end_codeCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->start_codeType, &start_codeCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->end_codeType, &end_codeCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_set_code(process, In0P->start_code, In0P->end_code);
	end_using_proc(process);
}

/* Routine proc_get_code */
mig_internal void _Xproc_get_code
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t start_codeType;
		vm_address_t start_code;
		mach_msg_type_t end_codeType;
		vm_address_t end_code;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_get_code
		(pstruct_t process, vm_address_t *start_code, vm_address_t *end_code);

	const mach_msg_type_t start_codeType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t end_codeType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 24) ||
	    (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_get_code(process, &OutP->start_code, &OutP->end_code);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 48;

	OutP->start_codeType = start_codeType;

	OutP->end_codeType = end_codeType;
}

/* Routine proc_make_task_namespace */
mig_internal void _Xproc_make_task_namespace
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t notifyType;
		mach_port_t notify;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_make_task_namespace
		(pstruct_t process, mach_port_t notify);

	const mach_msg_type_t notifyCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 32) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->notifyType, &notifyCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_make_task_namespace(process, In0P->notify);
	end_using_proc(process);
}

/* Routine proc_user_identify */
mig_internal void _Xproc_user_identify
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t rendezvousType;
		mach_port_t rendezvous;
		mach_msg_type_t pidType;
		pid_t pid;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t newportType;
		mach_port_t newport;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_user_identify
		(pstruct_t process, mach_port_t rendezvous, mach_port_t *newport, mach_msg_type_name_t *newportPoly, pid_t pid);

	boolean_t msgh_simple;
	const mach_msg_type_t rendezvousCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pidCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t newportType = {
		/* msgt_name = */		-1,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;
	mach_msg_type_name_t newportPoly;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->rendezvousType, &rendezvousCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->pidType, &pidCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_user_identify(process, In0P->rendezvous, &OutP->newport, &newportPoly, In0P->pid);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	msgh_simple = TRUE;
	OutP->Head.msgh_size = 40;

	OutP->newportType = newportType;

	if (MACH_MSG_TYPE_PORT_ANY(newportPoly))
		msgh_simple = FALSE;

	OutP->newportType.msgt_name = newportPoly;

	if (!msgh_simple)
		OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
}

/* Routine proc_server_identify */
mig_internal void _Xproc_server_identify
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t rendezvousType;
		mach_port_t rendezvous;
		mach_msg_type_t newportType;
		mach_port_t newport;
	} Request;

	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t RetCodeType;
		kern_return_t RetCode;
		mach_msg_type_t pidType;
		pid_t pid;
	} Reply;

	Request *In0P = (Request *) InHeadP;
	Reply *OutP = (Reply *) OutHeadP;
	mig_external kern_return_t S_proc_server_identify
		(pstruct_t process, mach_port_t rendezvous, mach_port_t newport, mach_msg_type_name_t newportPoly, pid_t *pid);

	const mach_msg_type_t rendezvousCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t pidType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	pstruct_t process;

#if	TypeCheck
	if ((In0P->Head.msgh_size != 40) ||
	    !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK(&In0P->rendezvousType, &rendezvousCheck))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

#if	TypeCheck
	if ((In0P->newportType.msgt_inline != TRUE) ||
	    (In0P->newportType.msgt_longform != FALSE) ||
	    (In0P->newportType.msgt_number != 1) ||
	    (In0P->newportType.msgt_size != 32))
		{ OutP->RetCode = MIG_BAD_ARGUMENTS; return; }
#endif	/* TypeCheck */

	if (MACH_MSGH_BITS_LOCAL (In0P->Head.msgh_bits) == MACH_MSG_TYPE_PROTECTED_PAYLOAD)
		process = begin_using_proc_payload(In0P->Head.msgh_protected_payload);
	else
		process = begin_using_proc_port(In0P->Head.msgh_request_port);

	OutP->RetCode = S_proc_server_identify(process, In0P->rendezvous, In0P->newport, In0P->newportType.msgt_name, &OutP->pid);
	end_using_proc(process);
	if (OutP->RetCode != KERN_SUCCESS)
		return;

	OutP->Head.msgh_size = 40;

	OutP->pidType = pidType;
}

mig_routine_t process_server_routines[] = {
		0,
		0,
		0,
		0,
		_Xproc_getprivports,
		_Xproc_getallpids,
		_Xproc_setexecdata,
		_Xproc_getexecdata,
		_Xproc_execdata_notify,
		_Xproc_uname,
		_Xproc_register_version,
		_Xproc_reauthenticate,
		_Xproc_child,
		_Xproc_setmsgport,
		_Xproc_reassign,
		_Xproc_setowner,
		_Xproc_getpids,
		_Xproc_set_arg_locations,
		_Xproc_get_arg_locations,
		_Xproc_getmsgport,
		_Xproc_wait,
		_Xproc_dostop,
		_Xproc_handle_exceptions,
		_Xproc_mark_stop,
		_Xproc_mark_cont,
		_Xproc_mark_exit,
		_Xproc_mark_exec,
		_Xproc_mark_traced,
		_Xproc_mod_stopchild,
		_Xproc_pid2task,
		_Xproc_task2pid,
		_Xproc_task2proc,
		_Xproc_proc2task,
		_Xproc_pid2proc,
		_Xproc_getprocinfo,
		_Xproc_getprocargs,
		_Xproc_getprocenv,
		_Xproc_make_login_coll,
		_Xproc_getloginid,
		_Xproc_getloginpids,
		_Xproc_setlogin,
		_Xproc_getlogin,
		_Xproc_setsid,
		_Xproc_getsid,
		_Xproc_getsessionpgids,
		_Xproc_getsessionpids,
		_Xproc_getsidport,
		_Xproc_setpgrp,
		_Xproc_getpgrp,
		_Xproc_getpgrppids,
		_Xproc_get_tty,
		_Xproc_getnports,
		_Xproc_set_init_task,
		_Xproc_mark_important,
		_Xproc_is_important,
		_Xproc_set_code,
		_Xproc_get_code,
		_Xproc_make_task_namespace,
		_Xproc_user_identify,
		_Xproc_server_identify,
};

mig_external boolean_t process_server
	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
	mach_msg_header_t *InP =  InHeadP;
	mig_reply_header_t *OutP = (mig_reply_header_t *) OutHeadP;

	const mach_msg_type_t RetCodeType = {
		/* msgt_name = */		MACH_MSG_TYPE_INTEGER_32,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	mig_routine_t routine;

	OutP->Head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InP->msgh_bits), 0);
	OutP->Head.msgh_size = sizeof *OutP;
	OutP->Head.msgh_remote_port = InP->msgh_reply_port;
	OutP->Head.msgh_local_port = MACH_PORT_NULL;
	OutP->Head.msgh_seqno = 0;
	OutP->Head.msgh_id = InP->msgh_id + 100;

	OutP->RetCodeType = RetCodeType;

	if ((InP->msgh_id > 24059) || (InP->msgh_id < 24000) ||
	    ((routine = process_server_routines[InP->msgh_id - 24000]) == 0)) {
		OutP->RetCode = MIG_BAD_ID;
		return FALSE;
	}
	(*routine) (InP, &OutP->Head);
	return TRUE;
}

mig_external mig_routine_t process_server_routine
	(const mach_msg_header_t *InHeadP)
{
	int msgh_id;

	msgh_id = InHeadP->msgh_id - 24000;

	if ((msgh_id > 59) || (msgh_id < 0))
		return 0;

	return process_server_routines[msgh_id];
}