/*
 * IDENTIFICATION:
 * stub generated Wed Jan 25 03:21:59 2017
 * with a MiG generated by bootstrap_cmds-96.20.2
 * OPTIONS: 
 */
#define	__MIG_check__Reply__DAServer_subsystem__ 1

#include "DAServer.h"


#ifndef	mig_internal
#define	mig_internal	static __inline__
#endif	/* mig_internal */

#ifndef	mig_external
#define mig_external
#endif	/* mig_external */

#if	!defined(__MigTypeCheck) && defined(TypeCheck)
#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
#endif	/* !defined(__MigTypeCheck) */

#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
#endif	/* !defined(__MigKernelSpecificCode) */

#ifndef	LimitCheck
#define	LimitCheck 0
#endif	/* LimitCheck */

#ifndef	min
#define	min(a,b)  ( ((a) < (b))? (a): (b) )
#endif	/* min */

#if !defined(_WALIGN_)
#define _WALIGN_(x) (((x) + 3) & ~3)
#endif /* !defined(_WALIGN_) */

#if !defined(_WALIGNSZ_)
#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
#endif /* !defined(_WALIGNSZ_) */

#ifndef	UseStaticTemplates
#define	UseStaticTemplates	0
#endif	/* UseStaticTemplates */

#ifndef	__MachMsgErrorWithTimeout
#define	__MachMsgErrorWithTimeout(_R_) { \
	switch (_R_) { \
	case MACH_SEND_INVALID_DATA: \
	case MACH_SEND_INVALID_DEST: \
	case MACH_SEND_INVALID_HEADER: \
		mig_put_reply_port(InP->Head.msgh_reply_port); \
		break; \
	case MACH_SEND_TIMED_OUT: \
	case MACH_RCV_TIMED_OUT: \
	default: \
		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
	} \
}
#endif	/* __MachMsgErrorWithTimeout */

#ifndef	__MachMsgErrorWithoutTimeout
#define	__MachMsgErrorWithoutTimeout(_R_) { \
	switch (_R_) { \
	case MACH_SEND_INVALID_DATA: \
	case MACH_SEND_INVALID_DEST: \
	case MACH_SEND_INVALID_HEADER: \
		mig_put_reply_port(InP->Head.msgh_reply_port); \
		break; \
	default: \
		mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
	} \
}
#endif	/* __MachMsgErrorWithoutTimeout */

#ifndef	__DeclareSendRpc
#define	__DeclareSendRpc(_NUM_, _NAME_)
#endif	/* __DeclareSendRpc */

#ifndef	__BeforeSendRpc
#define	__BeforeSendRpc(_NUM_, _NAME_)
#endif	/* __BeforeSendRpc */

#ifndef	__AfterSendRpc
#define	__AfterSendRpc(_NUM_, _NAME_)
#endif	/* __AfterSendRpc */

#ifndef	__DeclareSendSimple
#define	__DeclareSendSimple(_NUM_, _NAME_)
#endif	/* __DeclareSendSimple */

#ifndef	__BeforeSendSimple
#define	__BeforeSendSimple(_NUM_, _NAME_)
#endif	/* __BeforeSendSimple */

#ifndef	__AfterSendSimple
#define	__AfterSendSimple(_NUM_, _NAME_)
#endif	/* __AfterSendSimple */

#define msgh_request_port	msgh_remote_port
#define msgh_reply_port		msgh_local_port



#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskCopyDescription_t__defined)
#define __MIG_check__Reply___DAServerDiskCopyDescription_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskCopyDescription_t(__Reply___DAServerDiskCopyDescription_t *Out0P)
{

	typedef __Reply___DAServerDiskCopyDescription_t __Reply __attribute__((unused));
	boolean_t msgh_simple;
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 100) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

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

	if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||
	    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (msgh_simple) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

#if	__MigTypeCheck
	if (Out0P->_description.type != MACH_MSG_OOL_DESCRIPTOR) {
		return MIG_TYPE_ERROR;
	}
#endif	/* __MigTypeCheck */

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskCopyDescription_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskCopyDescription */
mig_external kern_return_t _DAServerDiskCopyDescription
(
	mach_port_t _session,
	caddr_t _disk,
	vm_address_t *_description,
	mach_msg_type_number_t *_descriptionCnt
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _description;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_msg_type_number_t _descriptionCnt;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _description;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_msg_type_number_t _descriptionCnt;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServerDiskCopyDescription_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskCopyDescription_t__defined */

	__DeclareSendRpc(0, "_DAServerDiskCopyDescription")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + (_WALIGN_(InP->_diskCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 0;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(0, "_DAServerDiskCopyDescription")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(0, "_DAServerDiskCopyDescription")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskCopyDescription_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskCopyDescription_t((__Reply___DAServerDiskCopyDescription_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskCopyDescription_t__defined) */

	*_description = (vm_address_t)(Out0P->_description.address);
	*_descriptionCnt = Out0P->_descriptionCnt;

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskGetOptions_t__defined)
#define __MIG_check__Reply___DAServerDiskGetOptions_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskGetOptions_t(__Reply___DAServerDiskGetOptions_t *Out0P)
{

	typedef __Reply___DAServerDiskGetOptions_t __Reply __attribute__((unused));
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 101) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	msgh_size = Out0P->Head.msgh_size;

	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	      Out0P->RetCode == KERN_SUCCESS)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (Out0P->RetCode != KERN_SUCCESS) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskGetOptions_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskGetOptions */
mig_external kern_return_t _DAServerDiskGetOptions
(
	mach_port_t _session,
	caddr_t _disk,
	int32_t *_options
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		int32_t _options;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		int32_t _options;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServerDiskGetOptions_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskGetOptions_t__defined */

	__DeclareSendRpc(1, "_DAServerDiskGetOptions")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + (_WALIGN_(InP->_diskCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 1;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(1, "_DAServerDiskGetOptions")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(1, "_DAServerDiskGetOptions")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskGetOptions_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskGetOptions_t((__Reply___DAServerDiskGetOptions_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskGetOptions_t__defined) */

	*_options = Out0P->_options;

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskGetUserUID_t__defined)
#define __MIG_check__Reply___DAServerDiskGetUserUID_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskGetUserUID_t(__Reply___DAServerDiskGetUserUID_t *Out0P)
{

	typedef __Reply___DAServerDiskGetUserUID_t __Reply __attribute__((unused));
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 102) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	msgh_size = Out0P->Head.msgh_size;

	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	      Out0P->RetCode == KERN_SUCCESS)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (Out0P->RetCode != KERN_SUCCESS) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskGetUserUID_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskGetUserUID */
mig_external kern_return_t _DAServerDiskGetUserUID
(
	mach_port_t _session,
	caddr_t _disk,
	uid_t *_userUID
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		uid_t _userUID;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		uid_t _userUID;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServerDiskGetUserUID_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskGetUserUID_t__defined */

	__DeclareSendRpc(2, "_DAServerDiskGetUserUID")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + (_WALIGN_(InP->_diskCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 2;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(2, "_DAServerDiskGetUserUID")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(2, "_DAServerDiskGetUserUID")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskGetUserUID_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskGetUserUID_t((__Reply___DAServerDiskGetUserUID_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskGetUserUID_t__defined) */

	*_userUID = Out0P->_userUID;

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskIsClaimed_t__defined)
#define __MIG_check__Reply___DAServerDiskIsClaimed_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskIsClaimed_t(__Reply___DAServerDiskIsClaimed_t *Out0P)
{

	typedef __Reply___DAServerDiskIsClaimed_t __Reply __attribute__((unused));
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 103) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	msgh_size = Out0P->Head.msgh_size;

	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    ((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	     (msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	      Out0P->RetCode == KERN_SUCCESS)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (Out0P->RetCode != KERN_SUCCESS) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskIsClaimed_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskIsClaimed */
mig_external kern_return_t _DAServerDiskIsClaimed
(
	mach_port_t _session,
	caddr_t _disk,
	boolean_t *_claimed
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		boolean_t _claimed;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		boolean_t _claimed;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServerDiskIsClaimed_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskIsClaimed_t__defined */

	__DeclareSendRpc(3, "_DAServerDiskIsClaimed")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + (_WALIGN_(InP->_diskCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 3;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(3, "_DAServerDiskIsClaimed")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(3, "_DAServerDiskIsClaimed")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskIsClaimed_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskIsClaimed_t((__Reply___DAServerDiskIsClaimed_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskIsClaimed_t__defined) */

	*_claimed = Out0P->_claimed;

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskSetAdoption_t__defined)
#define __MIG_check__Reply___DAServerDiskSetAdoption_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskSetAdoption_t(__Reply___DAServerDiskSetAdoption_t *Out0P)
{

	typedef __Reply___DAServerDiskSetAdoption_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 104) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskSetAdoption_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskSetAdoption */
mig_external kern_return_t _DAServerDiskSetAdoption
(
	mach_port_t _session,
	caddr_t _disk,
	boolean_t _adoption
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
		boolean_t _adoption;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerDiskSetAdoption_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskSetAdoption_t__defined */

	__DeclareSendRpc(4, "_DAServerDiskSetAdoption")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_diskCnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_adoption = _adoption;

	InP = &Mess.In;
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 4;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(4, "_DAServerDiskSetAdoption")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(4, "_DAServerDiskSetAdoption")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskSetAdoption_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskSetAdoption_t((__Reply___DAServerDiskSetAdoption_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskSetAdoption_t__defined) */

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskSetEncoding_t__defined)
#define __MIG_check__Reply___DAServerDiskSetEncoding_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskSetEncoding_t(__Reply___DAServerDiskSetEncoding_t *Out0P)
{

	typedef __Reply___DAServerDiskSetEncoding_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 105) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskSetEncoding_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskSetEncoding */
mig_external kern_return_t _DAServerDiskSetEncoding
(
	mach_port_t _session,
	caddr_t _disk,
	int32_t _encoding
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
		int32_t _encoding;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerDiskSetEncoding_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskSetEncoding_t__defined */

	__DeclareSendRpc(5, "_DAServerDiskSetEncoding")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_diskCnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_encoding = _encoding;

	InP = &Mess.In;
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 5;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(5, "_DAServerDiskSetEncoding")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(5, "_DAServerDiskSetEncoding")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskSetEncoding_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskSetEncoding_t((__Reply___DAServerDiskSetEncoding_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskSetEncoding_t__defined) */

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerDiskSetOptions_t__defined)
#define __MIG_check__Reply___DAServerDiskSetOptions_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerDiskSetOptions_t(__Reply___DAServerDiskSetOptions_t *Out0P)
{

	typedef __Reply___DAServerDiskSetOptions_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 106) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServerDiskSetOptions_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerDiskSetOptions */
mig_external kern_return_t _DAServerDiskSetOptions
(
	mach_port_t _session,
	caddr_t _disk,
	int32_t _options,
	int32_t _value
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
		int32_t _options;
		int32_t _value;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerDiskSetOptions_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskSetOptions_t__defined */

	__DeclareSendRpc(6, "_DAServerDiskSetOptions")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_diskCnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_options = _options;

	InP->_value = _value;

	InP = &Mess.In;
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 6;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(6, "_DAServerDiskSetOptions")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(6, "_DAServerDiskSetOptions")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerDiskSetOptions_t__defined)
	check_result = __MIG_check__Reply___DAServerDiskSetOptions_t((__Reply___DAServerDiskSetOptions_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerDiskSetOptions_t__defined) */

	return KERN_SUCCESS;
}

/* SimpleRoutine _DAServerDiskUnclaim */
mig_external kern_return_t _DAServerDiskUnclaim
(
	mach_port_t _session,
	caddr_t _disk
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServerDiskUnclaim_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerDiskUnclaim_t__defined */

	__DeclareSendSimple(7, "_DAServerDiskUnclaim")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + (_WALIGN_(InP->_diskCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 7;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(7, "_DAServerDiskUnclaim")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(7, "_DAServerDiskUnclaim")
	return msg_result;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined)
#define __MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerSessionCopyCallbackQueue_t(__Reply___DAServerSessionCopyCallbackQueue_t *Out0P)
{

	typedef __Reply___DAServerSessionCopyCallbackQueue_t __Reply __attribute__((unused));
	boolean_t msgh_simple;
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 108) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

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

	if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||
	    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (msgh_simple) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

#if	__MigTypeCheck
	if (Out0P->_queue.type != MACH_MSG_OOL_DESCRIPTOR) {
		return MIG_TYPE_ERROR;
	}
#endif	/* __MigTypeCheck */

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerSessionCopyCallbackQueue */
mig_external kern_return_t _DAServerSessionCopyCallbackQueue
(
	mach_port_t _session,
	vm_address_t *_queue,
	mach_msg_type_number_t *_queueCnt
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _queue;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_msg_type_number_t _queueCnt;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _queue;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_msg_type_number_t _queueCnt;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined */

	__DeclareSendRpc(8, "_DAServerSessionCopyCallbackQueue")

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 8;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(8, "_DAServerSessionCopyCallbackQueue")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(8, "_DAServerSessionCopyCallbackQueue")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined)
	check_result = __MIG_check__Reply___DAServerSessionCopyCallbackQueue_t((__Reply___DAServerSessionCopyCallbackQueue_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerSessionCopyCallbackQueue_t__defined) */

	*_queue = (vm_address_t)(Out0P->_queue.address);
	*_queueCnt = Out0P->_queueCnt;

	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerSessionCreate_t__defined)
#define __MIG_check__Reply___DAServerSessionCreate_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerSessionCreate_t(__Reply___DAServerSessionCreate_t *Out0P)
{

	typedef __Reply___DAServerSessionCreate_t __Reply __attribute__((unused));
	boolean_t msgh_simple;
#if	__MigTypeCheck
	unsigned int msgh_size;
#endif	/* __MigTypeCheck */
	if (Out0P->Head.msgh_id != 109) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

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

	if ((msgh_simple || Out0P->msgh_body.msgh_descriptor_count != 1 ||
	    msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
	    (!msgh_simple || msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
	    ((mig_reply_error_t *)Out0P)->RetCode == KERN_SUCCESS))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	if (msgh_simple) {
		return ((mig_reply_error_t *)Out0P)->RetCode;
	}

#if	__MigTypeCheck
	if (Out0P->_server.type != MACH_MSG_PORT_DESCRIPTOR ||
	    Out0P->_server.disposition != 17) {
		return MIG_TYPE_ERROR;
	}
#endif	/* __MigTypeCheck */

	return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply___DAServerSessionCreate_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerSessionCreate */
mig_external kern_return_t _DAServerSessionCreate
(
	mach_port_t _session,
	caddr_t _name,
	pid_t _pid,
	mach_port_t *_server
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _nameOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _nameCnt;
		char _name[1024];
		pid_t _pid;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_port_descriptor_t _server;
		/* end of the kernel processed data */
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_port_descriptor_t _server;
		/* end of the kernel processed data */
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerSessionCreate_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionCreate_t__defined */

	__DeclareSendRpc(9, "_DAServerSessionCreate")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_nameCnt = mig_strncpy_zerofill(InP->_name, _name, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_nameCnt = mig_strncpy(InP->_name, _name, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_nameCnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_pid = _pid;

	InP = &Mess.In;
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 9;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(9, "_DAServerSessionCreate")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(9, "_DAServerSessionCreate")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerSessionCreate_t__defined)
	check_result = __MIG_check__Reply___DAServerSessionCreate_t((__Reply___DAServerSessionCreate_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerSessionCreate_t__defined) */

	*_server = Out0P->_server.name;
	return KERN_SUCCESS;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerSessionQueueRequest_t__defined)
#define __MIG_check__Reply___DAServerSessionQueueRequest_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerSessionQueueRequest_t(__Reply___DAServerSessionQueueRequest_t *Out0P)
{

	typedef __Reply___DAServerSessionQueueRequest_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 110) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServerSessionQueueRequest_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerSessionQueueRequest */
mig_external kern_return_t _DAServerSessionQueueRequest
(
	mach_port_t _session,
	int32_t _kind,
	caddr_t _argument0,
	int32_t _argument1,
	vm_address_t _argument2,
	mach_msg_type_number_t _argument2Cnt,
	vm_address_t _argument3,
	mach_msg_type_number_t _argument3Cnt,
	mach_vm_offset_t _address,
	mach_vm_offset_t _context
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _argument2;
		mach_msg_ool_descriptor_t _argument3;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		int32_t _kind;
		mach_msg_type_number_t _argument0Offset; /* MiG doesn't use it */
		mach_msg_type_number_t _argument0Cnt;
		char _argument0[1024];
		int32_t _argument1;
		mach_msg_type_number_t _argument2Cnt;
		mach_msg_type_number_t _argument3Cnt;
		mach_vm_offset_t _address;
		mach_vm_offset_t _context;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerSessionQueueRequest_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionQueueRequest_t__defined */

	__DeclareSendRpc(10, "_DAServerSessionQueueRequest")

#if	UseStaticTemplates
	const static mach_msg_ool_descriptor_t _argument2Template = {
		/* addr = */		(void *)0,
		/* size = */		0,
		/* deal = */		FALSE,
		/* copy = */		MACH_MSG_VIRTUAL_COPY,
		/* pad2 = */		0,
		/* type = */		MACH_MSG_OOL_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

#if	UseStaticTemplates
	const static mach_msg_ool_descriptor_t _argument3Template = {
		/* addr = */		(void *)0,
		/* size = */		0,
		/* deal = */		FALSE,
		/* copy = */		MACH_MSG_VIRTUAL_COPY,
		/* pad2 = */		0,
		/* type = */		MACH_MSG_OOL_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

	InP->msgh_body.msgh_descriptor_count = 2;
#if	UseStaticTemplates
	InP->_argument2 = _argument2Template;
	InP->_argument2.address = (void *)(_argument2);
	InP->_argument2.size = _argument2Cnt;
#else	/* UseStaticTemplates */
	InP->_argument2.address = (void *)(_argument2);
	InP->_argument2.size = _argument2Cnt;
	InP->_argument2.deallocate =  FALSE;
	InP->_argument2.copy = MACH_MSG_VIRTUAL_COPY;
	InP->_argument2.type = MACH_MSG_OOL_DESCRIPTOR;
#endif	/* UseStaticTemplates */

#if	UseStaticTemplates
	InP->_argument3 = _argument3Template;
	InP->_argument3.address = (void *)(_argument3);
	InP->_argument3.size = _argument3Cnt;
#else	/* UseStaticTemplates */
	InP->_argument3.address = (void *)(_argument3);
	InP->_argument3.size = _argument3Cnt;
	InP->_argument3.deallocate =  FALSE;
	InP->_argument3.copy = MACH_MSG_VIRTUAL_COPY;
	InP->_argument3.type = MACH_MSG_OOL_DESCRIPTOR;
#endif	/* UseStaticTemplates */

	InP->NDR = NDR_record;

	InP->_kind = _kind;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_argument0Cnt = mig_strncpy_zerofill(InP->_argument0, _argument0, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_argument0Cnt = mig_strncpy(InP->_argument0, _argument0, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_argument0Cnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_argument1 = _argument1;

	InP->_argument2Cnt = _argument2Cnt;

	InP->_argument3Cnt = _argument3Cnt;

	InP->_address = _address;

	InP->_context = _context;

	InP = &Mess.In;
	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 = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 10;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(10, "_DAServerSessionQueueRequest")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(10, "_DAServerSessionQueueRequest")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerSessionQueueRequest_t__defined)
	check_result = __MIG_check__Reply___DAServerSessionQueueRequest_t((__Reply___DAServerSessionQueueRequest_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerSessionQueueRequest_t__defined) */

	return KERN_SUCCESS;
}

/* SimpleRoutine _DAServerSessionQueueResponse */
mig_external kern_return_t _DAServerSessionQueueResponse
(
	mach_port_t _session,
	mach_vm_offset_t _address,
	mach_vm_offset_t _context,
	int32_t _kind,
	caddr_t _disk,
	vm_address_t _response,
	mach_msg_type_number_t _responseCnt,
	int32_t _responseID
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _response;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_vm_offset_t _address;
		mach_vm_offset_t _context;
		int32_t _kind;
		mach_msg_type_number_t _diskOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _diskCnt;
		char _disk[1024];
		mach_msg_type_number_t _responseCnt;
		int32_t _responseID;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;
	unsigned int msgh_size;
	unsigned int msgh_size_delta;


#ifdef	__MIG_check__Reply___DAServerSessionQueueResponse_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionQueueResponse_t__defined */

	__DeclareSendSimple(11, "_DAServerSessionQueueResponse")

#if	UseStaticTemplates
	const static mach_msg_ool_descriptor_t _responseTemplate = {
		/* addr = */		(void *)0,
		/* size = */		0,
		/* deal = */		FALSE,
		/* copy = */		MACH_MSG_VIRTUAL_COPY,
		/* pad2 = */		0,
		/* type = */		MACH_MSG_OOL_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

	InP->msgh_body.msgh_descriptor_count = 1;
#if	UseStaticTemplates
	InP->_response = _responseTemplate;
	InP->_response.address = (void *)(_response);
	InP->_response.size = _responseCnt;
#else	/* UseStaticTemplates */
	InP->_response.address = (void *)(_response);
	InP->_response.size = _responseCnt;
	InP->_response.deallocate =  FALSE;
	InP->_response.copy = MACH_MSG_VIRTUAL_COPY;
	InP->_response.type = MACH_MSG_OOL_DESCRIPTOR;
#endif	/* UseStaticTemplates */

	InP->NDR = NDR_record;

	InP->_address = _address;

	InP->_context = _context;

	InP->_kind = _kind;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_diskCnt = mig_strncpy_zerofill(InP->_disk, _disk, 1024);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_diskCnt = mig_strncpy(InP->_disk, _disk, 1024);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size_delta = _WALIGN_(InP->_diskCnt);
	msgh_size = (mach_msg_size_t)(sizeof(Request) - 1024) + msgh_size_delta;
	InP = (Request *) ((pointer_t) InP + msgh_size_delta - 1024);

	InP->_responseCnt = _responseCnt;

	InP->_responseID = _responseID;

	InP = &Mess.In;
	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 11;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(11, "_DAServerSessionQueueResponse")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(11, "_DAServerSessionQueueResponse")
	return msg_result;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServerSessionRegisterCallback_t__defined)
#define __MIG_check__Reply___DAServerSessionRegisterCallback_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServerSessionRegisterCallback_t(__Reply___DAServerSessionRegisterCallback_t *Out0P)
{

	typedef __Reply___DAServerSessionRegisterCallback_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 112) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServerSessionRegisterCallback_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServerSessionRegisterCallback */
mig_external kern_return_t _DAServerSessionRegisterCallback
(
	mach_port_t _session,
	mach_vm_offset_t _address,
	mach_vm_offset_t _context,
	int32_t _kind,
	int32_t _order,
	vm_address_t _match,
	mach_msg_type_number_t _matchCnt,
	vm_address_t _watch,
	mach_msg_type_number_t _watchCnt
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_ool_descriptor_t _match;
		mach_msg_ool_descriptor_t _watch;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		mach_vm_offset_t _address;
		mach_vm_offset_t _context;
		int32_t _kind;
		int32_t _order;
		mach_msg_type_number_t _matchCnt;
		mach_msg_type_number_t _watchCnt;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionRegisterCallback_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionRegisterCallback_t__defined */

	__DeclareSendRpc(12, "_DAServerSessionRegisterCallback")

#if	UseStaticTemplates
	const static mach_msg_ool_descriptor_t _matchTemplate = {
		/* addr = */		(void *)0,
		/* size = */		0,
		/* deal = */		FALSE,
		/* copy = */		MACH_MSG_VIRTUAL_COPY,
		/* pad2 = */		0,
		/* type = */		MACH_MSG_OOL_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

#if	UseStaticTemplates
	const static mach_msg_ool_descriptor_t _watchTemplate = {
		/* addr = */		(void *)0,
		/* size = */		0,
		/* deal = */		FALSE,
		/* copy = */		MACH_MSG_VIRTUAL_COPY,
		/* pad2 = */		0,
		/* type = */		MACH_MSG_OOL_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

	InP->msgh_body.msgh_descriptor_count = 2;
#if	UseStaticTemplates
	InP->_match = _matchTemplate;
	InP->_match.address = (void *)(_match);
	InP->_match.size = _matchCnt;
#else	/* UseStaticTemplates */
	InP->_match.address = (void *)(_match);
	InP->_match.size = _matchCnt;
	InP->_match.deallocate =  FALSE;
	InP->_match.copy = MACH_MSG_VIRTUAL_COPY;
	InP->_match.type = MACH_MSG_OOL_DESCRIPTOR;
#endif	/* UseStaticTemplates */

#if	UseStaticTemplates
	InP->_watch = _watchTemplate;
	InP->_watch.address = (void *)(_watch);
	InP->_watch.size = _watchCnt;
#else	/* UseStaticTemplates */
	InP->_watch.address = (void *)(_watch);
	InP->_watch.size = _watchCnt;
	InP->_watch.deallocate =  FALSE;
	InP->_watch.copy = MACH_MSG_VIRTUAL_COPY;
	InP->_watch.type = MACH_MSG_OOL_DESCRIPTOR;
#endif	/* UseStaticTemplates */

	InP->NDR = NDR_record;

	InP->_address = _address;

	InP->_context = _context;

	InP->_kind = _kind;

	InP->_order = _order;

	InP->_matchCnt = _matchCnt;

	InP->_watchCnt = _watchCnt;

	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 = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 12;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(12, "_DAServerSessionRegisterCallback")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(12, "_DAServerSessionRegisterCallback")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServerSessionRegisterCallback_t__defined)
	check_result = __MIG_check__Reply___DAServerSessionRegisterCallback_t((__Reply___DAServerSessionRegisterCallback_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServerSessionRegisterCallback_t__defined) */

	return KERN_SUCCESS;
}

/* SimpleRoutine _DAServerSessionRelease */
mig_external kern_return_t _DAServerSessionRelease
(
	mach_port_t _session
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionRelease_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionRelease_t__defined */

	__DeclareSendSimple(13, "_DAServerSessionRelease")

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 13;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(13, "_DAServerSessionRelease")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(13, "_DAServerSessionRelease")
	return msg_result;
}

/* SimpleRoutine _DAServerSessionSetAuthorization */
mig_external kern_return_t _DAServerSessionSetAuthorization
(
	mach_port_t _session,
	AuthorizationExternalForm _authorization
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		AuthorizationExternalForm _authorization;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionSetAuthorization_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionSetAuthorization_t__defined */

	__DeclareSendSimple(14, "_DAServerSessionSetAuthorization")

	InP->NDR = NDR_record;

	InP->_authorization = _authorization;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 14;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(14, "_DAServerSessionSetAuthorization")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(14, "_DAServerSessionSetAuthorization")
	return msg_result;
}

/* SimpleRoutine _DAServerSessionSetClientPort */
mig_external kern_return_t _DAServerSessionSetClientPort
(
	mach_port_t _session,
	mach_port_t _client
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_port_descriptor_t _client;
		/* end of the kernel processed data */
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionSetClientPort_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionSetClientPort_t__defined */

	__DeclareSendSimple(15, "_DAServerSessionSetClientPort")

#if	UseStaticTemplates
	const static mach_msg_port_descriptor_t _clientTemplate = {
		/* name = */		MACH_PORT_NULL,
		/* pad1 = */		0,
		/* pad2 = */		0,
		/* disp = */		20,
		/* type = */		MACH_MSG_PORT_DESCRIPTOR,
	};
#endif	/* UseStaticTemplates */

	InP->msgh_body.msgh_descriptor_count = 1;
#if	UseStaticTemplates
	InP->_client = _clientTemplate;
	InP->_client.name = _client;
#else	/* UseStaticTemplates */
	InP->_client.name = _client;
	InP->_client.disposition = 20;
	InP->_client.type = MACH_MSG_PORT_DESCRIPTOR;
#endif	/* UseStaticTemplates */

	InP->Head.msgh_bits = MACH_MSGH_BITS_COMPLEX|
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 15;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(15, "_DAServerSessionSetClientPort")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(15, "_DAServerSessionSetClientPort")
	return msg_result;
}

/* SimpleRoutine _DAServerSessionUnregisterCallback */
mig_external kern_return_t _DAServerSessionUnregisterCallback
(
	mach_port_t _session,
	mach_vm_offset_t _address,
	mach_vm_offset_t _context
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_vm_offset_t _address;
		mach_vm_offset_t _context;
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
	} Mess;

	Request *InP = &Mess.In;

	mach_msg_return_t msg_result;

#ifdef	__MIG_check__Reply___DAServerSessionUnregisterCallback_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServerSessionUnregisterCallback_t__defined */

	__DeclareSendSimple(16, "_DAServerSessionUnregisterCallback")

	InP->NDR = NDR_record;

	InP->_address = _address;

	InP->_context = _context;

	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, 0);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = MACH_PORT_NULL;
	InP->Head.msgh_id = 16;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendSimple(16, "_DAServerSessionUnregisterCallback")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendSimple(16, "_DAServerSessionUnregisterCallback")
	return msg_result;
}

#if ( __MigTypeCheck )
#if __MIG_check__Reply__DAServer_subsystem__
#if !defined(__MIG_check__Reply___DAServermkdir_t__defined)
#define __MIG_check__Reply___DAServermkdir_t__defined

mig_internal kern_return_t __MIG_check__Reply___DAServermkdir_t(__Reply___DAServermkdir_t *Out0P)
{

	typedef __Reply___DAServermkdir_t __Reply __attribute__((unused));
	if (Out0P->Head.msgh_id != 117) {
	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
		{ return MIG_SERVER_DIED; }
	    else
		{ return MIG_REPLY_MISMATCH; }
	}

#if	__MigTypeCheck
	if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
	    (Out0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Reply)))
		{ return MIG_TYPE_ERROR ; }
#endif	/* __MigTypeCheck */

	{
		return Out0P->RetCode;
	}
}
#endif /* !defined(__MIG_check__Reply___DAServermkdir_t__defined) */
#endif /* __MIG_check__Reply__DAServer_subsystem__ */
#endif /* ( __MigTypeCheck ) */


/* Routine _DAServermkdir */
mig_external kern_return_t _DAServermkdir
(
	mach_port_t _session,
	___path_t _path
)
{

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		mach_msg_type_number_t _pathOffset; /* MiG doesn't use it */
		mach_msg_type_number_t _pathCnt;
		char _path[4096];
	} Request __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
		mach_msg_trailer_t trailer;
	} Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif

#ifdef  __MigPackStructs
#pragma pack(4)
#endif
	typedef struct {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} __Reply __attribute__((unused));
#ifdef  __MigPackStructs
#pragma pack()
#endif
	/*
	 * typedef struct {
	 * 	mach_msg_header_t Head;
	 * 	NDR_record_t NDR;
	 * 	kern_return_t RetCode;
	 * } mig_reply_error_t;
	 */

	union {
		Request In;
		Reply Out;
	} Mess;

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

	mach_msg_return_t msg_result;
	unsigned int msgh_size;

#ifdef	__MIG_check__Reply___DAServermkdir_t__defined
	kern_return_t check_result;
#endif	/* __MIG_check__Reply___DAServermkdir_t__defined */

	__DeclareSendRpc(17, "_DAServermkdir")

	InP->NDR = NDR_record;

#ifdef USING_MIG_STRNCPY_ZEROFILL
	if (mig_strncpy_zerofill != NULL) {
		InP->_pathCnt = mig_strncpy_zerofill(InP->_path, _path, 4096);
	} else {
#endif /* USING_MIG_STRNCPY_ZEROFILL */
		InP->_pathCnt = mig_strncpy(InP->_path, _path, 4096);
#ifdef USING_MIG_STRNCPY_ZEROFILL
	}
#endif /* USING_MIG_STRNCPY_ZEROFILL */

	msgh_size = (mach_msg_size_t)(sizeof(Request) - 4096) + (_WALIGN_(InP->_pathCnt));
	InP->Head.msgh_bits =
		MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
	/* msgh_size passed as argument */
	InP->Head.msgh_request_port = _session;
	InP->Head.msgh_reply_port = mig_get_reply_port();
	InP->Head.msgh_id = 17;
	InP->Head.msgh_reserved = 0;
	
/* BEGIN VOUCHER CODE */

#ifdef USING_VOUCHERS
	if (voucher_mach_msg_set != NULL) {
		voucher_mach_msg_set(&InP->Head);
	}
#endif // USING_VOUCHERS
	
/* END VOUCHER CODE */

	__BeforeSendRpc(17, "_DAServermkdir")
	msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, msgh_size, (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
	__AfterSendRpc(17, "_DAServermkdir")
	if (msg_result != MACH_MSG_SUCCESS) {
		__MachMsgErrorWithoutTimeout(msg_result);
		{ return msg_result; }
	}


#if	defined(__MIG_check__Reply___DAServermkdir_t__defined)
	check_result = __MIG_check__Reply___DAServermkdir_t((__Reply___DAServermkdir_t *)Out0P);
	if (check_result != MACH_MSG_SUCCESS)
		{ return check_result; }
#endif	/* defined(__MIG_check__Reply___DAServermkdir_t__defined) */

	return KERN_SUCCESS;
}
