#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif

#include "process_U.h"
#define EXPORT_BOOLEAN
#include <mach/boolean.h>
#include <mach/kern_return.h>
#include <mach/message.h>
#include <mach/notify.h>
#include <mach/mach_types.h>
#include <mach/mig_errors.h>
#include <mach/mig_support.h>
#include <mach/msg_type.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_remote_port
#define msgh_reply_port		msgh_local_port

#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>

/* Routine proc_getprivports */
mig_external kern_return_t proc_getprivports
(
	process_t process,
	mach_port_t *host_priv,
	mach_port_t *device_master
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	const mach_msg_type_t host_privCheck = {
		/* 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 device_masterCheck = {
		/* msgt_name = */		17,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24004;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24104) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 48) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->host_privType, &host_privCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*host_priv = OutP->host_priv;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->device_masterType, &device_masterCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*device_master = OutP->device_master;

	return KERN_SUCCESS;
}

/* Routine proc_getallpids */
mig_external kern_return_t proc_getallpids
(
	process_t process,
	pidarray_t *pidarray,
	mach_msg_type_number_t *pidarrayCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24005;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24105) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->pidarrayType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->pidarrayType.msgtl_name != 2) ||
	    (OutP->pidarrayType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->pidarrayType.msgtl_header.msgt_inline) ? 4 * OutP->pidarrayType.msgtl_number : sizeof(pid_t *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->pidarrayType.msgtl_header.msgt_inline)
	    *pidarray = *((pid_t **)OutP->pidarray);
	else if (OutP->pidarrayType.msgtl_number > *pidarrayCnt) {
	    __mig_allocate((vm_offset_t *)pidarray,
		4 * OutP->pidarrayType.msgtl_number);
	    memcpy(*pidarray, OutP->pidarray, 4 * OutP->pidarrayType.msgtl_number);
	}
	else {
	    memcpy(*pidarray, OutP->pidarray, 4 * OutP->pidarrayType.msgtl_number);
	}

	*pidarrayCnt = OutP->pidarrayType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_setexecdata */
mig_external kern_return_t proc_setexecdata
(
	process_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
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	boolean_t msgh_simple = TRUE;
	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,
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->portsType = portsType;

	if (portsCnt > 512) {
		InP->portsType.msgtl_header.msgt_inline = FALSE;
		*((mach_port_t **)InP->ports) = ports;
		msgh_simple = FALSE;
	}
	else {
		memcpy(InP->ports, ports, 4 * portsCnt);
	}

	if (MACH_MSG_TYPE_PORT_ANY(portsPoly))
		msgh_simple = FALSE;

	InP->portsType.msgtl_name = portsPoly;

	InP->portsType.msgtl_number = portsCnt;

	msgh_size_delta = (InP->portsType.msgtl_header.msgt_inline) ? 4 * portsCnt : sizeof(mach_port_t *);
	msgh_size = 48 + msgh_size_delta;
	InP = (Request *) ((char *) InP + msgh_size_delta - 2048);
	InP->intsType = intsType;

	if (intsCnt > 512) {
		InP->intsType.msgtl_header.msgt_inline = FALSE;
		*((int **)InP->ints) = ints;
		msgh_simple = FALSE;
	}
	else {
		memcpy(InP->ints, ints, 4 * intsCnt);
	}

	InP->intsType.msgtl_number = intsCnt;

	msgh_size += (InP->intsType.msgtl_header.msgt_inline) ? 4 * intsCnt : sizeof(int *);
	InP = &Mess.In;
	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24006;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24106) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getexecdata */
mig_external kern_return_t proc_getexecdata
(
	process_t process,
	portarray_t *ports,
	mach_msg_type_number_t *portsCnt,
	intarray_t *ints,
	mach_msg_type_number_t *intsCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */
	unsigned int msgh_size_delta;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24007;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24107) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 56) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

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

	msgh_size_delta = (OutP->portsType.msgtl_header.msgt_inline) ? 4 * OutP->portsType.msgtl_number : sizeof(mach_port_t *);
#if	TypeCheck
	if (msgh_size < 56 + msgh_size_delta)
		return MIG_TYPE_ERROR;
	msgh_size -= msgh_size_delta;
#endif	/* TypeCheck */

	if (!OutP->portsType.msgtl_header.msgt_inline)
	    *ports = *((mach_port_t **)OutP->ports);
	else if (OutP->portsType.msgtl_number > *portsCnt) {
	    __mig_allocate((vm_offset_t *)ports,
		4 * OutP->portsType.msgtl_number);
	    memcpy(*ports, OutP->ports, 4 * OutP->portsType.msgtl_number);
	}
	else {
	    memcpy(*ports, OutP->ports, 4 * OutP->portsType.msgtl_number);
	}

	*portsCnt = OutP->portsType.msgtl_number;

	OutP = (Reply *) ((char *) OutP + msgh_size_delta - 2048);

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

#if	TypeCheck
	if (msgh_size != 56 + ((OutP->intsType.msgtl_header.msgt_inline) ? 4 * OutP->intsType.msgtl_number : sizeof(int *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->intsType.msgtl_header.msgt_inline)
	    *ints = *((int **)OutP->ints);
	else if (OutP->intsType.msgtl_number > *intsCnt) {
	    __mig_allocate((vm_offset_t *)ints,
		4 * OutP->intsType.msgtl_number);
	    memcpy(*ints, OutP->ints, 4 * OutP->intsType.msgtl_number);
	}
	else {
	    memcpy(*ints, OutP->ints, 4 * OutP->intsType.msgtl_number);
	}

	*intsCnt = OutP->intsType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_execdata_notify */
mig_external kern_return_t proc_execdata_notify
(
	process_t process,
	mach_port_t notify,
	mach_msg_type_name_t notifyPoly
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	boolean_t msgh_simple = TRUE;

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

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->notifyType = notifyType;

	InP->notify = notify;

	if (MACH_MSG_TYPE_PORT_ANY(notifyPoly))
		msgh_simple = FALSE;

	InP->notifyType.msgt_name = notifyPoly;

	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24008;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24108) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_uname */
mig_external kern_return_t proc_uname
(
	process_t process,
	utsname_t *uname
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24009;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24109) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 5164) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->unameType.msgtl_header.msgt_inline != TRUE) ||
	    (OutP->unameType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->unameType.msgtl_name != 8) ||
	    (OutP->unameType.msgtl_number != 5120) ||
	    (OutP->unameType.msgtl_size != 8))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*uname = OutP->uname;

	return KERN_SUCCESS;
}

/* Routine proc_register_version */
mig_external kern_return_t proc_register_version
(
	process_t process,
	mach_port_t credential,
	string_t name,
	string_t release,
	string_t version
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t credentialType = {
		/* 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 nameType = {
		/* 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 releaseType = {
		/* 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 versionType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->credentialType = credentialType;

	InP->credential = credential;

	InP->nameType = nameType;

	(void) __mig_strncpy(InP->name, name, 1024);

	InP->releaseType = releaseType;

	(void) __mig_strncpy(InP->release, release, 1024);

	InP->versionType = versionType;

	(void) __mig_strncpy(InP->version, version, 1024);

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24010;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 3116, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24110) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* SimpleRoutine proc_reauthenticate */
mig_external kern_return_t proc_reauthenticate
(
	process_t process,
	mach_port_t rendezvous2,
	mach_msg_type_name_t rendezvous2Poly
)
{
	typedef struct {
		mach_msg_header_t Head;
		mach_msg_type_t rendezvous2Type;
		mach_port_t rendezvous2;
	} Request;

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	boolean_t msgh_simple = TRUE;

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

	InP->rendezvous2Type = rendezvous2Type;

	InP->rendezvous2 = rendezvous2;

	if (MACH_MSG_TYPE_PORT_ANY(rendezvous2Poly))
		msgh_simple = FALSE;

	InP->rendezvous2Type.msgt_name = rendezvous2Poly;

	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, 0) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, 0));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24011;

	return __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, 32, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
}

/* Routine proc_child */
mig_external kern_return_t proc_child
(
	process_t process,
	mach_port_t child
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t childType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->childType = childType;

	InP->child = child;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24012;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24112) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_setmsgport */
mig_external kern_return_t proc_setmsgport
(
	process_t process,
	mach_port_t newmsgport,
	mach_port_t *oldmsgport
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t newmsgportType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

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

	InP->newmsgportType = newmsgportType;

	InP->newmsgport = newmsgport;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24013;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24113) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->oldmsgportType, &oldmsgportCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*oldmsgport = OutP->oldmsgport;

	return KERN_SUCCESS;
}

/* Routine proc_reassign */
mig_external kern_return_t proc_reassign
(
	process_t process,
	mach_port_t newtask
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t newtaskType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->newtaskType = newtaskType;

	InP->newtask = newtask;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24014;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24114) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_setowner */
mig_external kern_return_t proc_setowner
(
	process_t process,
	uid_t owner,
	int clear
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t ownerType = {
		/* 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 clearType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->ownerType = ownerType;

	InP->owner = owner;

	InP->clearType = clearType;

	InP->clear = clear;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24015;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24115) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getpids */
mig_external kern_return_t proc_getpids
(
	process_t process,
	pid_t *pid,
	pid_t *ppid,
	int *orphaned
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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 ppidCheck = {
		/* 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 orphanedCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24016;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24116) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 56) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->pidType, &pidCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*pid = OutP->pid;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->ppidType, &ppidCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*ppid = OutP->ppid;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->orphanedType, &orphanedCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*orphaned = OutP->orphaned;

	return KERN_SUCCESS;
}

/* Routine proc_set_arg_locations */
mig_external kern_return_t proc_set_arg_locations
(
	process_t process,
	vm_address_t argv,
	vm_address_t envp
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->argvType = argvType;

	InP->argv = argv;

	InP->envpType = envpType;

	InP->envp = envp;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24017;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24117) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_get_arg_locations */
mig_external kern_return_t proc_get_arg_locations
(
	process_t process,
	vm_address_t *argv,
	vm_address_t *envp
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24018;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24118) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 48) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->argvType, &argvCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*argv = OutP->argv;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->envpType, &envpCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*envp = OutP->envp;

	return KERN_SUCCESS;
}

/* Routine proc_getmsgport */
mig_external kern_return_t proc_getmsgport
(
	process_t process,
	pid_t pid,
	mach_port_t *msgport
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

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

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24019;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24119) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->msgportType, &msgportCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*msgport = OutP->msgport;

	return KERN_SUCCESS;
}

/* Routine proc_wait */
mig_external kern_return_t proc_wait
(
	process_t process,
	pid_t pid,
	int options,
	int *status,
	int *sigcode,
	rusage_t *rusage,
	pid_t *pid_status
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 optionsType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	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
	};

	const mach_msg_type_t rusageCheck = {
		/* 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_statusCheck = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	InP->pidType = pidType;

	InP->pid = pid;

	InP->optionsType = optionsType;

	InP->options = options;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24020;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24120) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 132) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->statusType, &statusCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*status = OutP->status;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->sigcodeType, &sigcodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*sigcode = OutP->sigcode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->rusageType, &rusageCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*rusage = OutP->rusage;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->pid_statusType, &pid_statusCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*pid_status = OutP->pid_status;

	return KERN_SUCCESS;
}

/* Routine proc_dostop */
mig_external kern_return_t proc_dostop
(
	process_t process,
	mach_port_t contthread
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t contthreadType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->contthreadType = contthreadType;

	InP->contthread = contthread;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24021;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24121) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_handle_exceptions */
mig_external kern_return_t proc_handle_exceptions
(
	process_t process,
	mach_port_t msgport,
	mach_port_t forwardport,
	mach_msg_type_name_t forwardportPoly,
	int flavor,
	thread_state_t new_state,
	mach_msg_type_number_t new_stateCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

	const mach_msg_type_t msgportType = {
		/* 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 forwardportType = {
		/* msgt_name = */		-1,
		/* msgt_size = */		32,
		/* msgt_number = */		1,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t flavorType = {
		/* 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 new_stateType = {
		/* msgt_name = */		2,
		/* msgt_size = */		32,
		/* msgt_number = */		1024,
		/* msgt_inline = */		TRUE,
		/* msgt_longform = */		FALSE,
		/* msgt_deallocate = */		FALSE,
		/* msgt_unused = */		0
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->msgportType = msgportType;

	InP->msgport = msgport;

	InP->forwardportType = forwardportType;

	InP->forwardport = forwardport;

	InP->forwardportType.msgt_name = forwardportPoly;

	InP->flavorType = flavorType;

	InP->flavor = flavor;

	InP->new_stateType = new_stateType;

	if (new_stateCnt > 1024) {
		return MIG_ARRAY_TOO_LARGE;
	}
	else {
		memcpy(InP->new_state, new_state, 4 * new_stateCnt);
	}

	InP->new_stateType.msgt_number = new_stateCnt;

	msgh_size = 52 + (4 * new_stateCnt);
	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24022;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24122) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_stop */
mig_external kern_return_t proc_mark_stop
(
	process_t process,
	int signo,
	int sigcode
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t signoType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->signoType = signoType;

	InP->signo = signo;

	InP->sigcodeType = sigcodeType;

	InP->sigcode = sigcode;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24023;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24123) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_cont */
mig_external kern_return_t proc_mark_cont
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24024;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24124) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_exit */
mig_external kern_return_t proc_mark_exit
(
	process_t process,
	int status,
	int sigcode
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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 RetCodeCheck = {
		/* 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
	};

	InP->statusType = statusType;

	InP->status = status;

	InP->sigcodeType = sigcodeType;

	InP->sigcode = sigcode;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24025;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24125) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_exec */
mig_external kern_return_t proc_mark_exec
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24026;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24126) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_traced */
mig_external kern_return_t proc_mark_traced
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24027;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24127) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mod_stopchild */
mig_external kern_return_t proc_mod_stopchild
(
	process_t process,
	int doit
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t doitType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->doitType = doitType;

	InP->doit = doit;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24028;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24128) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_pid2task */
mig_external kern_return_t proc_pid2task
(
	process_t process,
	pid_t pid,
	mach_port_t *task
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24029;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24129) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->taskType, &taskCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*task = OutP->task;

	return KERN_SUCCESS;
}

/* Routine proc_task2pid */
mig_external kern_return_t proc_task2pid
(
	process_t process,
	mach_port_t task,
	pid_t *pid
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->taskType = taskType;

	InP->task = task;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24030;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24130) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->pidType, &pidCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*pid = OutP->pid;

	return KERN_SUCCESS;
}

/* Routine proc_task2proc */
mig_external kern_return_t proc_task2proc
(
	process_t process,
	mach_port_t task,
	mach_port_t *proc
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

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

	InP->taskType = taskType;

	InP->task = task;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24031;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24131) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->procType, &procCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*proc = OutP->proc;

	return KERN_SUCCESS;
}

/* Routine proc_proc2task */
mig_external kern_return_t proc_proc2task
(
	process_t process,
	mach_port_t *task
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24032;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24132) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->taskType, &taskCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*task = OutP->task;

	return KERN_SUCCESS;
}

/* Routine proc_pid2proc */
mig_external kern_return_t proc_pid2proc
(
	process_t process,
	pid_t pid,
	mach_port_t *proc
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

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

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24033;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24133) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->procType, &procCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*proc = OutP->proc;

	return KERN_SUCCESS;
}

/* Routine proc_getprocinfo */
mig_external kern_return_t proc_getprocinfo
(
	process_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
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */
	unsigned int msgh_size_delta;

	const mach_msg_type_t whichType = {
		/* 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_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->whichType = whichType;

	InP->which = which;

	InP->flagsType = flagsType;

	InP->flags = *flags;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24034;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24134) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 64)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->flagsType, &flagsCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*flags = OutP->flags;

#if	TypeCheck
	if ((OutP->procinfoType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->procinfoType.msgtl_name != 2) ||
	    (OutP->procinfoType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	msgh_size_delta = (OutP->procinfoType.msgtl_header.msgt_inline) ? 4 * OutP->procinfoType.msgtl_number : sizeof(int *);
#if	TypeCheck
	if (msgh_size < 64 + msgh_size_delta)
		return MIG_TYPE_ERROR;
	msgh_size -= msgh_size_delta;
#endif	/* TypeCheck */

	if (!OutP->procinfoType.msgtl_header.msgt_inline)
	    *procinfo = *((int **)OutP->procinfo);
	else if (OutP->procinfoType.msgtl_number > *procinfoCnt) {
	    __mig_allocate((vm_offset_t *)procinfo,
		4 * OutP->procinfoType.msgtl_number);
	    memcpy(*procinfo, OutP->procinfo, 4 * OutP->procinfoType.msgtl_number);
	}
	else {
	    memcpy(*procinfo, OutP->procinfo, 4 * OutP->procinfoType.msgtl_number);
	}

	*procinfoCnt = OutP->procinfoType.msgtl_number;

	OutP = (Reply *) ((char *) OutP + msgh_size_delta - 2048);

#if	TypeCheck
	if ((OutP->threadwaitsType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->threadwaitsType.msgtl_name != 8) ||
	    (OutP->threadwaitsType.msgtl_size != 8))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 64 + ((OutP->threadwaitsType.msgtl_header.msgt_inline) ? (OutP->threadwaitsType.msgtl_number + 3) & ~3 : sizeof(char *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->threadwaitsType.msgtl_header.msgt_inline)
	    *threadwaits = *((char **)OutP->threadwaits);
	else if (OutP->threadwaitsType.msgtl_number > *threadwaitsCnt) {
	    __mig_allocate((vm_offset_t *)threadwaits,
		OutP->threadwaitsType.msgtl_number);
	    memcpy(*threadwaits, OutP->threadwaits, OutP->threadwaitsType.msgtl_number);
	}
	else {
	    memcpy(*threadwaits, OutP->threadwaits, OutP->threadwaitsType.msgtl_number);
	}

	*threadwaitsCnt = OutP->threadwaitsType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_getprocargs */
mig_external kern_return_t proc_getprocargs
(
	process_t process,
	pid_t which,
	data_t *procargs,
	mach_msg_type_number_t *procargsCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t whichType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->whichType = whichType;

	InP->which = which;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24035;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24135) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->procargsType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->procargsType.msgtl_name != 8) ||
	    (OutP->procargsType.msgtl_size != 8))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->procargsType.msgtl_header.msgt_inline) ? (OutP->procargsType.msgtl_number + 3) & ~3 : sizeof(char *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->procargsType.msgtl_header.msgt_inline)
	    *procargs = *((char **)OutP->procargs);
	else if (OutP->procargsType.msgtl_number > *procargsCnt) {
	    __mig_allocate((vm_offset_t *)procargs,
		OutP->procargsType.msgtl_number);
	    memcpy(*procargs, OutP->procargs, OutP->procargsType.msgtl_number);
	}
	else {
	    memcpy(*procargs, OutP->procargs, OutP->procargsType.msgtl_number);
	}

	*procargsCnt = OutP->procargsType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_getprocenv */
mig_external kern_return_t proc_getprocenv
(
	process_t process,
	pid_t which,
	data_t *procenv,
	mach_msg_type_number_t *procenvCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t whichType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->whichType = whichType;

	InP->which = which;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24036;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24136) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->procenvType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->procenvType.msgtl_name != 8) ||
	    (OutP->procenvType.msgtl_size != 8))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->procenvType.msgtl_header.msgt_inline) ? (OutP->procenvType.msgtl_number + 3) & ~3 : sizeof(char *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->procenvType.msgtl_header.msgt_inline)
	    *procenv = *((char **)OutP->procenv);
	else if (OutP->procenvType.msgtl_number > *procenvCnt) {
	    __mig_allocate((vm_offset_t *)procenv,
		OutP->procenvType.msgtl_number);
	    memcpy(*procenv, OutP->procenv, OutP->procenvType.msgtl_number);
	}
	else {
	    memcpy(*procenv, OutP->procenv, OutP->procenvType.msgtl_number);
	}

	*procenvCnt = OutP->procenvType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_make_login_coll */
mig_external kern_return_t proc_make_login_coll
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24037;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24137) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getloginid */
mig_external kern_return_t proc_getloginid
(
	process_t process,
	pid_t pid,
	pid_t *login_id
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

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

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24038;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24138) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->login_idType, &login_idCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*login_id = OutP->login_id;

	return KERN_SUCCESS;
}

/* Routine proc_getloginpids */
mig_external kern_return_t proc_getloginpids
(
	process_t process,
	pid_t id,
	pidarray_t *pids,
	mach_msg_type_number_t *pidsCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t idType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->idType = idType;

	InP->id = id;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24039;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24139) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->pidsType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->pidsType.msgtl_name != 2) ||
	    (OutP->pidsType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->pidsType.msgtl_header.msgt_inline) ? 4 * OutP->pidsType.msgtl_number : sizeof(pid_t *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->pidsType.msgtl_header.msgt_inline)
	    *pids = *((pid_t **)OutP->pids);
	else if (OutP->pidsType.msgtl_number > *pidsCnt) {
	    __mig_allocate((vm_offset_t *)pids,
		4 * OutP->pidsType.msgtl_number);
	    memcpy(*pids, OutP->pids, 4 * OutP->pidsType.msgtl_number);
	}
	else {
	    memcpy(*pids, OutP->pids, 4 * OutP->pidsType.msgtl_number);
	}

	*pidsCnt = OutP->pidsType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_setlogin */
mig_external kern_return_t proc_setlogin
(
	process_t process,
	string_t logname
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->lognameType = lognameType;

	(void) __mig_strncpy(InP->logname, logname, 1024);

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24040;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 1052, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24140) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getlogin */
mig_external kern_return_t proc_getlogin
(
	process_t process,
	string_t logname
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24041;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24141) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 1060) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->lognameType, &lognameCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	(void) __mig_strncpy(logname, OutP->logname, 1024);

	return KERN_SUCCESS;
}

/* Routine proc_setsid */
mig_external kern_return_t proc_setsid
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24042;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24142) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getsid */
mig_external kern_return_t proc_getsid
(
	process_t process,
	pid_t pid,
	pid_t *sid
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24043;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24143) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->sidType, &sidCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*sid = OutP->sid;

	return KERN_SUCCESS;
}

/* Routine proc_getsessionpgids */
mig_external kern_return_t proc_getsessionpgids
(
	process_t process,
	pid_t sid,
	pidarray_t *pgidset,
	mach_msg_type_number_t *pgidsetCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->sidType = sidType;

	InP->sid = sid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24044;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24144) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->pgidsetType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->pgidsetType.msgtl_name != 2) ||
	    (OutP->pgidsetType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->pgidsetType.msgtl_header.msgt_inline) ? 4 * OutP->pgidsetType.msgtl_number : sizeof(pid_t *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->pgidsetType.msgtl_header.msgt_inline)
	    *pgidset = *((pid_t **)OutP->pgidset);
	else if (OutP->pgidsetType.msgtl_number > *pgidsetCnt) {
	    __mig_allocate((vm_offset_t *)pgidset,
		4 * OutP->pgidsetType.msgtl_number);
	    memcpy(*pgidset, OutP->pgidset, 4 * OutP->pgidsetType.msgtl_number);
	}
	else {
	    memcpy(*pgidset, OutP->pgidset, 4 * OutP->pgidsetType.msgtl_number);
	}

	*pgidsetCnt = OutP->pgidsetType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_getsessionpids */
mig_external kern_return_t proc_getsessionpids
(
	process_t process,
	pid_t sid,
	pidarray_t *pidset,
	mach_msg_type_number_t *pidsetCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->sidType = sidType;

	InP->sid = sid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24045;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24145) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->pidsetType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->pidsetType.msgtl_name != 2) ||
	    (OutP->pidsetType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->pidsetType.msgtl_header.msgt_inline) ? 4 * OutP->pidsetType.msgtl_number : sizeof(pid_t *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->pidsetType.msgtl_header.msgt_inline)
	    *pidset = *((pid_t **)OutP->pidset);
	else if (OutP->pidsetType.msgtl_number > *pidsetCnt) {
	    __mig_allocate((vm_offset_t *)pidset,
		4 * OutP->pidsetType.msgtl_number);
	    memcpy(*pidset, OutP->pidset, 4 * OutP->pidsetType.msgtl_number);
	}
	else {
	    memcpy(*pidset, OutP->pidset, 4 * OutP->pidsetType.msgtl_number);
	}

	*pidsetCnt = OutP->pidsetType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_getsidport */
mig_external kern_return_t proc_getsidport
(
	process_t process,
	mach_port_t *sessport
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

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

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24046;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24146) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->sessportType, &sessportCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*sessport = OutP->sessport;

	return KERN_SUCCESS;
}

/* Routine proc_setpgrp */
mig_external kern_return_t proc_setpgrp
(
	process_t process,
	pid_t pid,
	pid_t pgrp
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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 pgrpType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

	InP->pidType = pidType;

	InP->pid = pid;

	InP->pgrpType = pgrpType;

	InP->pgrp = pgrp;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24047;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24147) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_getpgrp */
mig_external kern_return_t proc_getpgrp
(
	process_t process,
	pid_t pid,
	pid_t *pgrp
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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 RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24048;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24148) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->pgrpType, &pgrpCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*pgrp = OutP->pgrp;

	return KERN_SUCCESS;
}

/* Routine proc_getpgrppids */
mig_external kern_return_t proc_getpgrppids
(
	process_t process,
	pid_t pgrp,
	pidarray_t *pidset,
	mach_msg_type_number_t *pidsetCnt
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->pgrpType = pgrpType;

	InP->pgrp = pgrp;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24049;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24149) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size < 44)) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if ((OutP->pidsetType.msgtl_header.msgt_longform != TRUE) ||
	    (OutP->pidsetType.msgtl_name != 2) ||
	    (OutP->pidsetType.msgtl_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (msgh_size != 44 + ((OutP->pidsetType.msgtl_header.msgt_inline) ? 4 * OutP->pidsetType.msgtl_number : sizeof(pid_t *)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (!OutP->pidsetType.msgtl_header.msgt_inline)
	    *pidset = *((pid_t **)OutP->pidset);
	else if (OutP->pidsetType.msgtl_number > *pidsetCnt) {
	    __mig_allocate((vm_offset_t *)pidset,
		4 * OutP->pidsetType.msgtl_number);
	    memcpy(*pidset, OutP->pidset, 4 * OutP->pidsetType.msgtl_number);
	}
	else {
	    memcpy(*pidset, OutP->pidset, 4 * OutP->pidsetType.msgtl_number);
	}

	*pidsetCnt = OutP->pidsetType.msgtl_number;

	return KERN_SUCCESS;
}

/* Routine proc_get_tty */
mig_external kern_return_t proc_get_tty
(
	process_t calling_process,
	pid_t target_process,
	mach_port_t *tty
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	boolean_t msgh_simple;
#endif	/* TypeCheck */
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t target_processType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

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

	InP->target_processType = target_processType;

	InP->target_process = target_process;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = calling_process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24050;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24150) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->ttyType, &ttyCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*tty = OutP->tty;

	return KERN_SUCCESS;
}

/* Routine proc_getnports */
mig_external kern_return_t proc_getnports
(
	process_t process,
	pid_t which,
	mach_msg_type_number_t *nports
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t whichType = {
		/* 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 RetCodeCheck = {
		/* 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
	};

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

	InP->whichType = whichType;

	InP->which = which;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24051;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24151) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->nportsType, &nportsCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*nports = OutP->nports;

	return KERN_SUCCESS;
}

/* Routine proc_set_init_task */
mig_external kern_return_t proc_set_init_task
(
	process_t process,
	mach_port_t task
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->taskType = taskType;

	InP->task = task;

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24052;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24152) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_mark_important */
mig_external kern_return_t proc_mark_important
(
	process_t process
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24053;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24153) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_is_important */
mig_external kern_return_t proc_is_important
(
	process_t process,
	boolean_t *essential
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

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

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24054;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24154) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->essentialType, &essentialCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*essential = OutP->essential;

	return KERN_SUCCESS;
}

/* Routine proc_set_code */
mig_external kern_return_t proc_set_code
(
	process_t process,
	vm_address_t start_code,
	vm_address_t end_code
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;

	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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->start_codeType = start_codeType;

	InP->start_code = start_code;

	InP->end_codeType = end_codeType;

	InP->end_code = end_code;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24055;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24155) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_get_code */
mig_external kern_return_t proc_get_code
(
	process_t process,
	vm_address_t *start_code,
	vm_address_t *end_code
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24056;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 24, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24156) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 48) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->start_codeType, &start_codeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*start_code = OutP->start_code;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->end_codeType, &end_codeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*end_code = OutP->end_code;

	return KERN_SUCCESS;
}

/* Routine proc_make_task_namespace */
mig_external kern_return_t proc_make_task_namespace
(
	process_t process,
	mach_port_t notify,
	mach_msg_type_name_t notifyPoly
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	boolean_t msgh_simple = TRUE;

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

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	InP->notifyType = notifyType;

	InP->notify = notify;

	if (MACH_MSG_TYPE_PORT_ANY(notifyPoly))
		msgh_simple = FALSE;

	InP->notifyType.msgt_name = notifyPoly;

	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24057;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 32, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24157) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (OutP->Head.msgh_size != 32))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	return OutP->RetCode;
}

/* Routine proc_user_identify */
mig_external kern_return_t proc_user_identify
(
	process_t process,
	mach_port_t rendezvous,
	mach_msg_type_name_t rendezvousPoly,
	mach_port_t *newport,
	pid_t pid
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	boolean_t msgh_simple = TRUE;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t rendezvousType = {
		/* msgt_name = */		-1,
		/* 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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

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

	InP->rendezvousType = rendezvousType;

	InP->rendezvous = rendezvous;

	if (MACH_MSG_TYPE_PORT_ANY(rendezvousPoly))
		msgh_simple = FALSE;

	InP->rendezvousType.msgt_name = rendezvousPoly;

	InP->pidType = pidType;

	InP->pid = pid;

	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24058;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24158) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;
	msgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);

	if (((msgh_size != 40) || msgh_simple) &&
	    ((msgh_size != sizeof(mig_reply_header_t)) ||
	     !msgh_simple ||
	     (OutP->RetCode == KERN_SUCCESS)))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->newportType, &newportCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*newport = OutP->newport;

	return KERN_SUCCESS;
}

/* Routine proc_server_identify */
mig_external kern_return_t proc_server_identify
(
	process_t process,
	mach_port_t rendezvous,
	mach_msg_type_name_t rendezvousPoly,
	mach_port_t newport,
	mach_msg_type_name_t newportPoly,
	pid_t *pid
)
{
	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;

	union {
		Request In;
		Reply Out;
	} Mess;

	Request *InP = &Mess.In;
	Reply *OutP = &Mess.Out;

	mach_msg_return_t msg_result;
	boolean_t msgh_simple = TRUE;
#if	TypeCheck
	unsigned int msgh_size;
#endif	/* TypeCheck */

	const mach_msg_type_t rendezvousType = {
		/* msgt_name = */		-1,
		/* 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
	};

	const mach_msg_type_t RetCodeCheck = {
		/* 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
	};

	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
	};

	InP->rendezvousType = rendezvousType;

	InP->rendezvous = rendezvous;

	if (MACH_MSG_TYPE_PORT_ANY(rendezvousPoly))
		msgh_simple = FALSE;

	InP->rendezvousType.msgt_name = rendezvousPoly;

	InP->newportType = newportType;

	InP->newport = newport;

	if (MACH_MSG_TYPE_PORT_ANY(newportPoly))
		msgh_simple = FALSE;

	InP->newportType.msgt_name = newportPoly;

	InP->Head.msgh_bits = msgh_simple ?
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE) :
		(MACH_MSGH_BITS_COMPLEX|
		 MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE));
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = process;
	InP->Head.msgh_reply_port = __mig_get_reply_port();
	InP->Head.msgh_seqno = 0;
	InP->Head.msgh_id = 24059;

	msg_result = __mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, 40, sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	if (msg_result != MACH_MSG_SUCCESS) {
		__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
		return msg_result;
	}
	__mig_put_reply_port(InP->Head.msgh_reply_port);

	if (OutP->Head.msgh_id != 24159) {
		if (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
			return MIG_SERVER_DIED;
		else {
			__mig_dealloc_reply_port(InP->Head.msgh_reply_port);
			return MIG_REPLY_MISMATCH;
		}
	}

#if	TypeCheck
	msgh_size = OutP->Head.msgh_size;

	if ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != 40) &&
	     ((msgh_size != sizeof(mig_reply_header_t)) ||
	      (OutP->RetCode == KERN_SUCCESS))))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->RetCodeType, &RetCodeCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	if (OutP->RetCode != KERN_SUCCESS)
		return OutP->RetCode;

#if	TypeCheck
	if (BAD_TYPECHECK (&OutP->pidType, &pidCheck))
		return MIG_TYPE_ERROR;
#endif	/* TypeCheck */

	*pid = OutP->pid;

	return KERN_SUCCESS;
}