ndl - zygaena/hammerhead

root / base / usr / src / uts / common / smbsrv / ndl
ndl Plain Text 8017 lines 216.6 KB
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _DSSETUP_NDL_
#define	_DSSETUP_NDL_

/*
 * Active Directory Service Setup
 *
 * Originally this interface contained a number of operations, as listed
 * below, but due to a buffer overflow security issue, all operations
 * except DsRoleGetPrimaryDomainInfo have been deprecated (MS04-011).
 */

#include <libmlrpc/ndrtypes.ndl>


#define	DSSETUP_OPNUM_DsRoleGetPrimaryDomainInfo	0x00
#define	DSSETUP_OPNUM_DsRoleDnsNameToFlatName		0x01
#define	DSSETUP_OPNUM_DsRoleDcAsDc			0x02
#define	DSSETUP_OPNUM_DsRoleDcAsReplica			0x03
#define	DSSETUP_OPNUM_DsRoleDemoteDc			0x04
#define	DSSETUP_OPNUM_DsRoleGetDcOperationProgress	0x05
#define	DSSETUP_OPNUM_DsRoleGetDcOperationResults	0x06
#define	DSSETUP_OPNUM_DsRoleCancel			0x07
#define	DSSETUP_OPNUM_DsRoleServerSaveStateForUpgrade	0x08
#define	DSSETUP_OPNUM_DsRoleUpgradeDownlevelServer	0x09
#define	DSSETUP_OPNUM_DsRoleAbortDownlevelServerUpgrade	0x0a

/*
 * DS roles
 */
#define	DS_ROLE_STANDALONE_WORKSTATION	0
#define	DS_ROLE_MEMBER_WORKSTATION	1
#define	DS_ROLE_STANDALONE_SERVER	2
#define	DS_ROLE_MEMBER_SERVER		3
#define	DS_ROLE_BACKUP_DC		4
#define	DS_ROLE_PRIMARY_DC		5

/*
 * DS role flags
 */
#define	DS_ROLE_PRIMARY_DS_RUNNING              0x00000001
#define	DS_ROLE_PRIMARY_DS_MIXED_MODE           0x00000002
#define	DS_ROLE_UPGRADE_IN_PROGRESS             0x00000004
#define	DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT	0x01000000

/*
 * DS role upgrade
 */
#define	DS_ROLE_NOT_UPGRADING		0
#define	DS_ROLE_UPGRADING		1

/*
 * DS role previous
 */
#define	DS_ROLE_PREVIOUS_UNKNOWN	0
#define	DS_ROLE_PREVIOUS_PRIMARY	1
#define	DS_ROLE_PREVIOUS_BACKUP		2

/*
 * DS role state
 */
#define	DS_ROLE_OP_IDLE			0
#define	DS_ROLE_OP_ACTIVE		1
#define	DS_ROLE_OP_NEEDS_REBOOT		2

/*
 * DS role information levels
 */
#define	DS_ROLE_BASIC_INFORMATION	1
#define	DS_ROLE_UPGRADE_STATUS		2
#define	DS_ROLE_OP_STATUS		3

struct dssetup_uuid {
	DWORD	data1;
	WORD	data2;
	WORD	data3;
	BYTE	data4[8];
};
typedef struct dssetup_uuid dssetup_uuid_t;

/*
 * DS_ROLE_BASIC_INFORMATION
 */
struct dssetup_DsRolePrimaryDomInfo1 {
	DWORD role;
	DWORD flags;
	LPTSTR nt_domain;
	LPTSTR dns_domain;
	LPTSTR forest;
	dssetup_uuid_t domain_guid;
};
typedef struct dssetup_DsRolePrimaryDomInfo1 ds_primary_domain_info_t;

/*
 * DS_ROLE_UPGRADE_STATUS
 */
struct dssetup_DsRolePrimaryDomInfo2 {
	DWORD upgrade_state;
	DWORD previous_role;
};

/*
 * DS_ROLE_OP_STATUS
 */
struct dssetup_DsRolePrimaryDomInfo3 {
	DWORD status;
};

union dssetup_GetPrimaryDomainInfo_ru {
	UNION_INFO_ENT(1,dssetup_DsRolePrimaryDomInfo);
	UNION_INFO_ENT(2,dssetup_DsRolePrimaryDomInfo);
	UNION_INFO_ENT(3,dssetup_DsRolePrimaryDomInfo);
	DEFAULT	char *nullptr;
};

struct dssetup_GetPrimaryDomainInfo {
	WORD switch_value;
    SWITCH(switch_value)
	union dssetup_GetPrimaryDomainInfo_ru ru;
};
typedef struct dssetup_GetPrimaryDomainInfo dssetup_GetPrimaryDomainInfo_t;

OPERATION(DSSETUP_OPNUM_DsRoleGetPrimaryDomainInfo)
struct dssetup_DsRoleGetPrimaryDomainInfo {
	IN	WORD level;
	OUT	struct dssetup_GetPrimaryDomainInfo *info;
	OUT	DWORD status;
};
typedef struct dssetup_DsRoleGetPrimaryDomainInfo
    dssetup_DsRoleGetPrimaryDomainInfo_t;


/*
 ***********************************************************************
 * DSSETUP interface definiton.
 ***********************************************************************
 */
INTERFACE(0)
union dssetup_interface {
	CASE(DSSETUP_OPNUM_DsRoleGetPrimaryDomainInfo)
		struct dssetup_DsRoleGetPrimaryDomainInfo GetPrimaryDomainInfo;
};
typedef union dssetup_interface dssetup_interface_t;
EXTERNTYPEINFO(dssetup_interface)

#endif /* _DSSETUP_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_LOGR_NDL_
#define _MLSVC_LOGR_NDL_

/*
 ***********************************************************************
 *
 * Event log RPC (EVENTLOG) interface definition.
 *
 ***********************************************************************
 */

#include <libmlrpc/ndrtypes.ndl>

#define LOGR_OPNUM_EventLogClose		0x02
#define LOGR_OPNUM_EventLogQueryCount		0x04
#define LOGR_OPNUM_EventLogGetOldestRec		0x05
#define LOGR_OPNUM_EventLogOpen			0x07
#define LOGR_OPNUM_EventLogRead			0x0A

#define LOGR_MAXENTRYLEN			800


CONTEXT_HANDLE(logr_handle) logr_handle_t;

struct logr_string {
	WORD	length;
	WORD	allosize;
	LPTSTR	str;
};
typedef struct logr_string logr_string_t;

struct logr_record {
	DWORD  Length1;
	DWORD  Reserved;
	DWORD  RecordNumber;
	DWORD  TimeGenerated;
	DWORD  TimeWritten;
	DWORD  EventID;
	WORD   EventType;
	WORD   NumStrings;
	WORD   EventCategory;
	WORD   ReservedFlags;
	DWORD  ClosingRecordNumber;
	DWORD  StringOffset;
	DWORD  UserSidLength;
	DWORD  UserSidOffset;
	DWORD  DataLength;
	DWORD  DataOffset;
	BYTE   info[LOGR_MAXENTRYLEN];
	DWORD  Length2;
};
typedef struct logr_record logr_record_t;

/*
 ***********************************************************************
 * LOGR_OPNUM_EventLogClose
 ***********************************************************************
 */
OPERATION(LOGR_OPNUM_EventLogClose)
struct logr_EventLogClose {
	IN	logr_handle_t handle;
	OUT	logr_handle_t result_handle;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * LOGR_OPNUM_EventLogQueryCount
 ***********************************************************************
 */
OPERATION(LOGR_OPNUM_EventLogQueryCount)
struct logr_EventLogQueryCount {
	IN	logr_handle_t handle;
	OUT	DWORD rec_num;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * LOGR_OPNUM_EventLogGetOldestRec
 ***********************************************************************
 */
OPERATION(LOGR_OPNUM_EventLogGetOldestRec)
struct logr_EventLogGetOldestRec {
	IN	logr_handle_t handle;
	OUT	DWORD oldest_rec;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * LOGR_OPNUM_EventLogOpen
 ***********************************************************************
 */
OPERATION(LOGR_OPNUM_EventLogOpen)
struct logr_EventLogOpen {
	IN	DWORD *server_name;
	IN	logr_string_t log_name;
	IN	DWORD reg_module_name;
	IN	DWORD major_version;
	IN	DWORD minor_version;
	OUT	logr_handle_t handle;
	OUT	DWORD status;
};

OPERATION(LOGR_OPNUM_EventLogRead)
struct logr_EventLogRead {
	IN	logr_handle_t handle;
	IN	DWORD read_flags;
	IN	DWORD rec_offset;
	IN	DWORD nbytes_to_read;
    SIZE_IS(nbytes_to_read)
	OUT REFERENCE	LPBYTE buf;
	OUT	DWORD sent_size;
	OUT	DWORD min_bytes_needed;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * The EVENTLOG interface definition.
 ***********************************************************************
 */
INTERFACE(0)
union logr_interface {
	CASE(LOGR_OPNUM_EventLogClose)
		struct logr_EventLogClose		EventLogClose;
	CASE(LOGR_OPNUM_EventLogQueryCount)
		struct logr_EventLogQueryCount		EventLogQueryCount;
	CASE(LOGR_OPNUM_EventLogGetOldestRec)
		struct logr_EventLogGetOldestRec	EventLogGetOldestRec;
	CASE(LOGR_OPNUM_EventLogOpen)
		struct logr_EventLogOpen		EventLogOpen;
	CASE(LOGR_OPNUM_EventLogRead)
		struct logr_EventLogRead		EventLogRead;
};
typedef union logr_interface	logr_interface_t;
EXTERNTYPEINFO(logr_interface)

#endif /* _MLSVC_LOGR_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_LLSR_NDL_
#define _MLSVC_LLSR_NDL_

/*
 * LLSRPC interface.
 *
 *	0x50	takes the 3a handle + DWORD, returns 2 DWORDs
 *	0x3c
 *	0x3f	list of services?
 *	0x3d	unknown
 *	0x3e	unknown
 *	0x4f
 *	0x4d
 *	0x4e
 *	0x01	closes the handle obtained via 0x00
 *	0x3b	closes the handle obtained via 0x3a
 */

#include <libmlrpc/ndrtypes.ndl>

#define LLSR_OPNUM_Open			0x00
#define LLSR_OPNUM_Close		0x01
#define LLSR_OPNUM_Connect		0x3a
#define LLSR_OPNUM_Disconnect		0x3b
#define LLSR_OPNUM_Unknown3c		0x3c
#define LLSR_OPNUM_Unknown3d		0x3d
#define LLSR_OPNUM_Unknown3e		0x3e
#define LLSR_OPNUM_Unknown3f		0x3f
#define LLSR_OPNUM_Unknown4d		0x4d
#define LLSR_OPNUM_Unknown4e		0x4e
#define LLSR_OPNUM_Unknown4f		0x4f
#define LLSR_OPNUM_Unknown50		0x50


CONTEXT_HANDLE(llsr_handle) llsr_handle_t;


OPERATION(LLSR_OPNUM_Open)
struct llsr_Open {
	IN	LPTSTR hostname;
	OUT	llsr_handle_t open_handle;
	OUT	DWORD status;
};


OPERATION(LLSR_OPNUM_Close)
struct llsr_Close {
	IN	llsr_handle_t open_handle;
	OUT	DWORD status;
};


OPERATION(LLSR_OPNUM_Connect)
struct llsr_Connect {
	IN	LPTSTR hostname;
	OUT	llsr_handle_t connect_handle;
	OUT	DWORD status;
};


OPERATION(LLSR_OPNUM_Disconnect)
struct llsr_Disconnect {
	IN	llsr_handle_t connect_handle;
	OUT	llsr_handle_t echoed_handle;
	OUT	DWORD status;
};


OPERATION(LLSR_OPNUM_Unknown50)
struct llsr_Unknown50 {
	IN	llsr_handle_t open_handle;
	IN	DWORD unknown1;	/* 0x00000004 */
	OUT	DWORD unknown2;	/* 0x00000004 */
	OUT	DWORD unknown3;	/* 0x0000003F */
	OUT	DWORD status;
};


#endif /* _MLSVC_LLSR_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_LSA_NDL_
#define _MLSVC_LSA_NDL_

/*
 * Local Security Authority RPC (LSARPC) interface definition.
 *
 * Names containing a backslash ('\') are known as qualified or composite
 * names.  The string preceding the backslash is assumed to be the domain
 * name and the string following the slash is assumed to be name to be
 * resolved within that domain.
 *
 * Names that do not contain a backslash are known as isolated names.
 * An isolated name may be a single label, such as john, or may be in
 * user principal name (UPN) form, such as john@example.com.
 */

#include <libmlrpc/ndrtypes.ndl>


#define	LSARPC_OPNUM_CloseHandle			0x00
#define	LSARPC_OPNUM_Delete				0x01
#define	LSARPC_OPNUM_EnumPrivileges			0x02
#define	LSARPC_OPNUM_QuerySecurityObject		0x03
#define	LSARPC_OPNUM_SetSecurityObject			0x04
#define	LSARPC_OPNUM_ChangePassword			0x05
#define	LSARPC_OPNUM_OpenPolicy				0x06
#define	LSARPC_OPNUM_QueryInfoPolicy			0x07
#define	LSARPC_OPNUM_SetInfoPolicy			0x08
#define	LSARPC_OPNUM_ClearAuditLog			0x09
#define	LSARPC_OPNUM_CreateAccount			0x0a
#define	LSARPC_OPNUM_EnumerateAccounts			0x0b
#define	LSARPC_OPNUM_CreateTrustedDomain		0x0c
#define	LSARPC_OPNUM_EnumTrustedDomain			0x0d
#define	LSARPC_OPNUM_LookupNames			0x0e
#define	LSARPC_OPNUM_LookupSids				0x0f
#define	LSARPC_OPNUM_CreateSecret			0x10
#define	LSARPC_OPNUM_OpenAccount			0x11
#define	LSARPC_OPNUM_EnumPrivsAccount			0x12
#define	LSARPC_OPNUM_AddAccountPrivs			0x13
#define	LSARPC_OPNUM_RemoveAccountPrivs			0x14
#define	LSARPC_OPNUM_GetAccountQuota			0x15
#define	LSARPC_OPNUM_SetAccountQuota			0x16
#define	LSARPC_OPNUM_GetSystemAccessAccount		0x17
#define	LSARPC_OPNUM_SetSystemAccessAccount		0x18
#define	LSARPC_OPNUM_OpenTrustedDomain			0x19
#define	LSARPC_OPNUM_QueryInfoTrustedDomain		0x1a
#define	LSARPC_OPNUM_SetinfoTrustedDomain		0x1b
#define	LSARPC_OPNUM_OpenSecret				0x1c
#define	LSARPC_OPNUM_SetSecret				0x1d
#define	LSARPC_OPNUM_QuerySecret			0x1e
#define	LSARPC_OPNUM_LookupPrivValue			0x1f
#define	LSARPC_OPNUM_LookupPrivName			0x20
#define	LSARPC_OPNUM_LookupPrivDisplayName		0x21
#define	LSARPC_OPNUM_DeleteObject			0x22
#define	LSARPC_OPNUM_EnumAccountsWithUserRight		0x23
#define	LSARPC_OPNUM_EnumAccountRights			0x24
#define	LSARPC_OPNUM_AddAccountRights			0x25
#define	LSARPC_OPNUM_RemoveAccountRights		0x26
#define	LSARPC_OPNUM_QueryTrustedDomainInfo		0x27
#define	LSARPC_OPNUM_SetTrustedDomainInfo		0x28

/* Windows 2000 */
#define	LSARPC_OPNUM_DeleteTrustedDomain		0x29
#define	LSARPC_OPNUM_StorePrivateData			0x2a
#define	LSARPC_OPNUM_RetrievePrivateData		0x2b
#define	LSARPC_OPNUM_OpenPolicy2			0x2c
#define	LSARPC_OPNUM_GetConnectedUser			0x2d
#define	LSARPC_OPNUM_QueryInfoPolicy2			0x2e
#define	LSARPC_OPNUM_SetInfoPolicy2			0x2f
#define	LSARPC_OPNUM_QueryTrustedDomainInfoByName	0x30
#define	LSARPC_OPNUM_SetTrustedDomainInfoByName		0x31
#define	LSARPC_OPNUM_EnumTrustedDomainsEx		0x32
#define	LSARPC_OPNUM_CreateTrustedDomainEx		0x33
#define	LSARPC_OPNUM_CloseTrustedDomainEx		0x34
#define	LSARPC_OPNUM_QueryDomainInfoPolicy		0x35
#define	LSARPC_OPNUM_SetDomainInfoPolicy		0x36
#define	LSARPC_OPNUM_OpenTrustedDomainByName		0x37
#define	LSARPC_OPNUM_TestCall				0x38
#define	LSARPC_OPNUM_LookupSids2			0x39
#define	LSARPC_OPNUM_LookupNames2			0x3a
#define	LSARPC_OPNUM_CreateTrustedDomainEx2		0x3b

/* Windows 2000 SP3 */
#define	LSARPC_OPNUM_CredWrite				0x3c
#define	LSARPC_OPNUM_CredRead				0x3d
#define	LSARPC_OPNUM_CredEnumerate			0x3e
#define	LSARPC_OPNUM_CredWriteDomainCreds		0x3f
#define	LSARPC_OPNUM_CredReadDomainCreds		0x40
#define	LSARPC_OPNUM_CredDelete				0x41
#define	LSARPC_OPNUM_CredGetTargetInfo			0x42
#define	LSARPC_OPNUM_CredProfileLoaded			0x43
#define	LSARPC_OPNUM_LookupNames3			0x44
#define	LSARPC_OPNUM_CredGetSessionTypes		0x45
#define	LSARPC_OPNUM_RegisterAuditEvent			0x46
#define	LSARPC_OPNUM_GenAuditEvent			0x47
#define	LSARPC_OPNUM_UnregisterAuditEvent		0x48
#define	LSARPC_OPNUM_QueryForestTrustInfo		0x49
#define	LSARPC_OPNUM_SetForestTrustInfo			0x4a
#define	LSARPC_OPNUM_CredRename				0x4b
#define	LSARPC_OPNUM_LookupSids3			0x4c
#define	LSARPC_OPNUM_LookupNames4			0x4d
#define	LSARPC_OPNUM_OpenPolicySce			0x4e

/* Windows Server 2003 */
#define	LSARPC_OPNUM_AdtRegisterSecurityEventSource	0x4f
#define	LSARPC_OPNUM_AdtUnregisterSecurityEventSource	0x50
#define	LSARPC_OPNUM_AdtReportSecurityEvent		0x51

/* Windows Vista */
#define	LSARPC_OPNUM_CredFindBestCredential		0x52
#define	LSARPC_OPNUM_SetAuditPolicy			0x53
#define	LSARPC_OPNUM_QueryAuditPolicy			0x54
#define	LSARPC_OPNUM_EnumerateAuditPolicy		0x55
#define	LSARPC_OPNUM_EnumerateAuditCategories		0x56
#define	LSARPC_OPNUM_EnumerateAuditSubCategories	0x57
#define	LSARPC_OPNUM_LookupAuditCategoryName		0x58
#define	LSARPC_OPNUM_LookupAuditSubCategoryName		0x59
#define	LSARPC_OPNUM_SetAuditSecurity			0x5a
#define	LSARPC_OPNUM_QueryAuditSecurity			0x5b
#define	LSARPC_OPNUM_CredReadByTokenHandle		0x5c
#define	LSARPC_OPNUM_CredRestoreCredentials		0x5d
#define	LSARPC_OPNUM_CredBackupCredentials		0x5e

/*
 * Lookup levels.  Level 1 appears to mean only look on the local host and
 * level 2 means forward the request to the PDC.  On the PDC it probably
 * doesn't matter which level you use but on a BDC a level 1 lookup will
 * fail if the BDC doesn't have the info whereas a level 2 lookup will also
 * check with the PDC.
 */
#define	LSA_LOOKUP_WKSTA			1	/* Windows NT 3.1 */
#define	LSA_LOOKUP_PDC				2
#define	LSA_LOOKUP_TDL				3
#define	LSA_LOOKUP_GC				4	/* Windows 2000 */
#define	LSA_LOOKUP_XFORESTREFERRAL		5	/* Windows XP */
#define	LSA_LOOKUP_XFORESTRESOLVE		6
#define	LSA_LOOKUP_RODCREFERRALTOFULLDC		7	/* Windows Vista */

/*
 * Name/SID lookup flags
 */
#define	LSA_LOOKUP_NAME_NOT_SPN			0x00000001
#define	LSA_LOOKUP_NAME_MAYBE_XFOREST		0x00000002
#define	LSA_LOOKUP_NAME_IN_DBVIEW		0x00000004

/*
 * Name/SID lookup options
 *
 * 0x00000000	Lookup isolated names both locally and in domains/forests.
 * 0x80000000	Lookup isolated names (except for UPNs) only in the local
 *		account database.  Do not lookup UPNs.
 */
#define	LSA_LOOKUP_OPT_ALL			0x00000000
#define	LSA_LOOKUP_OPT_LOCAL			0x80000000

/*
 * Client revision
 *
 * 0x00000001	Client does not understand DNS names or forests.
 * 0x00000002	Client understands DNS names and forests.
 *
 * Notes:
 *	0 means the same as 1
 *	Anything greater than 2 means the same as 2
 */
#define	LSA_CLIENT_REVISION_NT			0x00000001
#define	LSA_CLIENT_REVISION_AD			0x00000002

/*
 * Definition for a SID. The ndl compiler won't allow a typedef of
 * a structure containing variable size members.
 */
struct mslsa_sid {
	BYTE		Revision;
	BYTE		SubAuthCount;
	BYTE		Authority[6];
  SIZE_IS(SubAuthCount)
	DWORD		SubAuthority[ANY_SIZE_ARRAY];
};

struct mslsa_string_desc {
	WORD		length;
	WORD		allosize;
	LPTSTR		str;
};
typedef struct mslsa_string_desc mslsa_string_t;

CONTEXT_HANDLE(mslsa_handle) mslsa_handle_t;

struct mslsa_luid {
	DWORD low_part;
	DWORD high_part;
};
typedef struct mslsa_luid mslsa_luid_t;

struct mslsa_guid {
	DWORD	data1;
	WORD	data2;
	WORD	data3;
	BYTE	data4[8];
};
typedef struct mslsa_guid mslsa_guid_t;

/*
 ***********************************************************************
 * OpenPolicy2 obtains a handle for a remote LSA. This handle is
 * required for all subsequent LSA requests.
 *
 * The server name should be the name of the target PDC or BDC, with
 * the double backslash prefix.
 *
 * As far as I can tell, the mslsa_object_attributes structure can be
 * all zero except for the length, which should be set to sizeof(struct
 * mslsa_object_attributes).
 *
 * For read access, the desired access mask should contain the
 * READ_CONTROL standard right and whatever policy rights are required.
 * I haven't tried any update operations but if you get the access mask
 * wrong you can crash the domain controller.
 ***********************************************************************
 */


/*
 * From netmon:
 *	length = 12
 *	impersonation_level = 2
 *	context_tracking_mode = 1
 *	effective_only = 0
 */
struct mslsa_quality_of_service {
	DWORD length;
	WORD impersonation_level;
	BYTE context_tracking_mode;
	BYTE effective_only;
};


struct mslsa_object_attributes {
	DWORD length;
	DWORD rootDirectory;
	DWORD objectName;
	DWORD attributes;
	DWORD securityDescriptor;
	struct mslsa_quality_of_service *qualityOfService;
};


OPERATION(LSARPC_OPNUM_OpenPolicy)
struct mslsa_OpenPolicy {
	IN	DWORD	*servername;
	IN	struct mslsa_object_attributes attributes;
	IN	DWORD desiredAccess;
	OUT	mslsa_handle_t domain_handle;
	OUT	DWORD status;
};

OPERATION(LSARPC_OPNUM_OpenPolicy2)
struct mslsa_OpenPolicy2 {
	IN	LPTSTR servername;
	IN	struct mslsa_object_attributes attributes;
	IN	DWORD desiredAccess;
	OUT	mslsa_handle_t domain_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * CloseHandle closes an association with the LSA. The returned handle
 * will be all zero.
 ***********************************************************************
 */
OPERATION(LSARPC_OPNUM_CloseHandle)
struct mslsa_CloseHandle {
	IN	mslsa_handle_t handle;
	OUT	mslsa_handle_t result_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * EnumPrivileges
 *
 * Obtain a list of privilege names. This interface is not implemented
 * yet The definition below has not been tested. This is a guess based
 * on data available from netmon.
 ***********************************************************************
 */
struct mslsa_PrivDef {
	mslsa_string_t name;
	mslsa_luid_t luid;
};


struct mslsa_PrivEnumBuf {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslsa_PrivDef *def;
};


OPERATION(LSARPC_OPNUM_EnumPrivileges)
struct mslsa_EnumPrivileges {
	IN	mslsa_handle_t handle;
	INOUT	DWORD enum_context;
	IN	DWORD max_length;
	OUT	REFERENCE struct mslsa_PrivEnumBuf *enum_buf;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QuerySecurityObject. I'm not entirely sure how to set this up yet.
 * I used the discovery RPC to scope it out. The structures are set up
 * according to netmon and the assumption that a security descriptor
 * on the wire looks like the regular user level security descriptor.
 ***********************************************************************
 */
struct mslsa_SecurityDescriptor {
	BYTE revision;
	BYTE sbz1;
	WORD control;
	DWORD owner;
	DWORD group;
	DWORD sacl;
	DWORD dacl;
};


struct mslsa_SecurityDescInfo {
	DWORD length;
  SIZE_IS(length)
  	BYTE *desc; /* temporary */
	/* struct mslsa_SecurityDescriptor *desc; */
};


OPERATION(LSARPC_OPNUM_QuerySecurityObject)
struct mslsa_QuerySecurityObject {
	IN	mslsa_handle_t handle;
	IN	DWORD security_info;
	OUT	struct mslsa_SecurityDescInfo *desc_info;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * EnumerateAccounts and EnumerateTrustedDomain.
 ***********************************************************************
 */
struct mslsa_AccountInfo {
	struct mslsa_sid *sid;
};


struct mslsa_EnumAccountBuf {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslsa_AccountInfo *info;
};


OPERATION(LSARPC_OPNUM_EnumerateAccounts)
struct mslsa_EnumerateAccounts {
	IN	mslsa_handle_t handle;
	INOUT	DWORD enum_context;
	IN	DWORD max_length;
	OUT	REFERENCE struct mslsa_EnumAccountBuf *enum_buf;
	OUT	DWORD status;
};


struct mslsa_TrustedDomainInfo {
	mslsa_string_t name;
	struct mslsa_sid *sid;
};


struct mslsa_EnumTrustedDomainBuf {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslsa_TrustedDomainInfo *info;
};


OPERATION(LSARPC_OPNUM_EnumTrustedDomain)
struct mslsa_EnumTrustedDomain {
	IN	mslsa_handle_t handle;
	INOUT	DWORD enum_context;
	IN	DWORD max_length;
	OUT REFERENCE	struct mslsa_EnumTrustedDomainBuf *enum_buf;
	OUT	DWORD status;
};

struct mslsa_TrustedDomainInfoEx {
	mslsa_string_t		dns_name;
	mslsa_string_t		nb_name;
	struct mslsa_sid	*sid;
	DWORD			trust_direction;
	DWORD			trust_type;
	DWORD			trust_attrs;
};

struct mslsa_EnumTrustedDomainBufEx {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslsa_TrustedDomainInfoEx *info;
};

OPERATION(LSARPC_OPNUM_EnumTrustedDomainsEx)
struct mslsa_EnumTrustedDomainEx {
	IN	mslsa_handle_t handle;
	INOUT	DWORD enum_context;
	IN	DWORD max_length;
	OUT REFERENCE	struct mslsa_EnumTrustedDomainBufEx *enum_buf;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * Definitions common to both LookupSids and LookupNames. Both return
 * an mslsa_domain_table[]. Each interface also returns a specific
 * table with entries which index the mslsa_domain_table[].
 ***********************************************************************
 */
struct mslsa_domain_entry {
	mslsa_string_t domain_name;
	struct mslsa_sid *domain_sid;
};
typedef struct mslsa_domain_entry mslsa_domain_entry_t;


struct mslsa_domain_table {
	DWORD		n_entry;
  SIZE_IS(n_entry)
  	mslsa_domain_entry_t *entries;
	DWORD		max_n_entry;
};


/*
 ***********************************************************************
 * Definitions for LookupSids.
 *
 * The input parameters are:
 *
 *	A valid LSA handle obtained from an LsarOpenPolicy.
 *	The table of SIDs to be looked up.
 *	A table of names (probably empty).
 *	The lookup level (local=1 or PDC=2).
 *	An enumeration counter (used for continuation operations).
 *
 * The output results are:
 *
 *	A table of referenced domains.
 *	A table of usernames.
 *	The updated value of the enumeration counter.
 *	The result status.
 ***********************************************************************
 */

struct mslsa_lup_sid_entry {
	struct mslsa_sid *psid;
};

struct mslsa_lup_sid_table {
	DWORD		n_entry;
    SIZE_IS(n_entry)
	struct mslsa_lup_sid_entry *entries;
};

struct mslsa_name_entry {
	WORD		sid_name_use;
	WORD		unknown_flags;
	mslsa_string_t	name;
	DWORD		domain_ix;		/* -1 means none */
};

struct mslsa_name_table {
	DWORD		n_entry;
    SIZE_IS(n_entry)
	struct mslsa_name_entry *entries;
};

OPERATION(LSARPC_OPNUM_LookupSids)
struct mslsa_LookupSids {
	IN	mslsa_handle_t	handle;
	IN	struct mslsa_lup_sid_table lup_sid_table;

	OUT	struct mslsa_domain_table *domain_table;
	INOUT	struct mslsa_name_table name_table;

	IN	WORD lookup_level;
	INOUT	DWORD mapped_count;
 	OUT	DWORD status;
};

OPERATION(LSARPC_OPNUM_CreateSecret)
struct mslsa_CreateSecret {
	IN	mslsa_handle_t handle;
	IN	mslsa_string_t name;
	IN	DWORD access_mask;
	OUT	mslsa_handle_t secret_handle;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * Definitions for LookupNames.
 *
 * LookupNames requires the following input parameters.
 *
 *	A valid LSA handle obtained from an LsarOpenPolicy.
 *	The table of names to be looked up.
 *	A table of translated sids (probably empty).
 *	The lookup level (local=1 or PDC=2).
 *	An enumeration counter (used for continuation operations).
 *
 * The outputs are as follows.
 *
 *	A table of referenced domains.
 *	A table of translated sids (actually rids).
 *	The updated value of the enumeration counter.
 *	The result status.
 ***********************************************************************
 */
struct mslsa_lup_name_table {
	DWORD n_entry;
  SIZE_IS(n_entry)
	mslsa_string_t names[ANY_SIZE_ARRAY];
};


struct mslsa_rid_entry {
	WORD sid_name_use;
	WORD pad;
	DWORD rid;
	DWORD domain_index;
};


struct mslsa_rid_table {
	DWORD n_entry;
  SIZE_IS(n_entry)
	struct mslsa_rid_entry *rids;
};


OPERATION(LSARPC_OPNUM_LookupNames)
struct mslsa_LookupNames {
	IN	mslsa_handle_t handle;
	IN	REFERENCE	struct mslsa_lup_name_table *name_table;

	OUT	struct mslsa_domain_table *domain_table;
	INOUT	struct mslsa_rid_table translated_sids;

	IN	WORD lookup_level;
	INOUT	DWORD mapped_count;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QueryInfoPolicy returns various pieces of policy information. The
 * desired information is specified using a class value, as defined
 * below.
 ***********************************************************************
 */
#define MSLSA_POLICY_AUDIT_LOG_INFO		1
#define MSLSA_POLICY_AUDIT_EVENTS_INFO		2
#define MSLSA_POLICY_PRIMARY_DOMAIN_INFO	3
#define MSLSA_POLICY_UNKNOWN_4_INFO		4
#define MSLSA_POLICY_ACCOUNT_DOMAIN_INFO	5
#define MSLSA_POLICY_SERVER_ROLE_INFO		6
#define MSLSA_POLICY_REPLICA_SOURCE_INFO	7
#define MSLSA_POLICY_DEFAULT_QUOTA_INFO		8
#define MSLSA_POLICY_DB_INFO			9
#define MSLSA_POLICY_AUDIT_SET_INFO		10
#define MSLSA_POLICY_AUDIT_QUERY_INFO		11
#define MSLSA_POLICY_DNS_DOMAIN_INFO		12

#define	LSA_ROLE_STANDALONE_WORKSTATION		0
#define	LSA_ROLE_MEMBER_WORKSTATION		1
#define	LSA_ROLE_STANDALONE_SERVER		2
#define	LSA_ROLE_MEMBER_SERVER			3
#define	LSA_ROLE_BACKUP_DC			4
#define	LSA_ROLE_PRIMARY_DC			5

/*
 * MSLSA_POLICY_AUDIT_EVENTS_INFO
 */
struct mslsa_AuditEventsInfo {
	DWORD enabled;
    SIZE_IS (count)
	DWORD *settings;
	DWORD count;
};

/*
 * MSLSA_POLICY_PRIMARY_DOMAIN_INFO
 */
struct mslsa_PrimaryDomainInfo {
	struct mslsa_string_desc name;
	struct mslsa_sid *sid;
};

/*
 * MSLSA_POLICY_ACCOUNT_DOMAIN_INFO
 */
struct mslsa_AccountDomainInfo {
	struct mslsa_string_desc name;
	struct mslsa_sid *sid;
};

/*
 * MSLSA_POLICY_SERVER_ROLE_INFO
 */
struct mslsa_ServerRoleInfo {
	DWORD role;
	DWORD pad;
};

struct mslsa_DnsDomainInfo {
	struct mslsa_string_desc nb_domain;
	struct mslsa_string_desc dns_domain;
	struct mslsa_string_desc forest;
	struct mslsa_guid guid;
	struct mslsa_sid *sid;
};

union mslsa_PolicyInfoResUnion {
	CASE(2) struct mslsa_AuditEventsInfo audit_events;
	CASE(3) struct mslsa_PrimaryDomainInfo pd_info;
	CASE(5) struct mslsa_AccountDomainInfo ad_info;
	CASE(6) struct mslsa_ServerRoleInfo server_role;
	CASE(12) struct mslsa_DnsDomainInfo dns_info;
	DEFAULT	char *nullptr;
};

/*
 * This structure needs to be declared, even though it can't be used in
 * mslsa_QueryInfoPolicy, in order to get the appropriate size to calculate
 * the correct fixup offsets.  If ndrgen did the right thing,
 * mslsa_PolicyInfoRes would be one of the out parameters.  However, if
 * we do it that way, the switch_value isn't known early enough to do
 * the fixup calculation.  So it all has to go in mslsa_QueryInfoPolicy.
 */
struct mslsa_PolicyInfoRes {
	DWORD address;
	WORD switch_value;
    SWITCH(switch_value)
	union mslsa_PolicyInfoResUnion ru;
};

OPERATION(LSARPC_OPNUM_QueryInfoPolicy)
struct mslsa_QueryInfoPolicy {
	IN	mslsa_handle_t handle;
	IN	WORD info_class;
	/*
	 * Can't use this form because we need to include members explicitly.
	 * OUT	struct mslsa_PolicyInfoRes result;
	 */
	OUT	DWORD address;
	OUT	WORD switch_value;
    SWITCH(switch_value)
	OUT	union mslsa_PolicyInfoResUnion ru;
	OUT	DWORD status;
};



/*
 ***********************************************************************
 * OpenAccount.
 * 
 * Returns a handle that can be used to access the account specified
 * by a SID. This handle can be used to enumerate account privileges.
 ***********************************************************************
 */
OPERATION(LSARPC_OPNUM_OpenAccount)
struct mslsa_OpenAccount {
	IN  mslsa_handle_t handle;
	IN REFERENCE	struct mslsa_sid *sid;
	IN	DWORD access_mask;
	OUT mslsa_handle_t account_handle;
	OUT DWORD status;
};



 /*
 ***********************************************************************
 * EnumPrivilegesAccount.
 *
 * Enumerate the list of privileges held by the specified account. The
 * handle must be a valid account handle obtained via OpenAccount. The
 * luid values returned will be probably only be relevant on the domain
 * controller so we'll need to find a way to convert them to the
 * actual privilege names.
 ***********************************************************************
 */
struct mslsa_LuidAndAttributes {
	struct mslsa_luid luid;
	DWORD attributes;
};


struct mslsa_PrivilegeSet {
	DWORD privilege_count;
	DWORD control;
  SIZE_IS(privilege_count)
	struct mslsa_LuidAndAttributes privilege[ANY_SIZE_ARRAY];
};


OPERATION(LSARPC_OPNUM_EnumPrivsAccount)
	struct mslsa_EnumPrivsAccount {
	IN	mslsa_handle_t account_handle;
	OUT	struct mslsa_PrivilegeSet *privileges;
	OUT	DWORD status;
};

OPERATION(LSARPC_OPNUM_OpenSecret)
struct mslsa_OpenSecret {
	IN	mslsa_handle_t handle;
	IN	mslsa_string_t name;
	IN	DWORD access_mask;
	OUT	mslsa_handle_t secret_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LookupPrivValue
 *
 * Map a privilege name to a local unique id (LUID). Privilege names
 * are consistent across the network. LUIDs are machine specific.
 * The privilege list is provided as a set of LUIDs so the privilege
 * lookup functions must be used to identify which the privilege to
 * which each LUID refers. The handle here is a policy handle.
 ***********************************************************************
 */
OPERATION(LSARPC_OPNUM_LookupPrivValue)
struct mslsa_LookupPrivValue {
	IN	mslsa_handle_t handle;
	IN	mslsa_string_t name;
	OUT	struct mslsa_luid luid;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LookupPrivName
 *
 * Map a privilege value (LUID) to a privilege name. Privilege names
 * are consistent across the network. LUIDs are machine specific.
 * The privilege list is provided as a set of LUIDs so the privilege
 * lookup functions must be used to identify which the privilege to
 * which each LUID refers. The handle here is a policy handle.
 ***********************************************************************
 */
OPERATION(LSARPC_OPNUM_LookupPrivName)
struct mslsa_LookupPrivName {
	IN	mslsa_handle_t handle;
	IN	struct mslsa_luid luid;
	OUT	mslsa_string_t *name;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LookupPrivDisplayName
 *
 * Map a privilege name to a local unique id (LUID). Privilege names
 * are consistent across the network. LUIDs are machine specific.
 * The privilege list is provided as a set of LUIDs so the privilege
 * lookup functions must be used to identify which the privilege to
 * which each LUID refers. The handle here is a policy handle.
 ***********************************************************************
 */
OPERATION(LSARPC_OPNUM_LookupPrivDisplayName)
struct mslsa_LookupPrivDisplayName {
	IN	mslsa_handle_t handle;
	IN	mslsa_string_t name;
	IN	WORD client_language;
	IN	WORD default_language;
	OUT	mslsa_string_t *display_name;
	OUT	WORD language_ret;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * GetConnectedUser
 *
 * Return the account name and NetBIOS domain name for the user making
 * the request.  All input fields should be ignored by the server.
 ***********************************************************************
 */
struct mslsa_DomainName {
	struct mslsa_string_desc *name;
};


OPERATION(LSARPC_OPNUM_GetConnectedUser)
struct mslsa_GetConnectedUser {
	IN	LPTSTR hostname;
	IN	BYTE *owner_in;
	IN	BYTE *domain_in;
	OUT	struct mslsa_string_desc *owner;
	OUT	struct mslsa_DomainName *domain;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LSARPC_OPNUM_LookupSids2
 *
 * SID lookup function that appeared in Windows 2000. It appears to be
 * very similar to the original SID lookup RPC. There are two extra IN 
 * parameters, which we don't care about. The OUT name structure has
 * an extra field, in which zero seems to be okay.
 ***********************************************************************
 */
struct lsar_name_entry2 {
	WORD sid_name_use;
	WORD padding;
	mslsa_string_t name;
	DWORD domain_ix;	/* -1 means none */
	DWORD flags;
};
typedef struct lsar_name_entry2 lsar_translated_name_ex_t;

struct lsar_name_table2 {
	DWORD n_entry;
  SIZE_IS(n_entry)
	struct lsar_name_entry2 *entries;
};
typedef struct lsar_name_table2 lsar_translated_names_ex_t;

OPERATION(LSARPC_OPNUM_LookupSids2)
struct lsar_lookup_sids2 {
	IN		mslsa_handle_t policy_handle;
	IN		struct mslsa_lup_sid_table lup_sid_table;
	OUT		struct mslsa_domain_table *domain_table;
	INOUT	struct lsar_name_table2 name_table;
	IN		WORD lookup_level;
	INOUT	DWORD mapped_count;
	IN		DWORD lookup_options;
	IN		DWORD client_revision;
 	OUT		DWORD status;
};

OPERATION(LSARPC_OPNUM_LookupSids3)
struct lsar_lookup_sids3 {
	IN		struct mslsa_lup_sid_table	lup_sid_table;
	OUT		struct mslsa_domain_table	*domain_table;
	INOUT		lsar_translated_names_ex_t	name_table;
	IN		WORD				lookup_level;
	INOUT		DWORD				mapped_count;
	IN		DWORD				lookup_options;
	IN		DWORD				client_revision;
 	OUT		DWORD				status;
};

/*
 ***********************************************************************
 * LSARPC_OPNUM_LookupNames2
 *
 * Name lookup function that appeared in Windows 2000. It appears to be
 * very similar to the original name lookup RPC. There are two extra IN 
 * parameters, which we don't care about. The lsar_rid_entry2 structure
 * has an extra field, in which zero seems to be okay.
 ***********************************************************************
 */
struct lsar_rid_entry2 {
	WORD sid_name_use;
	WORD pad;
	DWORD rid;
	DWORD domain_index;	/* -1 means none */
	DWORD flags;
};


struct lsar_rid_table2 {
	DWORD n_entry;
  SIZE_IS(n_entry)
	struct lsar_rid_entry2 *rids;
};


OPERATION(LSARPC_OPNUM_LookupNames2)
struct lsar_LookupNames2 {
	IN		mslsa_handle_t policy_handle;
	IN	REFERENCE	struct mslsa_lup_name_table *name_table;
	OUT		struct mslsa_domain_table *domain_table;
	INOUT	struct lsar_rid_table2 translated_sids;
	IN		WORD lookup_level;
	INOUT	DWORD mapped_count;
	IN		DWORD lookup_options;
	IN		DWORD client_revision;
	OUT		DWORD status;
};

struct lsar_translated_sid_ex2 {
	WORD			sid_name_use;
	WORD			pad;
	struct mslsa_sid	*sid;
	DWORD			domain_index;	/* -1 means none */
	DWORD			flags;
};
typedef struct lsar_translated_sid_ex2 lsar_translated_sid_ex2_t;

struct lsar_sid_ex2_table {
	DWORD			n_entry;
  SIZE_IS(n_entry)
	struct lsar_translated_sid_ex2	*sids;
};
typedef struct lsar_sid_ex2_table lsar_sid_ex2_table_t;

OPERATION(LSARPC_OPNUM_LookupNames3)
struct lsar_LookupNames3 {
	IN		mslsa_handle_t			policy_handle;
	IN REFERENCE	struct mslsa_lup_name_table	*name_table;
	OUT		struct mslsa_domain_table	*domain_table;
	INOUT		struct lsar_sid_ex2_table	translated_sids;
	IN		WORD				lookup_level;
	INOUT		DWORD				mapped_count;
	IN		DWORD				lookup_options;
	IN		DWORD				client_revision;
	OUT		DWORD				status;
};

OPERATION(LSARPC_OPNUM_LookupNames4)
struct lsar_LookupNames4 {
	IN REFERENCE	struct mslsa_lup_name_table	*name_table;
	OUT		struct mslsa_domain_table	*domain_table;
	INOUT		struct lsar_sid_ex2_table	translated_sids;
	IN		WORD				lookup_level;
	INOUT		DWORD				mapped_count;
	IN		DWORD				lookup_options;
	IN		DWORD				client_revision;
	OUT		DWORD				status;
};

/*
 ***********************************************************************
 * The LSARPC interface definition.
 ***********************************************************************
 */
INTERFACE(0)
union lsarpc_interface {
	CASE(LSARPC_OPNUM_CloseHandle)
		struct mslsa_CloseHandle		CloseHandle;
	CASE(LSARPC_OPNUM_QuerySecurityObject)
		struct mslsa_QuerySecurityObject	QuerySecurityObj;
	CASE(LSARPC_OPNUM_EnumerateAccounts)
		struct mslsa_EnumerateAccounts		EnumAccounts;
	CASE(LSARPC_OPNUM_EnumTrustedDomainsEx)
		struct mslsa_EnumTrustedDomainEx	EnumTrustedDomainEx;
	CASE(LSARPC_OPNUM_EnumTrustedDomain)
		struct mslsa_EnumTrustedDomain		EnumTrustedDomain;
	CASE(LSARPC_OPNUM_OpenAccount)
		struct mslsa_OpenAccount		OpenAccount;
	CASE(LSARPC_OPNUM_EnumPrivsAccount)
		struct mslsa_EnumPrivsAccount		EnumPrivsAccount;
	CASE(LSARPC_OPNUM_LookupPrivValue)
		struct mslsa_LookupPrivValue		LookupPrivValue;
	CASE(LSARPC_OPNUM_LookupPrivName)
		struct mslsa_LookupPrivName		LookupPrivName;
	CASE(LSARPC_OPNUM_LookupPrivDisplayName)
		struct mslsa_LookupPrivDisplayName	LookupPrivDisplayName;
	CASE(LSARPC_OPNUM_CreateSecret)
		struct mslsa_CreateSecret		CreateSecret;
	CASE(LSARPC_OPNUM_OpenSecret)
		struct mslsa_OpenSecret			OpenSecret;
	CASE(LSARPC_OPNUM_QueryInfoPolicy)
		struct mslsa_QueryInfoPolicy		QueryInfoPolicy;
	CASE(LSARPC_OPNUM_OpenPolicy)
		struct mslsa_OpenPolicy			OpenPolicy;
	CASE(LSARPC_OPNUM_OpenPolicy2)
		struct mslsa_OpenPolicy2		OpenPolicy2;
	CASE(LSARPC_OPNUM_LookupSids)
		struct mslsa_LookupSids			LookupSids;
	CASE(LSARPC_OPNUM_LookupNames)
		struct mslsa_LookupNames		LookupNames;
	CASE(LSARPC_OPNUM_GetConnectedUser)
		struct mslsa_GetConnectedUser		GetConnectedUser;
	CASE(LSARPC_OPNUM_LookupSids2)
		struct lsar_lookup_sids2		LookupSids2;
	CASE(LSARPC_OPNUM_LookupSids3)
		struct lsar_lookup_sids3		LookupSids3;
	CASE(LSARPC_OPNUM_LookupNames2)
		struct lsar_LookupNames2		LookupNames2;
	CASE(LSARPC_OPNUM_LookupNames3)
		struct lsar_LookupNames3		LookupNames3;
	CASE(LSARPC_OPNUM_LookupNames4)
		struct lsar_LookupNames4		LookupNames4;
};
typedef union lsarpc_interface	lsarpc_interface_t;
EXTERNTYPEINFO(lsarpc_interface)

#endif /* _MLSVC_LSA_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MSGSVC_NDL_
#define	_MSGSVC_NDL_

/*
 * Message Service
 */

#include <libmlrpc/ndrtypes.ndl>

#define	MSGSVCSEND_OPNUM_NetrSendMessage	0x00

struct msgsvc_uuid {
	DWORD	data1;
	WORD	data2;
	WORD	data3;
	BYTE	data4[8];
};
typedef struct msgsvc_uuid msgsvc_uuid_t;

OPERATION(MSGSVCSEND_OPNUM_NetrSendMessage)
struct msgsvcsend_NetrSendMessage {
	IN	msgsvc_uuid_t handle;
	IN	LPTSTR from;
	IN	LPTSTR to;
	IN	LPTSTR text;
	OUT	DWORD status;
};
typedef struct msgsvcsend_NetrSendMessage msgsvcsend_NetrSendMessage_t;


/*
 ***********************************************************************
 * MSGSVC interface definiton.
 ***********************************************************************
 */
INTERFACE(0)
union msgsvcsend_interface {
	CASE(MSGSVCSEND_OPNUM_NetrSendMessage)
		struct msgsvcsend_NetrSendMessage NetrSendMessage;
};
typedef union msgsvcsend_interface msgsvcsend_interface_t;
EXTERNTYPEINFO(msgsvcsend_interface)

#endif /* _MSGSVC_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _NETDFS_NDL_
#define	_NETDFS_NDL_

/*
 * NT Distributed File Service (NETDFS) RPC interface definition.
 */

#include <libmlrpc/ndrtypes.ndl>


#define	NETDFS_ABSTRACT_UUID		"4fc742e0-4a10-11cf-8273-00aa004ae673"
#define	NETDFS_ABSTRACT_VERS		3

#define	NETDFS_TRANSFER_UUID		"8a885d04-1ceb-11c9-9fe8-08002b104860"
#define	NETDFS_TRANSFER_VERS		2

#define	NETDFS_OPNUM_GETVER		0x00
#define	NETDFS_OPNUM_ADD		0x01
#define	NETDFS_OPNUM_REMOVE		0x02
#define	NETDFS_OPNUM_SETINFO		0x03
#define	NETDFS_OPNUM_GETINFO		0x04
#define	NETDFS_OPNUM_ENUM		0x05
#define	NETDFS_OPNUM_MOVE		0x06
#define	NETDFS_OPNUM_RENAME		0x07
#define	NETDFS_OPNUM_ADDSTDROOT		0x0c
#define	NETDFS_OPNUM_REMSTDROOT		0x0d
#define	NETDFS_OPNUM_ENUMEX		0x15

#define	DFS_MANAGER_VERSION_NT4		0x01
#define	DFS_MANAGER_VERSION_W2K		0x02
#define	DFS_MANAGER_VERSION_W2K3	0x04

struct netdfs_uuid {
	DWORD data1;
	WORD data2;
	WORD data3;
	BYTE data4[8];
};
typedef struct netdfs_uuid netdfs_uuid_t;

struct netdfs_storage_info {
	DWORD state;
	LPTSTR server;
	LPTSTR share;
};
typedef struct netdfs_storage_info netdfs_storage_info_t;


struct netdfs_storage_info1 {
	DWORD state;
	LPTSTR server;
	LPTSTR share;
	DWORD p_class;
	WORD p_rank;
	WORD p_reserved;
};
typedef struct netdfs_storage_info1 netdfs_storage_info1_t;

struct netdfs_info1 {
	LPTSTR entry_path;
};
typedef struct netdfs_info1 netdfs_info1_t;

struct netdfs_info2 {
	LPTSTR entry_path;
	LPTSTR comment;
	DWORD state;
	DWORD n_store;
};
typedef struct netdfs_info2 netdfs_info2_t;

struct netdfs_info3 {
	LPTSTR entry_path;
	LPTSTR comment;
	DWORD state;
	DWORD n_store;
  SIZE_IS(n_store)
	struct netdfs_storage_info *si;
};
typedef struct netdfs_info3 netdfs_info3_t;

struct netdfs_info4 {
	LPTSTR entry_path;
	LPTSTR comment;
	DWORD state;
	DWORD timeout;
	netdfs_uuid_t guid;
	DWORD n_store;
  SIZE_IS(n_store)
	struct netdfs_storage_info *si;
};
typedef struct netdfs_info4 netdfs_info4_t;

struct netdfs_info5 {
	LPTSTR entry_path;
	LPTSTR comment;
	DWORD state;
	DWORD timeout;
	netdfs_uuid_t guid;
	DWORD flags;
	DWORD metadata_sz;
	DWORD n_store;
};
typedef struct netdfs_info5 netdfs_info5_t;

struct netdfs_info6 {
	LPTSTR entry_path;
	LPTSTR comment;
	DWORD state;
	DWORD timeout;
	netdfs_uuid_t guid;
	DWORD flags;
	DWORD metadata_sz;
	DWORD n_store;
  SIZE_IS(n_store)
	struct netdfs_storage_info1 *si;
};
typedef struct netdfs_info6 netdfs_info6_t;

struct netdfs_info100 {
	LPTSTR comment;
};
typedef struct netdfs_info100 netdfs_info100_t;

struct netdfs_info101 {
	DWORD state;
};
typedef struct netdfs_info101 netdfs_info101_t;


struct netdfs_info102 {
	DWORD timeout;
};
typedef struct netdfs_info102 netdfs_info102_t;


struct netdfs_info103 {
	DWORD property_flag_mask;
	DWORD property_flags;
};
typedef struct netdfs_info103 netdfs_info103_t;


struct netdfs_info104 {
	DWORD priority_class;
	WORD priority_rank;
	WORD reserved;
};
typedef struct netdfs_info104 netdfs_info104_t;


struct netdfs_info105 {
	LPTSTR comment;
	DWORD state;
	DWORD timeout;
	DWORD property_flag_mask;
	DWORD property_flags;
};
typedef struct netdfs_info105 netdfs_info105_t;


struct netdfs_info106 {
	DWORD storage_state;
	DWORD priority_class;
	DWORD priority_rank;
};


struct netdfs_info200 {
	LPTSTR entry_path;
};


struct netdfs_info300 {
	DWORD flavor;
	LPTSTR dfsname;
};
typedef struct netdfs_info300 netdfs_info300_t;


union netdfs_info_u {
        CASE(1) struct netdfs_info1 *info1;
	CASE(2) struct netdfs_info2 *info2;
	CASE(3) struct netdfs_info3 *info3;
	CASE(4) struct netdfs_info4 *info4;
	CASE(5) struct netdfs_info5 *info5;
	CASE(6) struct netdfs_info6 *info6;
	CASE(100) struct netdfs_info100 *info100;
	CASE(101) struct netdfs_info101 *info101;
	CASE(102) struct netdfs_info102 *info102;
	CASE(103) struct netdfs_info103 *info103;
	CASE(104) struct netdfs_info104 *info104;
	CASE(105) struct netdfs_info105 *info105;
	CASE(106) struct netdfs_info106 *info106;
	DEFAULT char *nullptr;
};


struct netdfs_info {
	DWORD level;
  SWITCH(level)
	union netdfs_info_u iu;
};
typedef struct netdfs_info netdfs_info_t;


struct netdfs_array1 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info1 *info1;
};

struct netdfs_array2 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info2 *info2;
};

struct netdfs_array3 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info3 *info3;
};

struct netdfs_array4 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info4 *info4;
};

struct netdfs_array5 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info5 *info5;
};

struct netdfs_array6 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info6 *info6;
};

struct netdfs_array200 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info200 *info200;
};

struct netdfs_array300 {
	DWORD count;
  SIZE_IS(count)
	struct netdfs_info300 *info300;
};

union netdfs_enum_info_u {
	CASE(1) struct netdfs_array1 *info1;
	CASE(2) struct netdfs_array2 *info2;
	CASE(3) struct netdfs_array3 *info3;
	CASE(4) struct netdfs_array4 *info4;
	CASE(5) struct netdfs_array5 *info5;
	CASE(6) struct netdfs_array6 *info6;
	CASE(200) struct netdfs_array200 *info200;
	CASE(300) struct netdfs_array300 *info300;
	DEFAULT char *nullptr;
};


struct netdfs_enum_info {
	DWORD level;
	DWORD switch_value;
  SWITCH(switch_value)
	union netdfs_enum_info_u iu;
};


/*
 ***********************************************************************
 * Return server version id
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_GETVER)
struct netdfs_getver {
	OUT		DWORD version;
};


/*
 ***********************************************************************
 * Add a new volume or additional storage for an existing volume at
 * dfs_path.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_ADD)
struct netdfs_add {
	IN REFERENCE	LPTSTR dfs_path;
	IN REFERENCE	LPTSTR server;
	IN		LPTSTR share;
	IN		LPTSTR comment;
	IN		DWORD flags;
	OUT		DWORD status;
};
typedef struct netdfs_add netdfs_add_t;


/*
 ***********************************************************************
 * Remove a volume or additional storage for volume from the DFS at
 * dfs_path. When applied to the last storage in a volume, removes
 * the volume from the DFS.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_REMOVE)
struct netdfs_remove {
	IN REFERENCE	LPTSTR dfs_path;
	IN		LPTSTR server;
	IN		LPTSTR share;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * Set information about the volume or storage. If the server and share
 * are specified, the information set is specific to that server and
 * share. Otherwise the information is specific to the volume as a whole.
 *
 * Valid levels are 100-102.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_SETINFO)
struct netdfs_setinfo {
	IN REFERENCE	LPTSTR dfs_path;
	IN		LPTSTR server;
	IN		LPTSTR share;
	IN		DWORD level;
	IN		struct netdfs_info info;
	OUT		DWORD status;
};
typedef struct netdfs_setinfo netdfs_setinfo_t;


/*
 ***********************************************************************
 * Get information about the volume or storage. If the server and share
 * are specified, the information returned is specific to that server
 * and share. Otherwise the information is specific to the volume as a
 * whole.
 *
 * Valid levels are 1-4, 100-102.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_GETINFO)
struct netdfs_getinfo {
	IN REFERENCE	LPTSTR dfs_path;
	IN		LPTSTR server;
	IN		LPTSTR share;
	IN		DWORD level;
	OUT		struct netdfs_info info;
	OUT		DWORD status;
};
typedef struct netdfs_getinfo netdfs_getinfo_t;


/*
 ***********************************************************************
 * Get information about all of the volumes in the DFS. dfs_path is
 * the "server" part of the UNC name used to refer to this particular
 * DFS.
 *
 * Valid levels are 1-3.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_ENUM)
struct netdfs_enum {
	IN		DWORD level;
	IN		DWORD pref_max_len;
	INOUT		struct netdfs_enum_info *info;
	INOUT		DWORD *resume_handle;
	OUT		DWORD status;
};
typedef struct netdfs_enum netdfs_enum_t;


/*
 ***********************************************************************
 * Rename the current Win32 path in a DFS to a new Win32 path in the
 * same DFS.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_RENAME)
struct netdfs_rename {
	IN REFERENCE	LPTSTR dfs_path;
	IN REFERENCE	LPTSTR new_path;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * Move a DFS volume and all subordinate volumes from one place in the
 * DFS to another place in the DFS.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_MOVE)
struct netdfs_move {
	IN REFERENCE	LPTSTR dfs_path;
	IN REFERENCE	LPTSTR new_path;
	IN		DWORD flags;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * Add a DFS root share.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_ADDSTDROOT)
struct netdfs_addstdroot {
	IN REFERENCE	LPTSTR server;
	IN REFERENCE	LPTSTR share;
	IN REFERENCE	LPTSTR comment;
	IN		DWORD flags;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * Remove a DFS root share.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_REMSTDROOT)
struct netdfs_remstdroot {
	IN REFERENCE	LPTSTR server;
	IN REFERENCE	LPTSTR share;
	IN		DWORD flags;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * Get information about all of the volumes in the DFS. dfs_path is
 * the "server" part of the UNC name used to refer to this particular
 * DFS.
 *
 * Valid levels are 1-3.
 ***********************************************************************
 */
OPERATION(NETDFS_OPNUM_ENUMEX)
struct netdfs_enumex {
	IN REFERENCE	LPTSTR dfs_path;
	IN		DWORD level;
	IN		DWORD pref_max_len;
	INOUT		struct netdfs_enum_info *info;
	INOUT		DWORD *resume_handle;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * The NETDFS interface definiton.
 ***********************************************************************
 */
INTERFACE(0)
union netdfs_interface {
	CASE(NETDFS_OPNUM_GETVER)
		struct netdfs_getver		netdfs_getver;
	CASE(NETDFS_OPNUM_ADD)
		struct netdfs_add		netdfs_add;
	CASE(NETDFS_OPNUM_REMOVE)
		struct netdfs_remove		netdfs_remove;
	CASE(NETDFS_OPNUM_SETINFO)
		struct netdfs_setinfo		netdfs_setinfo;
	CASE(NETDFS_OPNUM_GETINFO)
		struct netdfs_getinfo		netdfs_getinfo;
	CASE(NETDFS_OPNUM_ENUM)
		struct netdfs_enum		netdfs_enum;
	CASE(NETDFS_OPNUM_MOVE)
		struct netdfs_move		netdfs_move;
	CASE(NETDFS_OPNUM_RENAME)
		struct netdfs_rename		netdfs_rename;
	CASE(NETDFS_OPNUM_ADDSTDROOT)
		struct netdfs_addstdroot	netdfs_addstdroot;
	CASE(NETDFS_OPNUM_REMSTDROOT)
		struct netdfs_remstdroot	netdfs_remstdroot;
	CASE(NETDFS_OPNUM_ENUMEX)
		struct netdfs_enumex		netdfs_enumex;
};
typedef union netdfs_interface	netdfs_interface_t;
EXTERNTYPEINFO(netdfs_interface)


#endif /* _NETDFS_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2020 Tintri by DDN, Inc. All rights reserved.
 */

#ifndef _MLSVC_NETR_NDL_
#define _MLSVC_NETR_NDL_

/*
 ***********************************************************************
 *
 * NetLogon RPC (NETR) interface definition.
 *
 ***********************************************************************
 */

#include <libmlrpc/ndrtypes.ndl>


#define NETR_OPNUM_UasLogon			0x00
#define NETR_OPNUM_UasLogoff			0x01
#define NETR_OPNUM_SamLogon			0x02
#define NETR_OPNUM_SamLogoff			0x03
#define NETR_OPNUM_ServerReqChallenge		0x04
#define NETR_OPNUM_ServerAuthenticate		0x05
#define NETR_OPNUM_ServerPasswordSet		0x06
#define NETR_OPNUM_DatabaseDeltas		0x07
#define NETR_OPNUM_DatabaseSync			0x08
#define NETR_OPNUM_AccountDeltas		0x09
#define NETR_OPNUM_AccountSync			0x0a
#define NETR_OPNUM_GetDCName			0x0b
#define NETR_OPNUM_LogonControl			0x0c
#define NETR_OPNUM_GetAnyDCName			0x0d
#define NETR_OPNUM_LogonControl2		0x0E
#define NETR_OPNUM_ServerAuthenticate2		0x0F
#define NETR_OPNUM_DatabaseSync2		0x10
#define NETR_OPNUM_DatabaseRedo			0x11
#define NETR_OPNUM_LogonControl2Ex		0x12
#define NETR_OPNUM_TrustDomainList		0x13
#define NETR_OPNUM_DsrGetDcName			0x14
#define NETR_OPNUM_LogonGetCapabilities		0x15
#define NETR_OPNUM_LogonSetServiceBits		0x16
#define NETR_OPNUM_LogonGetTrustRid		0x17
#define NETR_OPNUM_LogonComputeServerDigest	0x18
#define NETR_OPNUM_LogonComputeClientDigest	0x19
#define NETR_OPNUM_ServerAuthenticate3		0x1A
#define NETR_OPNUM_DsrGetDcNameEx		0x1B
#define NETR_OPNUM_DsrGetSiteName		0x1C
#define NETR_OPNUM_LogonGetDomainInfo		0x1D
#define NETR_OPNUM_ServerPasswordSet2		0x1E

#define	NETR_OPNUM_SamLogonEx			0x27

/*
 * This is not a real NETR OPNUM.  It's used to unpack the
 * struct krb5_validation_info found in the Kerberos PAC.
 */
#define	NETR_OPNUM_decode_krb5_pac		1000


struct netr_sid {
	BYTE		Revision;
	BYTE		SubAuthCount;
	BYTE		Authority[6];
  SIZE_IS(SubAuthCount)
	DWORD		SubAuthority[ANY_SIZE_ARRAY];
};


struct netr_string {
	WORD		length;
	WORD		allosize;
	LPTSTR		str;
};
typedef struct netr_string netr_string_t;


/*
 * Alternative varying/conformant string definition - for
 * non-null terminated strings. This definition must match
 * ndr_vcbuf_t.
 */
struct netr_vcs {
	/*
	 * size_is (actually a copy of length_is) will
	 * be inserted here by the marshalling library.
	 */
	DWORD vc_first_is;
	DWORD vc_length_is;
  SIZE_IS(vc_length_is)
	WORD buffer[ANY_SIZE_ARRAY];
};

struct netr_vcstr {
	WORD wclen;
	WORD wcsize;
	struct netr_vcs *vcs;
};
typedef struct netr_vcstr netr_vcstr_t;

struct netr_vcb {
	/*
	 * size_is (actually a copy of length_is) will
	 * be inserted here by the marshalling library.
	 */
	DWORD vc_first_is;
	DWORD vc_length_is;
  SIZE_IS(vc_length_is)
	BYTE buffer[ANY_SIZE_ARRAY];
};

struct netr_vcbuf {
	WORD len;
	WORD size;
	struct netr_vcb *vcb;
};
typedef struct netr_vcbuf netr_vcbuf_t;

struct netr_credential {
	BYTE data[8];
};

struct netr_authenticator {
	struct netr_credential credential;
	DWORD timestamp;
};
typedef struct netr_authenticator netr_auth_t;


struct OLD_LARGE_INTEGER {
	DWORD LowPart;
	DWORD HighPart;
};
typedef struct OLD_LARGE_INTEGER netr_int64_t;

struct CYPHER_BLOCK {
	BYTE data[8];
};

struct OWF_PASSWORD {
	BYTE data[16];
};
typedef struct OWF_PASSWORD netr_owf_password_t;

/*
 * NL_TRUST_PASSWORD
 * See also: samr_user_password
 */
#define NETR_TRUST_PWLEN	256
struct netr_trust_password {
	WORD	Buffer[NETR_TRUST_PWLEN];
	DWORD	Length;
};
typedef struct netr_trust_password netr_trust_password_t;

struct USER_SESSION_KEY {
	struct CYPHER_BLOCK data[2];
};




/*
 ***********************************************************************
 * ServerReqChallenge
 ***********************************************************************
 */
ALIGN(2)
OPERATION(NETR_OPNUM_ServerReqChallenge)
struct netr_ServerReqChallenge {
	IN		LPTSTR servername;
	IN REFERENCE	LPTSTR hostname;
	IN		struct netr_credential client_challenge;
	OUT		struct netr_credential server_challenge;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * ServerAuthenticate2
 ***********************************************************************
 */
ALIGN(2)
OPERATION(NETR_OPNUM_ServerAuthenticate2)
struct netr_ServerAuthenticate2 {
	IN		LPTSTR servername;
	IN REFERENCE	LPTSTR account_name;
	IN		WORD account_type;
	IN REFERENCE	LPTSTR hostname;
	IN		struct netr_credential client_credential;
	OUT		struct netr_credential server_credential;
	INOUT	DWORD negotiate_flags;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * ServerPasswordSet
 ***********************************************************************
 */
ALIGN(2)
OPERATION(NETR_OPNUM_ServerPasswordSet)
struct netr_PasswordSet {
	IN		LPTSTR servername;
	IN REFERENCE	LPTSTR account_name;
	IN		WORD sec_chan_type;
	IN REFERENCE	LPTSTR hostname;
	INOUT	struct netr_authenticator auth;
	IN		netr_owf_password_t owf_password;
	OUT		DWORD status;
};

OPERATION(NETR_OPNUM_ServerPasswordSet2)
struct netr_PasswordSet2 {
	IN		LPTSTR servername;
	IN REFERENCE	LPTSTR account_name;
	IN		WORD sec_chan_type;
	IN REFERENCE	LPTSTR hostname;
	INOUT	struct netr_authenticator auth;
	IN		netr_trust_password_t trust_password;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * SamLogon
 ***********************************************************************
 */

/*
 * The challenge-response data should always be 24 bytes.
 */
#define NETR_CR_PASSWORD_SIZE			24


struct lm_challenge {
	BYTE data[8];
};
typedef struct lm_challenge lm_challenge_t;

/*
 * Input data
 */
struct netr_logon_identity_info {
	netr_vcstr_t domain_name;
	DWORD parameter_control;
	struct OLD_LARGE_INTEGER logon_id;
	netr_vcstr_t username;
	netr_vcstr_t workstation;
};
typedef struct netr_logon_identity_info netr_logon_id_t;


/*
 * Level 1: interactive logon
 */
struct netr_logon_info1 {
	netr_logon_id_t identity;
	netr_owf_password_t lm_owf_password;
	netr_owf_password_t nt_owf_password;
};


/*
 * Level 2: network logon.
 */
struct netr_logon_info2 {
	netr_logon_id_t identity;
	lm_challenge_t lm_challenge;
	netr_vcbuf_t nt_response;
	netr_vcbuf_t lm_response;
};


union netr_logon_info_u {
	UNION_INFO_PTR(1,netr_logon_info);
	UNION_INFO_PTR(2,netr_logon_info);
	DEFAULT	DWORD nothing;
};


FAKE
struct netr_login_info {
	WORD logon_level;
	WORD switch_value;
  SWITCH(switch_value)
	union netr_logon_info_u ru;
};


/*
 * Output data
 */
struct netr_group_membership {
	DWORD rid;
	DWORD attributes;
};


struct netr_sid_and_attributes {
	struct netr_sid *sid;
	DWORD attributes;
};


struct netr_validation_info3 {
	struct OLD_LARGE_INTEGER LogonTime;
	struct OLD_LARGE_INTEGER LogoffTime;
	struct OLD_LARGE_INTEGER KickOffTime;
	struct OLD_LARGE_INTEGER PasswordLastSet;
	struct OLD_LARGE_INTEGER PasswordCanChange;
	struct OLD_LARGE_INTEGER PasswordMustChange;
	netr_string_t EffectiveName;
	netr_string_t FullName;
	netr_string_t LogonScript;
	netr_string_t ProfilePath;
	netr_string_t HomeDirectory;
	netr_string_t HomeDirectoryDrive;
	WORD LogonCount;
	WORD BadPasswordCount;
	DWORD UserId;
	DWORD PrimaryGroupId;
	DWORD GroupCount;
  SIZE_IS(GroupCount)
	struct netr_group_membership *GroupIds;
	DWORD UserFlags;
	struct USER_SESSION_KEY UserSessionKey;
	netr_string_t LogonServer;
	netr_string_t LogonDomainName;
	struct netr_sid *LogonDomainId;
	DWORD ExpansionRoom[10];
	DWORD SidCount;
  SIZE_IS(SidCount)
	struct netr_sid_and_attributes *ExtraSids;
};

/* NETR_OPNUM_decode_krb5_pac */
struct krb5_validation_info {
	struct netr_validation_info3 info3;
	/* Kerberos PAC "resource group" stuff. */
	struct netr_sid *rg_dom_sid;
	DWORD rg_rid_cnt;
  SIZE_IS(rg_rid_cnt)
	struct netr_group_membership *rg_rids;
};

union netr_validation_u {
	CASE(3) struct netr_validation_info3 *info3;
	DEFAULT	DWORD nothing;
};


/*
 * This structure needs to be declared, even though it can't be used
 * in netr_SamLogon, in order to get the appropriate size to calculate
 * the correct fixup offsets.  If ndrgen did the right thing,
 * netr_validation_info would be one of the out parameters. However,
 * if we do it that way, the switch_value isn't known early enough to
 * do the fixup calculation. So it all has to go in netr_SamLogon.
 */
struct netr_validation_info {
	WORD validation_level;
  SWITCH(validation_level)
	union netr_validation_u ru;
};


/*
 * WARNING
 *
 * Validation_level is really a WORD and authoritative is really a
 * BYTE. They are declared as DWORD here due to the way things are
 * unmarshalled. NT does not clear out the unused bytes in the
 * DWORD so they must be cast to get the correct value.
 */
ALIGN(2)
OPERATION(NETR_OPNUM_SamLogon)
struct netr_SamLogon {
	IN		LPTSTR servername;
	IN		LPTSTR hostname;
	IN		struct netr_authenticator *auth;
	INOUT	struct netr_authenticator *ret_auth;
	IN		struct netr_login_info logon_info;
	INOUT	WORD validation_level;
  SWITCH(validation_level)
	OUT		union netr_validation_u ru;
	OUT		DWORD authoritative;
	OUT		DWORD status;
};

ALIGN(2)
OPERATION(NETR_OPNUM_SamLogonEx)
struct netr_SamLogonEx {
	IN		LPTSTR servername;
	IN		LPTSTR hostname;
	IN		struct netr_login_info logon_info;
	INOUT	WORD validation_level;
  SWITCH(validation_level)
	OUT		union netr_validation_u ru;
	OUT		DWORD authoritative;
	INOUT		DWORD extra_flags;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * SamLogoff
 ***********************************************************************
 */
OPERATION(NETR_OPNUM_SamLogoff)
struct netr_SamLogoff {
	IN		LPTSTR servername;
	IN REFERENCE	LPTSTR hostname;
	IN		struct netr_authenticator auth;
	INOUT	struct netr_authenticator ret_auth;
	IN		DWORD logon_level;
  SWITCH(logon_level)
	IN		union netr_logon_info_u ru;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * The NETR interface definition.
 ***********************************************************************
 */
INTERFACE(0)
union netr_interface {
	CASE(NETR_OPNUM_ServerReqChallenge)
		struct netr_ServerReqChallenge		ServerReqChallenge;
	CASE(NETR_OPNUM_ServerAuthenticate2)
		struct netr_ServerAuthenticate2		ServerAuthenticate2;
	CASE(NETR_OPNUM_SamLogon)
		struct netr_SamLogon			SamLogon;
	CASE(NETR_OPNUM_SamLogonEx)
		struct netr_SamLogonEx			SamLogonEx;
	CASE(NETR_OPNUM_SamLogoff)
		struct netr_SamLogoff			SamLogoff;
	CASE(NETR_OPNUM_ServerPasswordSet)
		struct netr_PasswordSet			PasswordSet;
	CASE(NETR_OPNUM_ServerPasswordSet2)
		struct netr_PasswordSet2		PasswordSet2;

	/* Special, for smb_decode_krb5_pac() */
	CASE(NETR_OPNUM_decode_krb5_pac)
		struct krb5_validation_info		krb5pac;
};
typedef union netr_interface netr_interface_t;
EXTERNTYPEINFO(netr_interface)

#endif /* _MLSVC_NETR_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_SAM_NDL_
#define _MLSVC_SAM_NDL_

/*
 * Security Accounts Manager RPC (SAMR) interface definition.
 */

#include <libmlrpc/ndrtypes.ndl>

/* Windows NT */
#define SAMR_OPNUM_Connect			0x00	/* SamrConnect */
#define SAMR_OPNUM_CloseHandle			0x01
#define SAMR_OPNUM_SetSecObject			0x02
#define SAMR_OPNUM_QuerySecObject		0x03
#define SAMR_OPNUM_ShutdownSamServer		0x04	/* NotUsedOnWire */
#define SAMR_OPNUM_LookupDomain			0x05
#define SAMR_OPNUM_EnumLocalDomains		0x06
#define SAMR_OPNUM_OpenDomain			0x07
#define SAMR_OPNUM_QueryDomainInfo		0x08
#define SAMR_OPNUM_SetDomainInfo		0x09
#define SAMR_OPNUM_CreateDomainGroup		0x0a
#define SAMR_OPNUM_QueryDomainGroups		0x0b
#define SAMR_OPNUM_CreateDomainUser		0x0c
#define SAMR_OPNUM_EnumDomainUsers		0x0d
#define SAMR_OPNUM_CreateDomainAlias		0x0e
#define SAMR_OPNUM_EnumDomainAliases		0x0f
#define SAMR_OPNUM_LookupIds			0x10	/* GetAliasMembership */
#define SAMR_OPNUM_LookupNames			0x11
#define SAMR_OPNUM_LookupDomainIds		0x12
#define SAMR_OPNUM_OpenGroup			0x13
#define SAMR_OPNUM_QueryGroupInfo		0x14
#define SAMR_OPNUM_StoreGroupInfo		0x15
#define SAMR_OPNUM_AddGroupMember		0x16
#define SAMR_OPNUM_DeleteDomainGroup		0x17
#define SAMR_OPNUM_DeleteGroupMember		0x18
#define SAMR_OPNUM_ListGroupMembers		0x19
#define SAMR_OPNUM_SetGroupMemberAttributes	0x1a
#define SAMR_OPNUM_OpenAlias			0x1b
#define SAMR_OPNUM_QueryAliasInfo		0x1c
#define SAMR_OPNUM_SetAliasInfo			0x1d
#define SAMR_OPNUM_DeleteDomainAlias		0x1e
#define SAMR_OPNUM_AddAliasMember		0x1f
#define SAMR_OPNUM_DeleteAliasMember		0x20
#define SAMR_OPNUM_ListAliasMembers		0x21
#define SAMR_OPNUM_OpenUser			0x22
#define SAMR_OPNUM_DeleteUser			0x23
#define SAMR_OPNUM_QueryUserInfo		0x24
#define SAMR_OPNUM_SetUserInfo0			0x25	/* SetUserInfo */
#define SAMR_OPNUM_ChangeUserPassword0		0x26	/* ChangeUserPassword */
#define SAMR_OPNUM_QueryUserGroups		0x27
#define SAMR_OPNUM_QueryDispInfo		0x28	/* QueryDispInfo1 */
#define	SAMR_OPNUM_GetDisplayEnumIndex		0x29
#define	SAMR_OPNUM_TestPrivateDomainFunctions	0x2a	/* NotUsedOnWire */
#define	SAMR_OPNUM_TestPrivateUserFunctions	0x2b	/* NotUsedOnWire */
#define SAMR_OPNUM_GetUserPwInfo		0x2c

/* Windows 2000 */
#define	SAMR_OPNUM_RemoveMemberFromForeignDomain        0x2d
#define	SAMR_OPNUM_QueryInfoDomain2		0x2e
#define	SAMR_OPNUM_QueryInfoUser2		0x2f
#define	SAMR_OPNUM_EnumDomainGroups		0x30    /* QueryDispInfo2 */
#define	SAMR_OPNUM_GetDisplayEnumIndex2		0x31
#define	SAMR_OPNUM_CreateUser			0x32
#define	SAMR_OPNUM_QueryDispInfo4		0x33
#define	SAMR_OPNUM_AddMultipleAliasMembers	0x34
#define	SAMR_OPNUM_RemoveMultipleAliasMembers	0x35
#define	SAMR_OPNUM_ChangeUserOemPassword	0x36
#define SAMR_OPNUM_ChangePasswordUser2		0x37	/* UnicodePasswd */
#define SAMR_OPNUM_GetDomainPwInfo		0x38
#define SAMR_OPNUM_Connect2                     0x39    /* SamrConnect2 */
#define SAMR_OPNUM_SetUserInfo			0x3a	/* SetInfoUser2 */
#define	SAMR_OPNUM_SetBootKeyInformation	0x3b
#define	SAMR_OPNUM_GetBootKeyInformation	0x3c
#define	SAMR_OPNUM_Connect3			0x3d	/* NotUsedOnWire */
#define	SAMR_OPNUM_Connect4			0x3e	/* SamrConnect4 */
#define	SAMR_OPNUM_ChangeUserUnicodePassword3	0x3f

/* Windows XP and Windows Server 2003 */
#define	SAMR_OPNUM_Connect5			0x40	/* SamrConnect5 */
#define	SAMR_OPNUM_RidToSid                     0x41
#define	SAMR_OPNUM_SetDSRMPassword              0x42
#define	SAMR_OPNUM_ValidatePassword             0x43

/* Windows Vista */
#define SAMR_OPNUM_QueryLocalizableAccountsInDomain     0x44
#define SAMR_OPNUM_PerformGenericOperation              0x45


/*
 * Sam account flags used when creating an account. These flags seem
 * to be very similar to the USER_INFO_X flags (UF_XXX) in lmaccess.h
 * but the values are different.
 */
#define SAMR_AF_ACCOUNTDISABLE			0x0001
#define SAMR_AF_HOMEDIR_REQUIRED		0x0002
#define SAMR_AF_PASSWD_NOTREQD			0x0004
#define SAMR_AF_TEMP_DUPLICATE_ACCOUNT		0x0008
#define SAMR_AF_NORMAL_ACCOUNT			0x0010
#define SAMR_AF_MNS_LOGON_ACCOUNT		0x0020
#define SAMR_AF_INTERDOMAIN_TRUST_ACCOUNT	0x0040
#define SAMR_AF_WORKSTATION_TRUST_ACCOUNT	0x0080
#define SAMR_AF_SERVER_TRUST_ACCOUNT		0x0100
#define SAMR_AF_DONT_EXPIRE_PASSWD		0x0200
#define SAMR_AF_ACCOUNT_AUTOLOCK		0x0400


#define SAMR_AF_MACHINE_ACCOUNT_MASK	( \
				SAMR_AF_INTERDOMAIN_TRUST_ACCOUNT \
				| SAMR_AF_WORKSTATION_TRUST_ACCOUNT \
				| SAMR_AF_SERVER_TRUST_ACCOUNT)

#define SAMR_AF_ACCOUNT_TYPE_MASK	( \
				SAMR_AF_TEMP_DUPLICATE_ACCOUNT \
				| SAMR_AF_NORMAL_ACCOUNT \
				| SAMR_AF_INTERDOMAIN_TRUST_ACCOUNT \
				| SAMR_AF_WORKSTATION_TRUST_ACCOUNT \
				| SAMR_AF_SERVER_TRUST_ACCOUNT)

/*
 * QueryUserInfo UserAllInformation WhichFields
 */
#define	SAMR_USER_ALL_USERNAME			0x00000001
#define	SAMR_USER_ALL_FULLNAME			0x00000002
#define	SAMR_USER_ALL_USERID			0x00000004
#define	SAMR_USER_ALL_PRIMARYGROUPID		0x00000008
#define	SAMR_USER_ALL_ADMINCOMMENT		0x00000010
#define	SAMR_USER_ALL_USERCOMMENT		0x00000020
#define	SAMR_USER_ALL_HOMEDIRECTORY		0x00000040
#define	SAMR_USER_ALL_HOMEDIRECTORYDRIVE	0x00000080
#define	SAMR_USER_ALL_SCRIPTPATH		0x00000100
#define	SAMR_USER_ALL_PROFILEPATH		0x00000200
#define	SAMR_USER_ALL_WORKSTATIONS		0x00000400
#define	SAMR_USER_ALL_LASTLOGON			0x00000800
#define	SAMR_USER_ALL_LASTLOGOFF		0x00001000
#define	SAMR_USER_ALL_LOGONHOURS		0x00002000
#define	SAMR_USER_ALL_BADPASSWORDCOUNT		0x00004000
#define	SAMR_USER_ALL_LOGONCOUNT		0x00008000
#define	SAMR_USER_ALL_PASSWORDCANCHANGE		0x00010000
#define	SAMR_USER_ALL_PASSWORDMUSTCHANGE	0x00020000
#define	SAMR_USER_ALL_PASSWORDLASTSET		0x00040000
#define	SAMR_USER_ALL_ACCOUNTEXPIRES		0x00080000
#define	SAMR_USER_ALL_USERACCOUNTCONTROL	0x00100000
#define	SAMR_USER_ALL_PARAMETERS		0x00200000
#define	SAMR_USER_ALL_COUNTRYCODE		0x00400000
#define	SAMR_USER_ALL_CODEPAGE			0x00800000
#define	SAMR_USER_ALL_NTPASSWORDPRESENT		0x01000000
#define	SAMR_USER_ALL_LMPASSWORDPRESENT		0x02000000
#define	SAMR_USER_ALL_PRIVATEDATA		0x04000000
#define	SAMR_USER_ALL_PASSWORDEXPIRED		0x08000000
#define	SAMR_USER_ALL_SECURITYDESCRIPTOR	0x10000000
#define	SAMR_USER_ALL_OWF_PASSWORD		0x20000000
#define	SAMR_USER_ALL_UNDEFINED_MASK		0xC0000000

/*
 * Alias Access Mask values for SAMR
 * Section 2.2.1.6 of MS-SAMR
 */
#define SAMR_ALIAS_ACCESS_EXECUTE		0x00020008
#define SAMR_ALIAS_ACCESS_WRITE			0x00020013
#define SAMR_ALIAS_ACCESS_READ			0x00020004
#define SAMR_ALIAS_ACCESS_ALL_ACCESS		0x000F001F
#define SAMR_ALIAS_ACCESS_WRITE_ACCOUNT		0x00000010
#define SAMR_ALIAS_ACCESS_READ_INFO		0x00000008
#define SAMR_ALIAS_ACCESS_LIST_MEMBERS		0x00000004
#define SAMR_ALIAS_ACCESS_REMOVE_MEMBER		0x00000002
#define SAMR_ALIAS_ACCESS_ADD_MEMBER		0x00000001

#define	SAMR_REVISION_1			1	/* Pre Windows 2000 */
#define	SAMR_REVISION_2			2	/* Windows 2000 */
#define	SAMR_REVISION_3			3	/* Post Windows 2000 */

/*
 * Definition for a SID. The ndl compiler does not allow a typedef of
 * a structure containing variable size members.
 * Note: cast compatible with smb_sid_t, and code depends on that.
 */
struct samr_sid {
	BYTE		Revision;
	BYTE		SubAuthCount;
	BYTE		Authority[6];
  SIZE_IS(SubAuthCount)
	DWORD		SubAuthority[ANY_SIZE_ARRAY];
};


/*
 * SAMR definition of a security_descriptor.
 */
struct samr_sec_desc {
	BYTE Revision;
	BYTE Sbz1;
	WORD Control;
	struct samr_sid *owner;
	struct samr_sid *group;
	struct samr_sid *sacl;
	struct samr_sid *dacl;
};

struct samr_sd {
	DWORD length;
  SIZE_IS(length)
	BYTE *data;
};
typedef struct samr_sd samr_sd_t;

/*
 * See RPC_STRING in the MS IDL.
 * Definition for a string. The length and allosize should be set to
 * twice the string length (i.e. strlen(str) * 2). The runtime code
 * will perform the appropriate string to a wide-char conversions,
 * so str should point to a regular char * string.
 */
struct samr_string {
	WORD		length;
	WORD		allosize;
	LPTSTR		str;
};
typedef struct samr_string samr_string_t;


/*
 * Alternative varying/conformant string definition - for
 * non-null terminated strings. This definition must match
 * ndr_vcbuf_t.
 */
struct samr_vcb {
	/*
	 * size_is (actually a copy of length_is) will
	 * be inserted here by the marshalling library.
	 */
	DWORD vc_first_is;
	DWORD vc_length_is;
  SIZE_IS(vc_length_is)
	WORD buffer[ANY_SIZE_ARRAY];
};

struct samr_vcbuf {
	WORD wclen;
	WORD wcsize;
	struct samr_vcb *vcb;
};
typedef struct samr_vcbuf samr_vcbuf_t;

CONTEXT_HANDLE(samr_handle) samr_handle_t;

/*
 * OLD_LARGE_INTEGER: a 64-bit value.
 */
struct samr_quad {
	DWORD low;
	DWORD high;
};
typedef struct samr_quad samr_quad_t;

/*
 * Blob used for the NT and LM OWF passwords.
 * The length and maxlen should be 16.
 */
struct samr_short_blob {
	WORD	length;
	WORD	maxlen;
  SIZE_IS(length / 2)
	WORD	*buf;
};

#define	DOMAIN_PASSWORD_COMPLEX			0x00000001
#define	DOMAIN_PASSWORD_NO_ANON_CHANGE		0x00000002
#define	DOMAIN_PASSWORD_NO_CLEAR_CHANGE		0x00000004
#define	DOMAIN_LOCKOUT_ADMINS			0x00000008
#define	DOMAIN_PASSWORD_STORE_CLEARTEXT		0x00000010
#define	DOMAIN_REFUSE_PASSWORD_CHANGE		0x00000020

struct samr_password_info {
	WORD	min_length;
	DWORD	properties;
};
typedef struct samr_password_info samr_password_info_t;

/*
 * There is some sort of logon bitmap structure in here, which I
 * think is a varying and conformant array, i.e.
 *
 *	struct samr_logon_hours {
 *      DWORD size_is;		(1260)
 *      DWORD first_is;		(zero)
 *      DWORD length_is;	(168)
 *      BYTE bitmap[21];
 *  };
 *
 *	struct samr_logon_info {
 *		DWORD length;
 *	SIZE_IS(length / 8)
 *		struct samr_logon_hours *hours;
 *	};
 *
 * There are 10080 minutes/week => 10080/8 = 1260 (0x04EC).
 * So size_is is set as some sort of maximum.
 *
 * There are 168 hours/week => 168/8 = 21 (0xA8). Since there are 21
 * bytes (all set to 0xFF), this is is probably the default setting.
 */

#define SAMR_MINS_PER_WEEK		10080
#define SAMR_HOURS_PER_WEEK		168

#define SAMR_HOURS_MAX_SIZE		(SAMR_MINS_PER_WEEK / 8)
#define SAMR_HOURS_SET_LEN(LEN)		((LEN) / 8)
#define SAMR_SET_USER_HOURS_SZ		21

struct samr_logon_hours {
	DWORD size;
	DWORD first;
	DWORD length;
	BYTE bitmap[SAMR_SET_USER_HOURS_SZ];
};

struct samr_logon_info {
	DWORD units;
	DWORD hours;
};

struct samr_logon_hours_all {
	WORD	units_per_week;
  SIZE_IS(units_per_week / 8)
	BYTE	*hours;
};

/*
 * SAMPR_USER_PASSWORD (in the MS Net API) or
 * struct samr_user_password (internal use) is
 * the "clear" form of struct samr_encr_passwd
 * (SAMPR_ENCRYPTED_USER_PASSWORD in MS Net).
 * It's not used by ndrgen, but is declared here
 * to help clarify the relationship between these,
 * and for the benefit of our client-side code.
 */
#ifndef	NDRGEN
#define SAMR_USER_PWLEN	256
struct samr_user_password {
	ndr_wchar_t	Buffer[SAMR_USER_PWLEN];
	DWORD Length;
};
#endif	/* NDRGEN */

/* SAMPR_ENCRYPTED_USER_PASSWORD */
#define	SAMR_ENCR_PWLEN 516	/* sizeof samr_user_password */
struct samr_encr_passwd {
	BYTE data[SAMR_ENCR_PWLEN];
};

/* ENCRYPTED_NT_OWF_PASSWORD */
#define	SAMR_PWHASH_LEN	16
struct samr_encr_hash {
	BYTE data[SAMR_PWHASH_LEN];
};

/*
 ***********************************************************************
 * SamrConnect.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_Connect)
struct samr_Connect {
	IN	DWORD *servername;
	IN	DWORD access_mask;
	OUT	samr_handle_t handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * SamrConnect2.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_Connect2)
struct samr_Connect2 {
	IN	LPTSTR servername;
	IN	DWORD access_mask;
	OUT	samr_handle_t handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * SamrConnect4. A new form of connect first seen with Windows 2000.
 * A new field has been added to the input request. Value: 0x00000002.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_Connect4)
struct samr_Connect4 {
	IN	LPTSTR servername;
	IN	DWORD revision;
	IN	DWORD access_mask;
	OUT	samr_handle_t handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * SamrConnect5. A new form of connect first seen with Windows XP.
 * The server name is the fully qualified domain name, i.e.
 *	\\server.sun.com.
 *
 * [in]  DWORD	 InVersion,
 * [in]  [switch_is(InVersion)]    samr_revision_info *InRevisionInfo
 * [out] DWORD	 *OutVersion
 * [out] [switch_is(*OutVersion)] *samr_revision_info *OutRevisionInfo
 *
 * SupportedFeatures (see notes in [MS-SAMR]
 *	0x00000001	RID values returned from the server must not be
 *			concatenated with the domain SID.
 *	0x00000002	Reserved
 *	0x00000004	Reserved
 ***********************************************************************
 */
struct samr_revision_info1 {
	DWORD revision;
	DWORD supported_features;
};
typedef struct samr_revision_info1 samr_revision_info1_t;

union samr_revision_info {
	UNION_INFO_ENT(1,samr_revision_info);
	DEFAULT	char *nullptr;
};

OPERATION(SAMR_OPNUM_Connect5)
struct samr_Connect5 {
	IN		LPTSTR servername;
	IN		DWORD access_mask;
	/*
	 * This should be a union, but instead this is
	 * done this way because unions are hard to
	 * express in this RPC implementation.
	 */
	INOUT	DWORD unknown2_00000001;	/* V1 */
	INOUT	DWORD unknown3_00000001;	/* V1 */
	/* SAMPR_REVISION_INFO_V1 */
	INOUT	DWORD unknown4_00000003;	/* Revision */
	INOUT	DWORD unknown5_00000000;	/* SupportedFeatures */
	OUT		samr_handle_t handle;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * CloseHandle closes an association with the SAM. Using the same
 * structure as the LSA seems to work.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_CloseHandle)
struct samr_CloseHandle {
	IN	samr_handle_t handle;
	OUT	samr_handle_t result_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QuerySecObject
 *
 * Returns the SecurityDescriptor of the object. Support not complete.
 *
 * QuerySecObject (
 *	IN samr_handle_t obj_handle,
 *	IN SECURITY_INFO secinfo,
 *	OUT samr_sd_t *sd,
 *	OUT DWORD status
 * )
 *
 ***********************************************************************
 */

typedef DWORD SECURITY_INFO;

OPERATION(SAMR_OPNUM_QuerySecObject)
struct samr_QuerySecObject {
	IN	samr_handle_t obj_handle;
	IN	SECURITY_INFO secinfo;
	OUT	samr_sd_t *sd;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LookupDomain: lookup up the domain SID.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_LookupDomain)
struct samr_LookupDomain {
	IN	samr_handle_t handle;
	IN	samr_string_t domain_name;
	OUT struct samr_sid *sid;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * EnumLocalDomain
 *
 * This looks like a request to get the local domains supported by a
 * remote server. NT always seems to return 2 domains: the local
 * domain (hostname) and the Builtin domain.
 *
 * The max_length field is set to 0x2000.
 * Enum_context is set to 0 in the request and set to entries_read in
 * the reply. Like most of these enums, total_entries is the same as
 * entries_read.
 ***********************************************************************
 */
struct samr_LocalDomainEntry {
	DWORD unknown;
	samr_string_t name;
};

struct samr_LocalDomainInfo {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct samr_LocalDomainEntry *entry;
};


OPERATION(SAMR_OPNUM_EnumLocalDomains)
struct samr_EnumLocalDomain {
	IN		samr_handle_t handle;
	INOUT	DWORD enum_context;
	IN		DWORD max_length;
	OUT		struct samr_LocalDomainInfo *info;
	OUT		DWORD total_entries;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * OpenDomain
 *
 * Open a specific domain within the SAM. From this I assume that each
 * SAM can handle multiple domains so you need to identify the one with
 * which you want to work. Working with a domain handle does appear to
 * offer the benefit that you can then use RIDs instead of full SIDs,
 * which simplifies things a bit. The domain handle can be used to get
 * user and group handles.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_OpenDomain)
struct samr_OpenDomain {
	IN	samr_handle_t handle;
	IN	DWORD access_mask;
	IN REFERENCE struct samr_sid *sid;
	OUT	samr_handle_t domain_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QueryDomainInfo
 *
 * Windows 95 Server Manager sends requests for levels 6 and 7 when
 * the services menu item is selected.
 ***********************************************************************
 */
#define SAMR_QUERY_DOMAIN_INFO_2		2
#define SAMR_QUERY_DOMAIN_INFO_6		6
#define SAMR_QUERY_DOMAIN_INFO_7		7


struct samr_QueryDomainInfo2 {
	DWORD unknown1;			/* 00 00 00 00 */
	DWORD unknown2;			/* 00 00 00 80 */
	samr_string_t s1;
	samr_string_t domain;
	samr_string_t s2;
	DWORD sequence_num;		/* 2B 00 00 00 */
	DWORD unknown3;			/* 00 00 00 00 */
	DWORD unknown4;			/* 01 00 00 00 */
	DWORD unknown5;			/* 03 00 00 00 */
	DWORD unknown6;			/* 01 */
	DWORD num_users;
	DWORD num_groups;
	DWORD num_aliases;
};


struct samr_QueryDomainInfo6 {
	DWORD unknown1;			/* 00 00 00 00 */
	DWORD unknown2;			/* B0 7F 14 00 */
	DWORD unknown3;			/* 00 00 00 00 */
	DWORD unknown4;			/* 00 00 00 00 */
	DWORD unknown5;			/* 00 00 00 00 */
};


struct samr_QueryDomainInfo7 {
	DWORD unknown1;			/* 03 00 00 00 */
};


union samr_QueryDomainInfo_ru {
	UNION_INFO_ENT(2,samr_QueryDomainInfo);
	UNION_INFO_ENT(6,samr_QueryDomainInfo);
	UNION_INFO_ENT(7,samr_QueryDomainInfo);
	DEFAULT	char *nullptr;
};

struct samr_QueryDomainInfoRes {
	WORD switch_value;
	SWITCH(switch_value)
		union samr_QueryDomainInfo_ru ru;
};

OPERATION(SAMR_OPNUM_QueryDomainInfo)
struct samr_QueryDomainInfo {
	IN	samr_handle_t domain_handle;
	IN	WORD info_level;
	OUT	struct samr_QueryDomainInfoRes *info;
	OUT	DWORD status;
};

/*
 * Identical to SAMR_OPNUM_QueryDomainInfo.
 */
OPERATION(SAMR_OPNUM_QueryInfoDomain2)
struct samr_QueryInfoDomain2 {
	IN	samr_handle_t	domain_handle;
	IN	WORD		info_level;
	OUT	struct samr_QueryDomainInfoRes *info;
	OUT	DWORD		status;
};

#define SAMR_QUERY_ALIAS_INFO_GENERAL		1
#define SAMR_QUERY_ALIAS_INFO_NAME		2
#define SAMR_QUERY_ALIAS_INFO_COMMENT		3

struct samr_QueryAliasInfoGeneral {
	WORD level;
	samr_string_t name;
	DWORD member_count;
	samr_string_t desc;
};

struct samr_QueryAliasInfoName {
	WORD level;
	samr_string_t name;
};

struct samr_QueryAliasInfoComment {
	WORD level;
	samr_string_t desc;
};

union samr_QueryAliasInfo_ru {
	CASE(1) struct samr_QueryAliasInfoGeneral info1;
	CASE(2) struct samr_QueryAliasInfoName    info2;
	CASE(3) struct samr_QueryAliasInfoComment info3;
	DEFAULT	char *nullptr;
};

struct samr_QueryAliasInfoRes {
	DWORD address;
	WORD switch_value;
	SWITCH(switch_value)
		union samr_QueryAliasInfo_ru ru;
};

OPERATION(SAMR_OPNUM_QueryAliasInfo)
struct samr_QueryAliasInfo {
	IN	samr_handle_t alias_handle;
	IN	WORD level;
	OUT DWORD address;
  SWITCH (level)
	OUT	union samr_QueryAliasInfo_ru ru;
	OUT	DWORD status;
};

OPERATION(SAMR_OPNUM_CreateDomainAlias)
struct samr_CreateDomainAlias {
	IN	samr_handle_t domain_handle;
	IN	samr_string_t alias_name;
	IN	DWORD access_mask;
	OUT samr_handle_t alias_handle;
	OUT	DWORD rid;
	OUT	DWORD status;
};

OPERATION(SAMR_OPNUM_SetAliasInfo)
struct samr_SetAliasInfo {
	IN	samr_handle_t alias_handle;
	IN	WORD level;
	/* TBD */
	OUT	DWORD status;
};

OPERATION(SAMR_OPNUM_DeleteDomainAlias)
struct samr_DeleteDomainAlias {
	INOUT	samr_handle_t alias_handle;
	OUT	DWORD status;
};

OPERATION(SAMR_OPNUM_OpenAlias)
struct samr_OpenAlias {
	IN	samr_handle_t domain_handle;
	IN	DWORD access_mask;
	IN	DWORD rid;
	OUT samr_handle_t alias_handle;
	OUT	DWORD status;
};

struct name_rid {
	DWORD rid;
	samr_string_t name;
};

struct aliases_info {
	DWORD count;
	DWORD address;
	SIZE_IS(count)
	struct name_rid info[ANY_SIZE_ARRAY];
};

OPERATION(SAMR_OPNUM_EnumDomainAliases)
struct samr_EnumDomainAliases {
	IN	samr_handle_t domain_handle;
	IN	DWORD resume_handle;
	IN	DWORD mask;
	OUT	DWORD out_resume;
	OUT struct aliases_info *aliases;
	OUT DWORD entries;
	OUT	DWORD status;
};

struct user_acct_info {
	DWORD index;
	DWORD rid;
	DWORD ctrl;
	samr_string_t name;
	samr_string_t fullname;
	samr_string_t desc;
};

struct user_disp_info {
	OUT DWORD total_size;
	OUT DWORD returned_size;
	OUT WORD switch_value;
	DWORD count;
	SIZE_IS(count)
	struct user_acct_info *acct;
};

OPERATION(SAMR_OPNUM_QueryDispInfo)
struct samr_QueryDispInfo {
	IN	samr_handle_t domain_handle;
	IN	WORD level;
	IN	DWORD start_idx;
	IN	DWORD max_entries;
	IN	DWORD pref_maxsize;
	OUT struct user_disp_info users;
	OUT	DWORD status;
};

struct group_acct_info {
	DWORD index;
	DWORD rid;
	DWORD ctrl;
	samr_string_t name;
	samr_string_t desc;
};

struct group_disp_info {
	DWORD count;
	/* right now we just need one entry */
	struct group_acct_info acct[1];
};

OPERATION(SAMR_OPNUM_EnumDomainGroups)
struct samr_EnumDomainGroups {
	IN	samr_handle_t domain_handle;
	IN	WORD level;
	IN	DWORD start_idx;
	IN	DWORD max_entries;
	IN	DWORD pref_maxsize;
	OUT DWORD total_size;
	OUT DWORD returned_size;
	OUT WORD switch_value;
	OUT DWORD count;
	OUT struct group_disp_info *groups;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * OpenUser
 *
 * Input must be a domain handle obtained via SAMR_OPNUM_OpenDomain,
 * an access mask and the appropriate user rid. The output will be a
 * handle for use with the specified user.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_OpenUser)
struct samr_OpenUser {
	IN	samr_handle_t handle;
	IN	DWORD access_mask;
	IN	DWORD rid;
	OUT	samr_handle_t user_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * DeleteUser
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_DeleteUser)
struct samr_DeleteUser {
	INOUT	samr_handle_t user_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QueryUserInfo
 *
 * Provides various pieces of information on a specific user (see
 * SAM_Q_QUERY_USERINFO and SAM_R_QUERY_USERINFO). The handle must
 * be a valid SAM user handle.
 *
 * QueryUserInfo (
 *	IN samr_handle_t user_handle,
 *	IN WORD switch_value,
 *	OUT union switch(switch_value) {
 *		case 1: struct QueryUserInfo1 *info1;
 *	} bufptr,
 *	OUT DWORD status
 * )
 *
 * typedef enum _USER_INFORMATION_CLASS {
 *	UserGeneralInformation		= 1,
 *	UserPreferencesInformation	= 2,
 *	UserLogonInformation		= 3,
 *	UserLogonHoursInformation	= 4,
 *	UserAccountInformation		= 5,
 *	UserNameInformation		= 6,
 *	UserAccountNameInformation	= 7,
 *	UserFullNameInformation		= 8,
 *	UserPrimaryGroupInformation	= 9,
 *	UserHomeInformation		= 10,
 *	UserScriptInformation		= 11,
 *	UserProfileInformation		= 12,
 *	UserAdminCommentInformation	= 13,
 *	UserWorkStationsInformation	= 14,
 *	UserControlInformation		= 16,
 *	UserExpiresInformation		= 17,
 *	UserInternal1Information	= 18,
 *	UserParametersInformation	= 20,
 *	UserAllInformation		= 21,
 *	UserInternal4Information	= 23,
 *	UserInternal5Information	= 24,
 *	UserInternal4InformationNew	= 25,
 *	UserInternal5InformationNew	= 26,
 * } USER_INFORMATION_CLASS;
 *
 * 1 = username, fullname, description and some other stuff.
 * 3 = large structure containing user rid, group rid, username
 *     and fullname.
 * 5 = large structure (like 3) containing user rid, group rid,
 *     username, fullname and description.
 * 6 = username and fullname
 * 7 = username
 * 8 = fullname
 * 9 = group rid
 * 16 = used after creating a new account
 *
 * Due to an ndrgen bug, a function must be provided to to patch the
 * offsets used by the unmarshalling code at runtime.  In order to
 * simplify things it is useful to use a naming convention that
 * indicates the switch value for each structure.
 *
 ***********************************************************************
 */


#define SAMR_QUERY_USER_INFO_1			1
#define SAMR_QUERY_USER_UNAME_AND_FNAME		6
#define SAMR_QUERY_USER_USERNAME		7
#define SAMR_QUERY_USER_FULLNAME		8
#define SAMR_QUERY_USER_GROUPRID		9
#define SAMR_QUERY_USER_CONTROL_INFO		16
#define SAMR_QUERY_USER_ALL_INFO		21


struct samr_QueryUserInfo1 {
	samr_string_t username;
	samr_string_t fullname;
	DWORD group_rid;
	samr_string_t description;
	samr_string_t unknown;
};


struct samr_QueryUserInfo6 {
	samr_string_t username;
	samr_string_t fullname;
};

struct samr_QueryUserInfo7 {
	samr_string_t username;
};


struct samr_QueryUserInfo8 {
	samr_string_t fullname;
};


struct samr_QueryUserInfo9 {
	DWORD group_rid;
};


struct samr_QueryUserInfo16 {
	DWORD UserAccountControl;
};

/*
 * SAMR_USER_ALL_INFORMATION
 */
struct samr_QueryUserInfo21 {
	samr_quad_t		LastLogon;
	samr_quad_t		LastLogoff;
	samr_quad_t		PasswordLastSet;
	samr_quad_t		AccountExpires;
	samr_quad_t		PasswordCanChange;
	samr_quad_t		PasswordMustChange;
	samr_string_t		UserName;
	samr_string_t		FullName;
	samr_string_t		HomeDirectory;
	samr_string_t		HomeDirectoryDrive;
	samr_string_t		ScriptPath;
	samr_string_t		ProfilePath;
	samr_string_t		AdminComment;
	samr_string_t		WorkStations;
	samr_string_t		UserComment;
	samr_string_t		Parameters;
	struct samr_short_blob	LmOwfPassword;
	struct samr_short_blob	NtOwfPassword;
	samr_string_t		PrivateData;
	samr_sd_t		SecurityDescriptor;
	DWORD			UserId;
	DWORD			PrimaryGroupId;
	DWORD			UserAccountControl;
	DWORD			WhichFields;
	struct samr_logon_hours_all	LogonHours;
	WORD			BadPasswordCount;
	WORD			LogonCount;
	WORD			CountryCode;
	WORD			CodePage;
	BYTE			LmPasswordPresent;
	BYTE			NtPasswordPresent;
	BYTE			PasswordExpired;
	BYTE			PrivateDataSensitive;
};

/* See also: fixup_samr_QueryUserInfo() */
union QueryUserInfo_result_u {
	UNION_INFO_ENT(1,samr_QueryUserInfo);
	UNION_INFO_ENT(6,samr_QueryUserInfo);
	UNION_INFO_ENT(7,samr_QueryUserInfo);
	UNION_INFO_ENT(8,samr_QueryUserInfo);
	UNION_INFO_ENT(9,samr_QueryUserInfo);
	UNION_INFO_ENT(16,samr_QueryUserInfo);
	UNION_INFO_ENT(21,samr_QueryUserInfo);
	DEFAULT	char *nullptr;
};


/*
 * This structure needs to be declared, even though it can't be used in
 * samr_QueryUserInfo, in order to get the appropriate size to calculate
 * the correct fixup offsets.  If ndrgen did the right thing,
 * QueryUserInfo_result would be one of the out parameters.  However, if
 * we do it that way, the switch_value isn't known early enough to do
 * the fixup calculation.  So it all has to go in samr_QueryUserInfo.
 */
struct QueryUserInfo_result {
	DWORD address;
	WORD switch_value;
	SWITCH(switch_value)
		union QueryUserInfo_result_u ru;
};


OPERATION(SAMR_OPNUM_QueryUserInfo)
struct samr_QueryUserInfo {
	IN	samr_handle_t user_handle;
	IN	WORD switch_value;
	/*
	 * Can't use this form because we need to include members explicitly.
	 * OUT	struct QueryUserInfo_result result;
	 */
	OUT	DWORD address;
	OUT	WORD switch_index;
  SWITCH(switch_value)
	OUT	union QueryUserInfo_result_u ru;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QueryUserGroups
 ***********************************************************************
 */
struct samr_UserGroups {
	DWORD rid;
	DWORD attr;
};


struct samr_UserGroupInfo {
	DWORD n_entry;
  SIZE_IS(n_entry)
	struct samr_UserGroups *groups;
};


OPERATION(SAMR_OPNUM_QueryUserGroups)
struct samr_QueryUserGroups {
	IN	samr_handle_t user_handle;
	OUT struct samr_UserGroupInfo *info;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * LookupName
 ***********************************************************************
 */
struct samr_LookupNameTable {
	DWORD n_entry;
  SIZE_IS(n_entry)
	samr_string_t names[ANY_SIZE_ARRAY];
};


struct samr_LookupRidTable {
	DWORD n_entry;
  SIZE_IS(n_entry)
	DWORD *rid;
};

struct samr_RidType {
	DWORD n_entry;
  SIZE_IS(n_entry)
	DWORD *rid_type;
};


OPERATION(SAMR_OPNUM_LookupNames)
struct samr_LookupNames {
	IN	samr_handle_t handle;
	IN	DWORD n_entry;
	IN	DWORD max_n_entry;
	IN	DWORD index;
	IN	DWORD total;
	IN	samr_string_t name;
	OUT	struct samr_LookupRidTable rids;
	OUT	struct samr_RidType rid_types;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * OpenGroup
 *
 * Input must be a domain handle obtained via SAMR_OPNUM_OpenDomain,
 * an access mask and the appropriate group rid. The output will be a
 * handle for use with the specified group.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_OpenGroup)
struct samr_OpenGroup {
	IN	samr_handle_t handle;
	IN	DWORD access_mask;
	IN	DWORD rid;
	OUT	samr_handle_t group_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * QueryGroupInfo
 *
 * Input must be a group handle obtained via SAMR_OPNUM_OpenGroup,
 * an access mask and the appropriate group rid. The output will
 * be a handle for use with the specified group.
 ***********************************************************************
 */
struct samr_QueryGroupInfo1 {
	samr_string_t groupname;
};


union samr_QueryGroupInfo_result_u {
	UNION_INFO_ENT(1,samr_QueryGroupInfo);
	DEFAULT	char *nullptr;
};


struct samr_QueryGroupInfo_result {
	DWORD address;
	WORD switch_index;
  SWITCH(switch_index)
	union samr_QueryGroupInfo_result_u ru;
};


OPERATION(SAMR_OPNUM_QueryGroupInfo)
struct samr_QueryGroupInfo {
	IN	samr_handle_t group_handle;
	IN	DWORD switch_value;
	OUT	DWORD address;
	OUT	WORD switch_index;
  SWITCH(switch_index)
	OUT	union samr_QueryGroupInfo_result_u ru;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * StoreGroupInfo
 *
 * This definition is mostly just a place holder in case this is useful
 * in the future. Note that it may not be correct. The information is
 * from a netmon trace captured when I added a group description. I
 * haven't implemented it because we don't have to update anything on
 * the PDC. The description should almost certainly be in a separate
 * structure.
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_StoreGroupInfo)
struct samr_StoreGroupInfo {
	IN	samr_handle_t group_handle;
	IN	DWORD switch_value;
	IN	samr_string_t group_description;
	OUT	DWORD status;
};

/*
 * AddAliasMember
 */
OPERATION(SAMR_OPNUM_AddAliasMember)
struct samr_AddAliasMember {
	IN		samr_handle_t alias_handle;
	IN REFERENCE	struct samr_sid *sid;
	OUT DWORD	status;
};

/*
 * DeleteAliasMember
 */
OPERATION(SAMR_OPNUM_DeleteAliasMember)
struct samr_DeleteAliasMember {
	IN		samr_handle_t alias_handle;
	IN REFERENCE	struct samr_sid *sid;
	OUT DWORD	status;
};

struct samr_SidList {
	struct samr_sid		*sid;
};

struct samr_SidInfo {
	DWORD n_entry;
  SIZE_IS(n_entry)
	struct samr_SidList	*sidlist;
};

/*
 * ListAliasMembers
 */
OPERATION(SAMR_OPNUM_ListAliasMembers)
struct samr_ListAliasMembers {
	IN		samr_handle_t alias_handle;
	OUT		struct samr_SidInfo info;
	OUT DWORD	status;
};

/*
 ***********************************************************************
 * GetUserDomainPasswordInformation
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_GetUserPwInfo)
struct samr_GetUserPwInfo {
	IN		samr_handle_t		user_handle;
	OUT REFERENCE	samr_password_info_t	*pwinfo;
	OUT		DWORD			status;
};


/*
 ***********************************************************************
 * CreateUser
 *
 * Create a user in the domain specified by the domain handle. The
 * domain handle is obtained obtained via SAMR_OPNUM_OpenDomain.
 * DesiredAccess: 0xe00500b0.
 * The output will be a handle for use with the specified user and the
 * user's RID. I think the RID may be a unique pointer (it can be null).
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_CreateUser)
struct samr_CreateUser {
	IN	samr_handle_t handle;
	IN	samr_vcbuf_t username;
	IN	DWORD account_flags;
	IN	DWORD desired_access;
	OUT	samr_handle_t user_handle;
	OUT	DWORD maybe_ptr;
	OUT	DWORD rid;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * ChangePasswordUser2 - See:
 * SamrUnicodeChangePasswordUser2 [MS-SAMR 3.1.5.10.3]
 ***********************************************************************
 */

OPERATION(SAMR_OPNUM_ChangePasswordUser2)
struct samr_ChangePasswordUser2 {
	IN	samr_string_t *servername;
	IN REF	samr_string_t *username;
	IN	struct samr_encr_passwd *nt_newpw;
	IN	struct samr_encr_hash *nt_oldpw;
	IN	BYTE lm_present;
	IN	struct samr_encr_passwd *lm_newpw;
	IN	struct samr_encr_hash *lm_oldpw;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * GetDomainPwInfo
 ***********************************************************************
 */
OPERATION(SAMR_OPNUM_GetDomainPwInfo)
struct samr_GetDomainPwInfo {
	IN		DWORD			unused;
	OUT REFERENCE	samr_password_info_t	*pwinfo;
	OUT		DWORD			status;
};


/*
 ***********************************************************************
 * SetUserInfo
 * [MS-SAMR] SamrSetInformationUser2
 ***********************************************************************
 */

/* USER_CONTROL_INFORMATION */
struct samr_SetUserInfo16 {
	DWORD UserAccountControl;
};


/*
 * samr_SetUserInfo21, a.k.a
 * SAMR_USER_ALL_INFORMATION
 *
 * We now know this is the same as samr_QueryUserInfo21
 * Could merge, except for the samr_vcbuf_t mess.
 */

#define SAMR_SET_USER_INFO_21		21

struct samr_SetUserInfo21 {
	samr_quad_t		LastLogon;
	samr_quad_t		LastLogoff;
	samr_quad_t		PasswordLastSet;
	samr_quad_t		AccountExpires;
	samr_quad_t		PasswordCanChange;
	samr_quad_t		PasswordMustChange;

	samr_vcbuf_t		UserName;
	samr_vcbuf_t		FullName;
	samr_vcbuf_t		HomeDirectory;
	samr_vcbuf_t		HomeDirectoryDrive;
	samr_vcbuf_t		ScriptPath;
	samr_vcbuf_t		ProfilePath;
	samr_vcbuf_t		AdminComment;
	samr_vcbuf_t		WorkStations;
	samr_vcbuf_t		UserComment;
	samr_vcbuf_t		Parameters;

	struct samr_short_blob	LmOwfPassword;
	struct samr_short_blob	NtOwfPassword;
	samr_vcbuf_t		PrivateData;
	samr_sd_t		SecurityDescriptor;

	DWORD			UserId;	/* RID */
	DWORD			PrimaryGroupId;
	DWORD			UserAccountControl;
	DWORD			WhichFields;

	/*
	 * This should be samr_logon_hours_all, but apparently
	 * ndrgen doesn't get that quite right, so instead, the
	 * client-side code patches this up.
	 */
	struct samr_logon_info	LogonHours;

	WORD			BadPasswordCount;
	WORD			LogonCount;
	WORD			CountryCode;
	WORD			CodePage;
	BYTE			LmPasswordPresent;
	BYTE			NtPasswordPresent;
	BYTE			PasswordExpired;
	BYTE			PrivateDataSensitive;
};

/*
 *	SAMPR_USER_INTERNAL4_INFORMATION
 *	UserInternal4Information (23)
 */
#define SAMR_SET_USER_INFO_23		23
struct samr_SetUserInfo23 {
	struct samr_SetUserInfo21 info21;
	struct samr_encr_passwd encr_pw;
};

/*
 *	SAMPR_USER_INTERNAL5_INFORMATION
 *	UserInternal5Information (24)
 */
#define SAMR_SET_USER_INFO_24		24
struct samr_SetUserInfo24 {
	struct samr_encr_passwd encr_pw;
	BYTE password_expired;
};


union samr_SetUserInfo_u {
	UNION_INFO_ENT(16,samr_SetUserInfo);
	UNION_INFO_ENT(21,samr_SetUserInfo);
	UNION_INFO_ENT(23,samr_SetUserInfo);
	UNION_INFO_ENT(24,samr_SetUserInfo);
	DEFAULT  DWORD nothing;
};

struct samr_SetUserInfo_s {
	WORD info_level;
	WORD switch_value;
  SWITCH(switch_value)
	union samr_SetUserInfo_u ru;
};

OPERATION(SAMR_OPNUM_SetUserInfo)
struct samr_SetUserInfo {
	IN	samr_handle_t user_handle;
	IN	struct samr_SetUserInfo_s info;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * The SAMR interface definition.
 ***********************************************************************
 */
INTERFACE(0)
union samr_interface {
	CASE(SAMR_OPNUM_Connect)
		struct samr_Connect		Connect;
	CASE(SAMR_OPNUM_CloseHandle)
		struct samr_CloseHandle		CloseHandle;
	CASE(SAMR_OPNUM_QuerySecObject)
		struct samr_QuerySecObject	QuerySecObject;
	CASE(SAMR_OPNUM_LookupDomain)
		struct samr_LookupDomain	LookupDomain;
	CASE(SAMR_OPNUM_EnumLocalDomains)
		struct samr_EnumLocalDomain	EnumLocalDomain;
	CASE(SAMR_OPNUM_OpenDomain)
		struct samr_OpenDomain		OpenDomain;
	CASE(SAMR_OPNUM_QueryDomainInfo)
		struct samr_QueryDomainInfo	QueryDomainInfo;
	CASE(SAMR_OPNUM_QueryInfoDomain2)
		struct samr_QueryInfoDomain2	QueryInfoDomain2;
	CASE(SAMR_OPNUM_LookupNames)
		struct samr_LookupNames		LookupNames;
	CASE(SAMR_OPNUM_OpenUser)
		struct samr_OpenUser		OpenUser;
	CASE(SAMR_OPNUM_DeleteUser)
		struct samr_DeleteUser		DeleteUser;
	CASE(SAMR_OPNUM_QueryUserInfo)
		struct samr_QueryUserInfo	QueryUserInfo;
	CASE(SAMR_OPNUM_QueryUserGroups)
		struct samr_QueryUserGroups	QueryUserGroups;
	CASE(SAMR_OPNUM_OpenGroup)
		struct samr_OpenGroup		OpenGroup;
	CASE(SAMR_OPNUM_AddAliasMember)
		struct samr_AddAliasMember	AddAliasMember;
	CASE(SAMR_OPNUM_DeleteAliasMember)
		struct samr_DeleteAliasMember	DeleteAliasMember;
	CASE(SAMR_OPNUM_ListAliasMembers)
		struct samr_ListAliasMembers	ListAliasMembers;
	CASE(SAMR_OPNUM_GetUserPwInfo)
		struct samr_GetUserPwInfo	GetUserPwInfo;
	CASE(SAMR_OPNUM_CreateUser)
		struct samr_CreateUser		CreateUser;
	CASE(SAMR_OPNUM_ChangePasswordUser2)
		struct samr_ChangePasswordUser2	ChangePasswordUser2;
	CASE(SAMR_OPNUM_GetDomainPwInfo)
		struct samr_GetDomainPwInfo	GetDomainPwInfo;
	CASE(SAMR_OPNUM_Connect2)
		struct samr_Connect2		Connect2;
	CASE(SAMR_OPNUM_SetUserInfo)
		struct samr_SetUserInfo		SetUserInfo;
	CASE(SAMR_OPNUM_Connect4)
		struct samr_Connect4		Connect4;
	CASE(SAMR_OPNUM_Connect5)
		struct samr_Connect5		Connect5;
	CASE(SAMR_OPNUM_QueryDispInfo)
		struct samr_QueryDispInfo	QueryDispInfo;
	CASE(SAMR_OPNUM_OpenAlias)
		struct samr_OpenAlias		OpenAlias;
	CASE(SAMR_OPNUM_CreateDomainAlias)
		struct samr_CreateDomainAlias	CreateDomainAlias;
	CASE(SAMR_OPNUM_SetAliasInfo)
		struct samr_SetAliasInfo	SetAliasInfo;
	CASE(SAMR_OPNUM_QueryAliasInfo)
		struct samr_QueryAliasInfo	QueryAliasInfo;
	CASE(SAMR_OPNUM_DeleteDomainAlias)
		struct samr_DeleteDomainAlias	DeleteDomainAlias;
	CASE(SAMR_OPNUM_EnumDomainAliases)
		struct samr_EnumDomainAliases	EnumDomainAliases;
	CASE(SAMR_OPNUM_EnumDomainGroups)
		struct samr_EnumDomainGroups	EnumDomainGroups;
};
typedef union samr_interface	samr_interface_t;
EXTERNTYPEINFO(samr_interface)

#endif /* _MLSVC_SAM_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#ifndef _SECURITY_NDL_
#define	_SECURITY_NDL_

#define	USE_UINT_ENUMS 1

struct GUID {
	DWORD time_low;
	WORD time_mid;
	WORD time_hi_and_version;
	BYTE clock_seq[2];
	BYTE node[6];
};

#define	SEC_MASK_GENERIC	0xF0000000
#define	SEC_MASK_FLAGS		0x0F000000
#define	SEC_MASK_STANDARD	0x00FF0000
#define	SEC_MASK_SPECIFIC	0x0000FFFF
#define	SEC_GENERIC_ALL		0x10000000
#define	SEC_GENERIC_EXECUTE	0x20000000
#define	SEC_GENERIC_WRITE	0x40000000
#define	SEC_GENERIC_READ	0x80000000
#define	SEC_FLAG_SYSTEM_SECURITY 0x01000000
#define	SEC_FLAG_MAXIMUM_ALLOWED 0x02000000
#define	SEC_STD_DELETE		0x00010000
#define	SEC_STD_READ_CONTROL	0x00020000
#define	SEC_STD_WRITE_DAC	0x00040000
#define	SEC_STD_WRITE_OWNER	0x00080000
#define	SEC_STD_SYNCHRONIZE	0x00100000
#define	SEC_STD_REQUIRED	0x000F0000
#define	SEC_STD_ALL		0x001F0000
#define	SEC_FILE_READ_DATA	0x00000001
#define	SEC_FILE_WRITE_DATA	0x00000002
#define	SEC_FILE_APPEND_DATA	0x00000004
#define	SEC_FILE_READ_EA	0x00000008
#define	SEC_FILE_WRITE_EA	0x00000010
#define	SEC_FILE_EXECUTE	0x00000020
#define	SEC_FILE_READ_ATTRIBUTE	0x00000080
#define	SEC_FILE_WRITE_ATTRIBUTE 0x00000100
#define	SEC_FILE_ALL		0x000001ff
#define	SEC_DIR_LIST		0x00000001
#define	SEC_DIR_ADD_FILE	0x00000002
#define	SEC_DIR_ADD_SUBDIR	0x00000004
#define	SEC_DIR_READ_EA		0x00000008
#define	SEC_DIR_WRITE_EA	0x00000010
#define	SEC_DIR_TRAVERSE	0x00000020
#define	SEC_DIR_DELETE_CHILD	0x00000040
#define	SEC_DIR_READ_ATTRIBUTE	0x00000080
#define	SEC_DIR_WRITE_ATTRIBUTE	0x00000100
#define	SEC_REG_QUERY_VALUE	0x00000001
#define	SEC_REG_SET_VALUE	0x00000002
#define	SEC_REG_CREATE_SUBKEY	0x00000004
#define	SEC_REG_ENUM_SUBKEYS	0x00000008
#define	SEC_REG_NOTIFY		0x00000010
#define	SEC_REG_CREATE_LINK	0x00000020
#define	SEC_ADS_CREATE_CHILD	0x00000001
#define	SEC_ADS_DELETE_CHILD	0x00000002
#define	SEC_ADS_LIST		0x00000004
#define	SEC_ADS_SELF_WRITE	0x00000008
#define	SEC_ADS_READ_PROP	0x00000010
#define	SEC_ADS_WRITE_PROP	0x00000020
#define	SEC_ADS_DELETE_TREE	0x00000040
#define	SEC_ADS_LIST_OBJECT	0x00000080
#define	SEC_ADS_CONTROL_ACCESS	0x00000100
#define	SEC_RIGHTS_FILE_READ	SEC_STD_READ_CONTROL|SEC_STD_SYNCHRONIZE|SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE|SEC_FILE_READ_EA
#define	SEC_RIGHTS_FILE_WRITE	SEC_STD_READ_CONTROL|SEC_STD_SYNCHRONIZE|SEC_FILE_WRITE_DATA|SEC_FILE_WRITE_ATTRIBUTE|SEC_FILE_WRITE_EA|SEC_FILE_APPEND_DATA
#define	SEC_RIGHTS_FILE_EXECUTE	SEC_STD_SYNCHRONIZE|SEC_STD_READ_CONTROL|SEC_FILE_READ_ATTRIBUTE|SEC_FILE_EXECUTE
#define	SEC_RIGHTS_FILE_ALL	SEC_STD_ALL|SEC_FILE_ALL
#define	SEC_RIGHTS_DIR_READ	SEC_RIGHTS_FILE_READ
#define	SEC_RIGHTS_DIR_WRITE	SEC_RIGHTS_FILE_WRITE
#define	SEC_RIGHTS_DIR_EXECUTE	SEC_RIGHTS_FILE_EXECUTE
#define	SEC_RIGHTS_DIR_ALL	SEC_RIGHTS_FILE_ALL
#define	SID_NULL		"S-1-0-0"
#define	SID_WORLD_DOMAIN	"S-1-1"
#define	SID_WORLD		"S-1-1-0"
#define	SID_CREATOR_OWNER_DOMAIN "S-1-3"
#define	SID_CREATOR_OWNER	"S-1-3-0"
#define	SID_CREATOR_GROUP	"S-1-3-1"
#define	SID_NT_AUTHORITY	"S-1-5"
#define	SID_NT_DIALUP		"S-1-5-1"
#define	SID_NT_NETWORK		"S-1-5-2"
#define	SID_NT_BATCH		"S-1-5-3"
#define	SID_NT_INTERACTIVE	"S-1-5-4"
#define	SID_NT_SERVICE		"S-1-5-6"
#define	SID_NT_ANONYMOUS	"S-1-5-7"
#define	SID_NT_PROXY		"S-1-5-8"
#define	SID_NT_ENTERPRISE_DCS	"S-1-5-9"
#define	SID_NT_SELF		"S-1-5-10"
#define	SID_NT_AUTHENTICATED_USERS "S-1-5-11"
#define	SID_NT_RESTRICTED	"S-1-5-12"
#define	SID_NT_TERMINAL_SERVER_USERS "S-1-5-13"
#define	SID_NT_REMOTE_INTERACTIVE "S-1-5-14"
#define	SID_NT_THIS_ORGANISATION  "S-1-5-15"
#define	SID_NT_SYSTEM		"S-1-5-18"
#define	SID_NT_LOCAL_SERVICE	"S-1-5-19"
#define	SID_NT_NETWORK_SERVICE	"S-1-5-20"
#define	SID_BUILTIN		"S-1-5-32"
#define	SID_BUILTIN_ADMINISTRATORS "S-1-5-32-544"
#define	SID_BUILTIN_USERS	"S-1-5-32-545"
#define	SID_BUILTIN_GUESTS	"S-1-5-32-546"
#define	SID_BUILTIN_POWER_USERS	"S-1-5-32-547"
#define	SID_BUILTIN_ACCOUNT_OPERATORS	"S-1-5-32-548"
#define	SID_BUILTIN_SERVER_OPERATORS	"S-1-5-32-549"
#define	SID_BUILTIN_PRINT_OPERATORS	"S-1-5-32-550"
#define	SID_BUILTIN_BACKUP_OPERATORS	"S-1-5-32-551"
#define	SID_BUILTIN_REPLICATOR	"S-1-5-32-552"
#define	SID_BUILTIN_RAS_SERVERS	"S-1-5-32-553"
#define	SID_BUILTIN_PREW2K	"S-1-5-32-554"
#define	DOMAIN_RID_LOGON	9
#define	DOMAIN_RID_ADMINISTRATOR 500
#define	DOMAIN_RID_GUEST	501
#define	DOMAIN_RID_ADMINS	512
#define	DOMAIN_RID_USERS	513
#define	DOMAIN_RID_DCS		516
#define	DOMAIN_RID_CERT_ADMINS	517
#define	DOMAIN_RID_SCHEMA_ADMINS 518
#define	DOMAIN_RID_ENTERPRISE_ADMINS 519
#define	NT4_ACL_REVISION	SECURITY_ACL_REVISION_NT4
#define	SD_REVISION		SECURITY_DESCRIPTOR_REVISION_1

#ifndef USE_UINT_ENUMS
	enum sec_privilege {
	SEC_PRIV_SECURITY=1,
	SEC_PRIV_BACKUP=2,
	SEC_PRIV_RESTORE=3,
	SEC_PRIV_SYSTEMTIME=4,
	SEC_PRIV_SHUTDOWN=5,
	SEC_PRIV_REMOTE_SHUTDOWN=6,
	SEC_PRIV_TAKE_OWNERSHIP=7,
	SEC_PRIV_DEBUG=8,
	SEC_PRIV_SYSTEM_ENVIRONMENT=9,
	SEC_PRIV_SYSTEM_PROFILE=10,
	SEC_PRIV_PROFILE_SINGLE_PROCESS=11,
	SEC_PRIV_INCREASE_BASE_PRIORITY=12,
	SEC_PRIV_LOAD_DRIVER=13,
	SEC_PRIV_CREATE_PAGEFILE=14,
	SEC_PRIV_INCREASE_QUOTA=15,
	SEC_PRIV_CHANGE_NOTIFY=16,
	SEC_PRIV_UNDOCK=17,
	SEC_PRIV_MANAGE_VOLUME=18,
	SEC_PRIV_IMPERSONATE=19,
	SEC_PRIV_CREATE_GLOBAL=20,
	SEC_PRIV_ENABLE_DELEGATION=21,
	SEC_PRIV_INTERACTIVE_LOGON=22,
	SEC_PRIV_NETWORK_LOGON=23,
	SEC_PRIV_REMOTE_INTERACTIVE_LOGON=24
};
#else

#define	SEC_PRIV_SECURITY			1
#define	SEC_PRIV_BACKUP				2
#define	SEC_PRIV_RESTORE			3
#define	SEC_PRIV_SYSTEMTIME			4
#define	SEC_PRIV_SHUTDOWN			5
#define	SEC_PRIV_REMOTE_SHUTDOWN		6
#define	SEC_PRIV_TAKE_OWNERSHIP			7
#define	SEC_PRIV_DEBUG				8
#define	SEC_PRIV_SYSTEM_ENVIRONMENT		9
#define	SEC_PRIV_SYSTEM_PROFILE			10
#define	SEC_PRIV_PROFILE_SINGLE_PROCESS		11
#define	SEC_PRIV_INCREASE_BASE_PRIORITY		12
#define	SEC_PRIV_LOAD_DRIVER			13
#define	SEC_PRIV_CREATE_PAGEFILE		14
#define	SEC_PRIV_INCREASE_QUOTA			15
#define	SEC_PRIV_CHANGE_NOTIFY			16
#define	SEC_PRIV_UNDOCK				17
#define	SEC_PRIV_MANAGE_VOLUME			18
#define	SEC_PRIV_IMPERSONATE			19
#define	SEC_PRIV_CREATE_GLOBAL			20
#define	SEC_PRIV_ENABLE_DELEGATION		21
#define	SEC_PRIV_INTERACTIVE_LOGON		22
#define	SEC_PRIV_NETWORK_LOGON			23
#define	SEC_PRIV_REMOTE_INTERACTIVE_LOGON	24
#endif

struct dom_sid {
	BYTE sid_rev_num;
	BYTE num_auths;
	BYTE id_auth[6];
	DWORD *sub_auths;
};

/*
 * bitmap security_ace_flags
 */
#define	SEC_ACE_FLAG_OBJECT_INHERIT		0x01
#define	SEC_ACE_FLAG_CONTAINER_INHERIT		0x02
#define	SEC_ACE_FLAG_NO_PROPAGATE_INHERIT	0x04
#define	SEC_ACE_FLAG_INHERIT_ONLY		0x08
#define	SEC_ACE_FLAG_INHERITED_ACE		0x10
#define	SEC_ACE_FLAG_VALID_INHERIT		0x0f
#define	SEC_ACE_FLAG_SUCCESSFUL_ACCESS		0x40
#define	SEC_ACE_FLAG_FAILED_ACCESS		0x80

#ifndef USE_UINT_ENUMS
enum security_ace_type {
	SEC_ACE_TYPE_ACCESS_ALLOWED=0,
	SEC_ACE_TYPE_ACCESS_DENIED=1,
	SEC_ACE_TYPE_SYSTEM_AUDIT=2,
	SEC_ACE_TYPE_SYSTEM_ALARM=3,
	SEC_ACE_TYPE_ALLOWED_COMPOUND=4,
	SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT=5,
	SEC_ACE_TYPE_ACCESS_DENIED_OBJECT=6,
	SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT=7,
	SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT=8
};
#else
#define	SEC_ACE_TYPE_ACCESS_ALLOWED		0
#define	SEC_ACE_TYPE_ACCESS_DENIED		1
#define	SEC_ACE_TYPE_SYSTEM_AUDIT		2
#define	SEC_ACE_TYPE_SYSTEM_ALARM		3
#define	SEC_ACE_TYPE_ALLOWED_COMPOUND		4
#define	SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT	5
#define	SEC_ACE_TYPE_ACCESS_DENIED_OBJECT	6
#define	SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT	7
#define	SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT	8
#endif

/*
 * bitmap security_ace_object_flags
 */
#define	SEC_ACE_OBJECT_TYPE_PRESENT		0x00000001
#define	SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT	0x00000002

union security_ace_object_type {
	CASE(0) struct GUID type;
};

union security_ace_object_inherited_type {
	CASE(0) struct GUID inherited_type;
};

struct security_ace_object {
	DWORD flags;
};

union security_ace_object_ctr {
	CASE(0) struct security_ace_object object;
};

struct security_ace {
	DWORD security_ace_type;
	BYTE flags;
	WORD size;
	DWORD access_mask;
	struct dom_sid trustee;
};

#ifndef USE_UINT_ENUMS
enum security_acl_revision {
	SECURITY_ACL_REVISION_NT4=2,
	SECURITY_ACL_REVISION_ADS=4
};
#else
#define	SECURITY_ACL_REVISION_NT4	2
#define	SECURITY_ACL_REVISION_ADS	4
#endif

struct security_acl {
	DWORD security_acl_revision;
	WORD size;
	DWORD num_aces;
	struct security_ace *aces;
};

#ifndef USE_UINT_ENUMS
enum security_descriptor_revision {
	SECURITY_DESCRIPTOR_REVISION_1=1
};
#else
#define	SECURITY_DESCRIPTOR_REVISION_1	1
#endif

/*
 * bitmap security_descriptor_type
 */
#define	SEC_DESC_OWNER_DEFAULTED	0x0001
#define	SEC_DESC_GROUP_DEFAULTED	0x0002
#define	SEC_DESC_DACL_PRESENT		0x0004
#define	SEC_DESC_DACL_DEFAULTED		0x0008
#define	SEC_DESC_SACL_PRESENT		0x0010
#define	SEC_DESC_SACL_DEFAULTED		0x0020
#define	SEC_DESC_DACL_TRUSTED		0x0040
#define	SEC_DESC_SERVER_SECURITY	0x0080
#define	SEC_DESC_DACL_AUTO_INHERIT_REQ	0x0100
#define	SEC_DESC_SACL_AUTO_INHERIT_REQ	0x0200
#define	SEC_DESC_DACL_AUTO_INHERITED	0x0400
#define	SEC_DESC_SACL_AUTO_INHERITED	0x0800
#define	SEC_DESC_DACL_PROTECTED		0x1000
#define	SEC_DESC_SACL_PROTECTED		0x2000
#define	SEC_DESC_RM_CONTROL_VALID	0x4000
#define	SEC_DESC_SELF_RELATIVE		0x8000

struct security_descriptor {
	WORD revision;
	WORD type;
	DWORD ownersid;
	DWORD groupsid;
	DWORD sacl;
	DWORD dacl;
};

struct sec_desc_buf {
	DWORD sd_size;
	struct security_descriptor *sd;
};

struct security_token {
	struct dom_sid *user_sid;
	struct dom_sid *group_sid;
	DWORD num_sids;
	DWORD privilege_mask1;
	DWORD privilege_mask2;
};

/* 
 * bitmap security_secinfo
 */
#define	SECINFO_OWNER		0x00000001
#define	SECINFO_GROUP		0x00000002
#define	SECINFO_DACL		0x00000004
#define	SECINFO_SACL		0x00000008

#endif /* _SECURITY_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _SPOOLSS_NDL_
#define	_SPOOLSS_NDL_

#include <libmlrpc/ndrtypes.ndl>
#include "security.ndl"

#define TABLE_STRING 1
#define TABLE_DWORD  2
#define TABLE_TIME   3
#define TABLE_DEVMODE 4
#define TABLE_SECURITY_DESCRIPTOR 5

#define SPOOLSS_OPNUM_EnumPrinters			0x00
#define SPOOLSS_OPNUM_OpenPrinter			0x01
#define SPOOLSS_OPNUM_GetJob				0x03
#define SPOOLSS_OPNUM_EnumJobs				0x04
#define SPOOLSS_OPNUM_DeletePrinter			0x06
#define SPOOLSS_OPNUM_GetPrinter			0x08
#define SPOOLSS_OPNUM_GetPrinterDriver			0x0b
#define SPOOLSS_OPNUM_DeletePrinterDriver		0x0d
#define SPOOLSS_OPNUM_StartDocPrinter			0x11
#define SPOOLSS_OPNUM_StartPagePrinter			0x12
#define SPOOLSS_OPNUM_WritePrinter			0x13
#define SPOOLSS_OPNUM_EndPagePrinter			0x14
#define SPOOLSS_OPNUM_AbortPrinter			0x15
#define SPOOLSS_OPNUM_AddJob				0x18
#define SPOOLSS_OPNUM_ScheduleJob			0x19
#define SPOOLSS_OPNUM_GetPrinterData			0x1a
#define SPOOLSS_OPNUM_ClosePrinter			0x1d
#define SPOOLSS_OPNUM_AddForm				0x1e
#define SPOOLSS_OPNUM_DeleteForm			0x1f
#define SPOOLSS_OPNUM_EndDocPrinter			0x17
#define SPOOLSS_OPNUM_EnumForms				0x22
#define SPOOLSS_OPNUM_EnumPorts				0x23
#define	SPOOLSS_OPNUM_EnumMonitor			0x24
#define SPOOLSS_OPNUM_DeletePort			0x27
#define SPOOLSS_OPNUM_CreatePrinterIC			0x28
#define	SPOOLSS_OPNUM_AddMonitor			0x2e
#define	SPOOLSS_OPNUM_DeleteMonitor			0x2f
#define SPOOLSS_OPNUM_ResetPrinter			0x34
#define SPOOLSS_OPNUM_GetPrinterDriver2			0x35
#define SPOOLSS_OPNUM_FCPN				0x38
#define SPOOLSS_OPNUM_ReplyOpenPrinter			0x3a
#define SPOOLSS_OPNUM_ReplyClosePrinter			0x3c
#define SPOOLSS_OPNUM_AddPortEx				0x3d
#define SPOOLSS_OPNUM_RFFPCNEX				0x41
#define SPOOLSS_OPNUM_RRPCN				0x42
#define SPOOLSS_OPNUM_RFNPCNEX				0x43
#define SPOOLSS_OPNUM_OpenPrinterEx			0x45
#define SPOOLSS_OPNUM_SetPort				0x47
#define SPOOLSS_OPNUM_EnumPrinterData			0x48
#define SPOOLSS_OPNUM_EnumPrinterDataEx			0x4f
#define SPOOLSS_OPNUM_EnumPrinterKey			0x50

CONTEXT_HANDLE(spoolss_handle) spoolss_handle_t;

struct spoolssDevmodeContainer {
	BYTE 	DevContCount;
  SIZE_IS(DevContCount)
  	BYTE	*DevMode;
};


struct spoolss_DeviceMode {
	BYTE devicename[64];
	WORD specversion;
	WORD driverversion;
	WORD size;
	WORD driverextra_length;
	DWORD	fields;
	WORD orientation;
	WORD papersize;
	WORD paperlength;
	WORD paperwidth;
	WORD scale;
	WORD copies;
	WORD defaultsource;
	WORD printquality;
	WORD color;
	WORD duplex;
	WORD yresolution;
	WORD ttoption;
	WORD collate;
	BYTE formname[64];
	WORD logpixels;
	DWORD	bitsperpel;
	DWORD	pelswidth;
	DWORD	pelsheight;
	DWORD	displayflags;
	DWORD	displayfrequency;
	DWORD	icmmethod;
	DWORD	icmintent;
	DWORD	mediatype;
	DWORD	dithertype;
	DWORD	reserved1;
	DWORD	reserved2;
	DWORD	panningwidth;
	DWORD	panningheight;
	struct spoolssDevmodeContainer driverextra_data;
};

OPERATION(SPOOLSS_OPNUM_CreatePrinterIC)
struct spoolss_CreatePrinterIC {
	IN	spoolss_handle_t handle;
	OUT	spoolss_handle_t gdi_handle;
	IN	struct spoolssDevmodeContainer dmodeContainer;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_OpenPrinter)
struct spoolss_OpenPrinter {
	IN	LPTSTR printer_name;
	OUT	spoolss_handle_t handle;
	IN	LPTSTR data_type;
	/* IN	struct spoolssDevmodeContainer dmodeContainer; */
	/* IN	DWORD AccessRequired; */
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumJobs)
struct spoolss_EnumJobs {
	IN	spoolss_handle_t handle;
	IN	DWORD FirstJob;
	IN	DWORD NoJobs;
	IN	DWORD level;
	IN	DWORD Buf2;
	IN	DWORD 	BufCount;
		SIZE_IS(BufCount)
  	OUT		BYTE *pJob;
	OUT	DWORD needed;
	OUT	DWORD needed2;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_DeletePrinter)
struct spoolss_DeletePrinter {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

#define SPOOLSS_ARCHITECTURE_NT_X86	( "Windows NT x86" )
struct spoolss_Time {
	WORD year;
	WORD month;
	WORD day_of_week;
	WORD day;
	WORD hour;
	WORD minute;
	WORD second;
	WORD millisecond;
};

struct spoolss_GetPrinter0 {
	DWORD printername;
	DWORD servername;
	DWORD cjobs;
	DWORD total_jobs;
	DWORD total_bytes;
	DWORD time0;
	DWORD time1;
	DWORD time2;
	DWORD time3;
	DWORD global_counter;
	DWORD total_pages;
	DWORD version;
	DWORD ffreebuild;
	DWORD cspooling;
	DWORD cmaxspooling;
	DWORD session_counter;
	DWORD out_of_paper;
	DWORD not_ready;
	DWORD job_error;
	DWORD num_processors;
	DWORD type_processor;
	DWORD high_part_total_bytes;
	DWORD change_id;
	DWORD last_error;
	DWORD status;
	DWORD enum_network_printers;
	DWORD c_setprinter;
	WORD processor_arch;
	WORD processor_level;
	DWORD ref;
	DWORD reserved2;
	DWORD reserved3;
};

/* bitmap spoolss_EnumPrinterFlags */
#define PRINTER_ENUM_DEFAULT ( 0x00000001 )
#define PRINTER_ENUM_LOCAL ( 0x00000002 )
#define PRINTER_ENUM_CONNECTIONS ( 0x00000004 )
#define PRINTER_ENUM_FAVORITE ( 0x00000004 )
#define PRINTER_ENUM_NAME ( 0x00000008 )
#define PRINTER_ENUM_REMOTE ( 0x00000010 )
#define PRINTER_ENUM_SHARED ( 0x00000020 )
#define PRINTER_ENUM_NETWORK ( 0x00000040 )
#define PRINTER_ENUM_EXPAND ( 0x00004000 )
#define PRINTER_ENUM_CONTAINER ( 0x00008000 )
#define PRINTER_ENUM_ICON1 ( 0x00010000 )
#define PRINTER_ENUM_ICON2 ( 0x00020000 )
#define PRINTER_ENUM_ICON3 ( 0x00040000 )
#define PRINTER_ENUM_ICON4 ( 0x00080000 )
#define PRINTER_ENUM_ICON5 ( 0x00100000 )
#define PRINTER_ENUM_ICON6 ( 0x00200000 )
#define PRINTER_ENUM_ICON7 ( 0x00400000 )
#define PRINTER_ENUM_ICON8 ( 0x00800000 )
#define PRINTER_ENUM_HIDE ( 0x01000000 )

struct spoolss_GetPrinter1 {
	DWORD flags;
	DWORD name;
	DWORD description;
	DWORD comment;
};

/* bitmap spoolss_PrinterAttributes */
#define PRINTER_ATTRIBUTE_QUEUED ( 0x00000001 )
#define PRINTER_ATTRIBUTE_DIRECT ( 0x00000002 )
#define PRINTER_ATTRIBUTE_DEFAULT ( 0x00000004 )
#define PRINTER_ATTRIBUTE_SHARED ( 0x00000008 )
#define PRINTER_ATTRIBUTE_NETWORK ( 0x00000010 )
#define PRINTER_ATTRIBUTE_HIDDEN ( 0x00000020 )
#define PRINTER_ATTRIBUTE_LOCAL ( 0x00000040 )
#define PRINTER_ATTRIBUTE_ENABLE_DEVQ ( 0x00000080 )
#define PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS ( 0x00000100 )
#define PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST ( 0x00000200 )
#define PRINTER_ATTRIBUTE_WORK_OFFLINE ( 0x00000400 )
#define PRINTER_ATTRIBUTE_ENABLE_BIDI ( 0x00000800 )
#define PRINTER_ATTRIBUTE_RAW_ONLY ( 0x00001000 )
#define PRINTER_ATTRIBUTE_PUBLISHED ( 0x00002000 )
#define PRINTER_ATTRIBUTE_FAX ( 0x00004000 )
#define PRINTER_ATTRIBUTE_TS ( 0x00008000 )

/* bitmap spoolss_PrinterStatus */
#define PRINTER_STATUS_PAUSED ( 0x00000001 )
#define PRINTER_STATUS_ERROR ( 0x00000002 )
#define PRINTER_STATUS_PENDING_DELETION ( 0x00000004 )
#define PRINTER_STATUS_PAPER_JAM ( 0x00000008 )
#define PRINTER_STATUS_PAPER_OUT ( 0x00000010 )
#define PRINTER_STATUS_MANUAL_FEED ( 0x00000020 )
#define PRINTER_STATUS_PAPER_PROBLEM ( 0x00000040 )
#define PRINTER_STATUS_OFFLINE ( 0x00000080 )
#define PRINTER_STATUS_IO_ACTIVE ( 0x00000100 )
#define PRINTER_STATUS_BUSY ( 0x00000200 )
#define PRINTER_STATUS_PRINTING ( 0x00000400 )
#define PRINTER_STATUS_OUTPUT_BIN_FULL ( 0x00000800 )
#define PRINTER_STATUS_NOT_AVAILABLE ( 0x00001000 )
#define PRINTER_STATUS_WAITING ( 0x00002000 )
#define PRINTER_STATUS_PROCESSING ( 0x00004000 )
#define PRINTER_STATUS_INITIALIZING ( 0x00008000 )
#define PRINTER_STATUS_WARMING_UP ( 0x00010000 )
#define PRINTER_STATUS_TONER_LOW ( 0x00020000 )
#define PRINTER_STATUS_NO_TONER ( 0x00040000 )
#define PRINTER_STATUS_PAGE_PUNT ( 0x00080000 )
#define PRINTER_STATUS_USER_INTERVENTION ( 0x00100000 )
#define PRINTER_STATUS_OUT_OF_MEMORY ( 0x00200000 )
#define PRINTER_STATUS_DOOR_OPEN ( 0x00400000 )
#define PRINTER_STATUS_SERVER_UNKNOWN ( 0x00800000 )
#define PRINTER_STATUS_POWER_SAVE ( 0x01000000 )

struct spoolss_GetPrinter2 {
	DWORD servername;
	DWORD printername;
	DWORD sharename;
	DWORD portname;
	DWORD drivername;
	DWORD comment;
	DWORD location;
	DWORD devmode;
	DWORD sepfile;
	DWORD printprocessor;
	DWORD datatype;
	DWORD parameters;
	DWORD secdesc; 
	DWORD attributes;
	DWORD priority;
	DWORD defaultpriority;
	DWORD starttime;
	DWORD untiltime;
	DWORD status;
	DWORD cjobs;
	DWORD averageppm;
};

typedef struct spoolss_GetPrinter2 spoolss_GetPrinter2_t;

struct spoolss_GetPrinter3 {
	DWORD dummy;
};

struct spoolss_GetPrinter4 {
	DWORD printername;
	DWORD servername;
	DWORD attributes;
};

struct spoolss_GetPrinter5 {
	DWORD printername;
	DWORD portname;
	DWORD attributes;
	DWORD device_not_selected_timeout;
	DWORD transmission_retry_timeout;
};

struct spoolss_GetPrinter6 {
	DWORD status;
};

/* bitmap spoolss_DsPrintAction */
#define DSPRINT_PUBLISH ( 0x00000001 )
#define DSPRINT_UPDATE ( 0x00000002 )
#define DSPRINT_UNPUBLISH ( 0x00000004 )
#define DSPRINT_REPUBLISH ( 0x00000008 )
#define DSPRINT_PENDING ( 0x80000000 )

struct spoolss_GetPrinter7 {
	DWORD guid;
	DWORD action;
};

struct spoolss_GetPrinter8 {
	DWORD flags;
	DWORD name;
	DWORD description;
	DWORD comment;
};

union spoolss_GetPrinter_result_u {
	UNION_INFO_ENT(0, spoolss_GetPrinter);
	UNION_INFO_ENT(1, spoolss_GetPrinter);
	UNION_INFO_ENT(2, spoolss_GetPrinter);
	UNION_INFO_ENT(3, spoolss_GetPrinter);
	UNION_INFO_ENT(4, spoolss_GetPrinter);
	UNION_INFO_ENT(5, spoolss_GetPrinter);
	UNION_INFO_ENT(6, spoolss_GetPrinter);
	UNION_INFO_ENT(7, spoolss_GetPrinter);
	UNION_INFO_ENT(8, spoolss_GetPrinter);
	DEFAULT char *nullptr;
};

struct spoolss_GetPrinter_result {
	DWORD switch_value;
	SWITCH(switch_value)
		union spoolss_GetPrinter_result_u ru;
};

struct spoolss_RPC_V2_NOTIFY_OPTIONS_TYPE {
	WORD type;
	WORD reserved0;
	DWORD reserved1;
	DWORD reserved2;
	DWORD count;
	SIZE_IS(count)
		WORD *pFields;
};

struct spoolss_RPC_V2_NOTIFY_OPTIONS {
	DWORD version;
	DWORD reserved;
	DWORD count;
	SIZE_IS(count)
		struct spoolss_RPC_V2_NOTIFY_OPTIONS_TYPE *ptypes;
};

struct SYSTEMTIME {
	WORD year;
	WORD month;
	WORD dayofweek;
	WORD day;
	WORD hour;
	WORD minute;
	WORD second;
	WORD millisecs;
};

struct SECURITY_CONTAINER {
	DWORD count;
	SIZE_IS(count)
		BYTE *psecurity;
};

struct SYSTEMTIME_CONTAINER {
	DWORD count;
	struct SYSTEMTIME *psystemtime;
};

struct STRING_CONTAINER {
	DWORD count;
	SIZE_IS(count / 2)
		LPTSTR pstring;
};

union spoolss_RPC_V2_NOTIFY_INFO_DATA_DATA {
	CASE(TABLE_STRING)
		struct STRING_CONTAINER pcont;
	CASE(TABLE_DWORD)
		DWORD data[2];
	CASE(TABLE_TIME)
		struct SYSTEMTIME_CONTAINER system_time;
	CASE(TABLE_DEVMODE)
		struct spoolssDevmodeContainer devmode;
	CASE(TABLE_SECURITY_DESCRIPTOR)
		struct SECURITY_CONTAINER security_descriptor;
};

struct spoolss_RPC_V2_NOTIFY_INFO_DATA {
	WORD Type;
	WORD Field;
	DWORD Reserved;
	DWORD Id;
	SWITCH(Reserved & 0x0000FFFF)
		union spoolss_RPC_V2_NOTIFY_INFO_DATA_DATA data;
};

struct spoolss_RPC_V2_NOTIFY_INFO {
	DWORD Version;
	DWORD Flags;
	DWORD Count;
	SIZE_IS(Count)
		struct spoolss_RPC_V2_NOTIFY_INFO_DATA *aData;
};
	
OPERATION(SPOOLSS_OPNUM_GetPrinter)
struct spoolss_GetPrinter {
	IN	spoolss_handle_t handle;
	IN 	DWORD 	switch_value;
  	IN	DWORD   Buf2;
	IN	DWORD 	BufCount;
		SIZE_IS(BufCount)
  	OUT		BYTE *Buf;
	OUT	DWORD needed;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_GetPrinterData)
struct spoolss_GetPrinterData {
	IN	spoolss_handle_t handle;
	IN	REFERENCE LPTSTR pValueName;
	OUT	DWORD pType;
    SIZE_IS(Size)
   	OUT	REFERENCE LPBYTE Buf;
	IN	DWORD Size;
	OUT	DWORD Needed;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_GetPrinterDriver)
struct spoolss_GetPrinterDriver {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_DeletePrinterDriver)
struct spoolss_DeletePrinterDriver {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

struct spoolss_DocInfo {
	LPTSTR doc_name;
	LPTSTR printer_name;
	LPTSTR type;
};
typedef struct spoolss_DocInfo spoolss_DocInfo_t;

struct spoolss_DocInfo_Container {
	DWORD level;
	DWORD switch_value;
	spoolss_DocInfo_t *DocInfoContainer;
};
typedef struct spoolss_DocInfo_Container spoolss_DocInfo_Container_t;

OPERATION(SPOOLSS_OPNUM_StartDocPrinter)
struct spoolss_StartDocPrinter {
	IN	spoolss_handle_t handle;
	IN	spoolss_DocInfo_Container_t dinfo;
	OUT	DWORD JobId;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_AbortPrinter)
struct spoolss_AbortPrinter {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumPorts)
struct spoolss_EnumPorts {
	IN	LPTSTR name;
	IN	DWORD level;
	OUT	DWORD needed;
	OUT	DWORD returned;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_DeletePort)
struct spoolss_DeletePort {
	IN	LPTSTR name;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_AddPortEx)
struct spoolss_AddPortEx {
	IN	LPTSTR name;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_SetPort)
struct spoolss_SetPort {
	IN	LPTSTR name;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumMonitor)
struct spoolss_EnumMonitor {
	IN	LPTSTR name;
	IN	DWORD level;
	OUT	DWORD needed;
	OUT	DWORD returned;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_AddMonitor)
struct spoolss_AddMonitor {
	IN	LPTSTR name;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_DeleteMonitor)
struct spoolss_DeleteMonitor {
	IN	LPTSTR name;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_ResetPrinter)
struct spoolss_ResetPrinter {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_StartPagePrinter)
struct spoolss_StartPagePrinter {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EndPagePrinter)
struct spoolss_EndPagePrinter {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_WritePrinter)
struct spoolss_WritePrinter {
	IN	spoolss_handle_t handle;
	IN	DWORD BufCount;
		SIZE_IS(BufCount)
  	IN	REFERENCE LPBYTE pBuf;
	OUT	DWORD written;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_ScheduleJob)
struct spoolss_ScheduleJob {
	IN	spoolss_handle_t handle;
	IN 	DWORD 	JobId;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_GetJob)
struct spoolss_GetJob {
	IN	spoolss_handle_t handle;
	IN 	DWORD 	JobId;
	IN	DWORD 	level;
		SIZE_IS(BufCount)
  	INOUT		BYTE *pJob;
	IN	DWORD BufCount;
	OUT	DWORD needed;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_AddJob)
struct spoolss_AddJob {
	IN	spoolss_handle_t handle;
	IN 	DWORD 	level;
  	IN	DWORD   Buf2;
	IN	DWORD 	BufCount;
		SIZE_IS(BufCount)
  	OUT		BYTE *pAddJob;
	OUT	DWORD needed;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_ClosePrinter)
struct spoolss_ClosePrinter {
	IN	spoolss_handle_t handle;
	OUT	spoolss_handle_t result_handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EndDocPrinter)
struct spoolss_EndDocPrinter {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_AddForm)
struct spoolss_AddForm {
	IN	spoolss_handle_t handle;
	/*	FORM_CONTAINER *form_container; */
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_DeleteForm)
struct spoolss_DeleteForm {
	IN	spoolss_handle_t handle;
	/* IN	REFERENCE LPTSTR form_name; */
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumForms)
struct spoolss_EnumForms {
	IN	spoolss_handle_t handle;
	IN 	DWORD 	level;
	IN	DWORD 	BufCount;
		SIZE_IS(BufCount)
  	INOUT		BYTE *pEnumForms;
	OUT	DWORD needed;
	OUT	DWORD pcRet;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_GetPrinterDriver2)
struct spoolss_GetPrinterDriver2 {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_FCPN)
struct spoolss_FCPN {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_ReplyOpenPrinter)
struct spoolss_ReplyOpenPrinter {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_ReplyClosePrinter)
struct spoolss_ReplyClosePrinter {
	IN	DWORD dontcare;
	OUT	DWORD status;
};


OPERATION(SPOOLSS_OPNUM_RFFPCNEX)
struct spoolss_RFFPCNEX {
	IN	spoolss_handle_t handle;
	OUT	DWORD status;
};

struct spoolss_infores {
	DWORD entriesread;
	struct spoolss_RPC_V2_NOTIFY_INFO *pinfo;
};

OPERATION(SPOOLSS_OPNUM_RFNPCNEX)
struct spoolss_RFNPCNEX {
	IN	spoolss_handle_t handle;
	IN 	DWORD color;
	IN	struct spoolss_RPC_V2_NOTIFY_OPTIONS *poptions;
	OUT	struct spoolss_infores *ppinfo;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_RRPCN)
struct spoolss_RRPCN {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_OpenPrinterEx)
struct spoolss_OpenPrinterEx {
	IN	LPTSTR printer_name;
	OUT	spoolss_handle_t handle;
	IN	LPTSTR data_type;
	/* IN	struct spoolssDevmodeContainer dmodeContainer; */
	/* IN	DWORD AccessRequired; */
	/* IN	CLIENT_CONTAINER client_info; */
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumPrinterData)
struct spoolss_EnumPrinterData {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumPrinterDataEx)
struct spoolss_EnumPrinterDataEx {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

OPERATION(SPOOLSS_OPNUM_EnumPrinterKey)
struct spoolss_EnumPrinterKey {
	IN	DWORD dontcare;
	OUT	DWORD status;
};

/*
 ***********************************************************************
 * The spoolss interface definition.
 ***********************************************************************
 */

INTERFACE(0)
union spoolss_interface {
 	CASE(SPOOLSS_OPNUM_OpenPrinter)
		struct spoolss_OpenPrinter OpenPrinter;

	CASE(SPOOLSS_OPNUM_DeletePrinter)
		struct spoolss_DeletePrinter DeletePrinter;

	CASE(SPOOLSS_OPNUM_GetPrinter)
		struct spoolss_GetPrinter GetPrinter;

	CASE(SPOOLSS_OPNUM_GetPrinterData)
		struct spoolss_GetPrinterData GetPrinterData;
	
	CASE(SPOOLSS_OPNUM_AbortPrinter)
		struct spoolss_AbortPrinter AbortPrinter;
	
	CASE(SPOOLSS_OPNUM_StartDocPrinter)
		struct spoolss_StartDocPrinter StartDocPrinter;
	
	CASE(SPOOLSS_OPNUM_EndDocPrinter)
		struct spoolss_EndDocPrinter EndDocPrinter;
	
	CASE(SPOOLSS_OPNUM_CreatePrinterIC)
		struct spoolss_CreatePrinterIC CreatePrinterIC;
	
	CASE(SPOOLSS_OPNUM_ResetPrinter)
		struct spoolss_ResetPrinter ResetPrinter;

	CASE(SPOOLSS_OPNUM_EnumMonitor)
		struct spoolss_EnumMonitor EnumMonitor;

	CASE(SPOOLSS_OPNUM_AddMonitor)
		struct spoolss_AddMonitor AddMonitor;

	CASE(SPOOLSS_OPNUM_DeleteMonitor)
		struct spoolss_DeleteMonitor DeleteMonitor;

	CASE(SPOOLSS_OPNUM_WritePrinter)
		struct spoolss_WritePrinter WritePrinter;
	
	CASE(SPOOLSS_OPNUM_StartPagePrinter)
		struct spoolss_StartPagePrinter StartPagePrinter;
	
	CASE(SPOOLSS_OPNUM_EndPagePrinter)
		struct spoolss_EndPagePrinter EndPagePrinter;
	
	CASE(SPOOLSS_OPNUM_ClosePrinter)
		struct spoolss_ClosePrinter ClosePrinter;

	CASE(SPOOLSS_OPNUM_OpenPrinterEx)
		struct spoolss_OpenPrinterEx OpenPrinterEx;
	
	CASE(SPOOLSS_OPNUM_AddJob)
		struct spoolss_AddJob AddJob;

	CASE(SPOOLSS_OPNUM_GetJob)
		struct spoolss_GetJob GetJob;

	CASE(SPOOLSS_OPNUM_ScheduleJob)
		struct spoolss_ScheduleJob ScheduleJob;

	CASE(SPOOLSS_OPNUM_AddForm)
		struct spoolss_AddForm AddForm;

	CASE(SPOOLSS_OPNUM_DeleteForm)
		struct spoolss_DeleteForm DeleteForm;

	CASE(SPOOLSS_OPNUM_EnumForms)
		struct spoolss_EnumForms EnumForms;

	CASE(SPOOLSS_OPNUM_EnumPorts)
		struct spoolss_EnumPorts EnumPorts;

	CASE(SPOOLSS_OPNUM_DeletePort)
		struct spoolss_DeletePort DeletePort;

	CASE(SPOOLSS_OPNUM_AddPortEx)
		struct spoolss_AddPortEx AddPortEx;

	CASE(SPOOLSS_OPNUM_SetPort)
		struct spoolss_SetPort SetPort;

	CASE(SPOOLSS_OPNUM_RFNPCNEX)
		struct spoolss_RFNPCNEX RFNPCNEX;

};
typedef union spoolss_interface	spoolss_interface_t;
EXTERNTYPEINFO(spoolss_interface)

#endif /* _SPOOLSS_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_LANMAN_NDL_
#define _MLSVC_LANMAN_NDL_

/*
 * LanMan RPC (WKSSVC and SRVSVC) interface definitions.
 */

#include <libmlrpc/ndrtypes.ndl>

/*
 * WARNING: The cpp(1) macros in this file are not understood by
 *          /usr/bin/cpp. Use /usr/libexec/cpp instead.
 */

/*
 * TYPE CONSTRUCTOR MACROS FOR INFORMATION RESULTS
 ****************************************************************
 *
 * This is an explanation of the macros that follow this comment.
 *
 * The LANMAN API's look something like this:
 *
 *	NetXXXGetInfo (
 *		IN  char *  servername,
 *		IN  char *  XXX_name,
 *		IN  int     level,
 *		OUT char ** bufptr);
 *
 * The bufptr is a pointer-to-pointer (**). The NetXXXGetInfo() function
 * malloc()s memory, and sets *bufptr to the memory. The API's
 * are undiscriminated about what bufptr really points to.
 *
 * However, for RPI (Remote Procedure Interface), this just won't fly.
 * We have to know what the result data looks like in order to
 * properly (un)marshall it.
 *
 * As best we can determine, the MSC developers use an RPI that looks
 * like this (approximately in IDL):
 *
 *	RemoteNetXXXGetInfo (
 *		IN  char *  servername,
 *		IN  char *  XXX_name,
 *		IN  int     level,
 *		OUT union switch(level) {
 * 			case(1): XXX_INFO_1 * info1;
 *			case(2): XXX_INFO_2 * info2;
 *		    }       bufptr);
 *
 * The level guides the (un)marshalling as it follows the pointer.
 * DCE(MS) IDL will automatically form a structure for the union
 * which looks about like this (much as Sun/RPC does):
 *
 *	struct {
 *		int   _keyvalue_;
 *		union {
 *			XXX_INFO_1 *info1;
 *			XXX_INFO_2 *info2;
 *		}      _u_;
 *	} bufptr;
 *
 * This struct is not made visible to the application. It is purely
 * an internal (automagic) thing.  However, ndrgen does not do this.
 * The ndrgen input MUST remain a valid C header file, and all
 * struct and union declarations must be exact, and we (would) have
 * to tediously code sequences like this (approximately NDL)):
 *
 *	union XXXGetInfo_result_u {
 *	    [case(1)]
 *		XXX_INFO_1 *	info1;
 *	    [case(2)]
 *		XXX_INFO_2 *	info2;
 *	};
 *
 *	struct XXXGetInfo_result {
 *		int	level;
 *	   
 *		union XXXGetInfo_result_u bufptr;
 *	};
 *
 *	struct XXXGetInfo_param {	// still have to code this one
 *	    [in]  char *	servername;
 *	    [in]  ushort	level;
 *	    [out] struct XXXGetInfo_result result;
 *	};
 *
 * This is error prone and difficult to write, and more difficult
 * and distracting to read. It is hard to pick through the
 * necessary evils and see what's really going on. To mitigate
 * the situation, we have a series of macros which generate
 * the tedious code, and are easily recognized as supporting
 * fluff rather than important structures:
 *
 *	INFO1RES_DEFINITION(XXXGetInfo,
 *		INFO1RES_UNION_ENTRY(XXXGetInfo, 1)
 *		INFO1RES_UNION_ENTRY(XXXGetInfo, 2))
 *
 *	structt XXXGetInfo_param {	// still have to code this one
 *	    [in]  char *	servername;
 *	    [in]  ushort	level;
 *	    [out] struct XXXGetInfo_result result;
 *	};
 *
 * The INFO1RES_DEFINITION macro defines two types:
 *
 *	union ...__ru {...}
 *	struct ..._result { DWORD level; union ..._ru bufptr; }
 *
 * There is a similar macro, INFO1RESBUF_DEFINITION, which defines
 * actual space rather than just pointers. It defines:
 *
 *	union ...._rb {...}
 *	typedef union ..._rb ..._rb;
 *
 * Which is handy in functions because the initial coding sequence
 * looks something like:
 *
 *	XXXGetInfoParam (struct XXXGetInfo_param *param) {
 *		XXXGetInfo_rb	rb;
 *
 *		param->result.level = param->level;	// for marshalling
 *		param->result.bufptr.nullptr = &rb;	// anything fits
 *
 * There are two flavors of Info results. The first is the
 * single XXX_INFO_x result, which the foregoing example
 * uses. The second flavor is when there are multiple entries
 * possible. Again, for the sake of guiding the marshalling,
 * the RPIs use something accommodating:
 *
 *	struct XXX_INFO_1_result {
 *		unsigned	entriesread;
 *	   [size_is(entriesread)]
 *		XXX_INFO_1 *	table;
 *	};
 *
 *	union { XXX_INFO_1_result *info1; ...}
 *
 * Notice this is using XXX_INFO_1_result rather than just XXX_INFO_1.
 * The requirements from this point are much like before. Because of
 * the variable-length value, there is no realistic way to do something
 * like INFO1RESBUF_DEFINITION.
 *
 * There are two sets of macros here. INFO1RES_xxx are for the
 * single result case, and INFONRES_xxx for the multiple entry case.
 */

/*
 * INFO1RES_...
 *	Type constructors for single-result case
 */

#define INFO1RES_DEFINITION(INFOPREF, ENTRIES) \
	INFO1RES_UNION(INFOPREF, ENTRIES) \
	INFO1RES_STRUCT(INFOPREF)

#define INFO1RES_UNION(INFOPREF, ENTRIES) \
	union INFOPREF##__ru { \
		INFO1RES_UNION_NULLPTR \
		ENTRIES \
	};

#define INFO1RES_UNION_NULLPTR \
	DEFAULT char *			nullptr;

#define INFO1RES_UNION_ENTRY(INFOPREF,NUM) \
	CASE(NUM) struct INFOPREF##_##NUM * bufptr##NUM;

#define INFO1RES_STRUCT(INFOPREF) \
	struct INFOPREF##_result { \
		DWORD	level; \
	   SWITCH(level) \
		union INFOPREF##__ru bufptr; \
	};

/*
 * INFO1RESBUF_...
 *	Type constructors for single-result buffering.
 */


#ifndef NDRGEN
#define INFO1RESBUF_DEFINITION(INFOPREF, ENTRIES) \
	typedef union INFOPREF##_rb { \
		ENTRIES \
	} INFOPREF##_rb;
#define INFO1RESBUF_UNION_ENTRY(INFOPREF,NUM) \
	CASE(NUM) struct INFOPREF##_##NUM   buf##NUM;
#else
#define INFO1RESBUF_DEFINITION(INFOPREF, ENTRIES)
#define INFO1RESBUF_UNION_ENTRY(INFOPREF,NUM)
#endif




/*
 * INFONRES_...
 *	Type constructors for multiple-result case
 */

#define INFONRES_RESULT(INFOPREF,NUM) \
	struct INFOPREF##_##NUM##_result { \
		DWORD	entriesread; \
	    SIZE_IS(entriesread) \
		struct INFOPREF##_##NUM *entries; \
	};

#define INFONRES_DEFINITION(INFOPREF, ENTRIES) \
	INFONRES_UNION(INFOPREF, ENTRIES) \
	INFONRES_STRUCT(INFOPREF)

#define INFONRES_UNION(INFOPREF, ENTRIES) \
	union INFOPREF##__ru { \
		INFONRES_UNION_NULLPTR \
		INFONRES_UNION_INFONRES \
		ENTRIES \
	};

#define INFONRES_UNION_NULLPTR \
	DEFAULT char *			nullptr;

#ifndef NDRGEN
#define INFONRES_UNION_INFONRES \
	struct mslm_infonres *		p;
#else
#define INFONRES_UNION_INFONRES
#endif

#define INFONRES_UNION_ENTRY(INFOPREF,NUM) \
	CASE(NUM) struct INFOPREF##_##NUM##_result * bufptr##NUM;

#define INFONRES_STRUCT(INFOPREF) \
	struct INFOPREF##_result { \
		DWORD	level; \
	   SWITCH(level) \
		union INFOPREF##__ru bufptr; \
	};

#ifndef NDRGEN
/*
 * This just makes things a little easier on the stub modules:
 *
 *	XXXGetInfoParam (struct XXXGetInfo_param *param) {
 *		struct mslm_infonres	infonres;
 *		
 *		infonres.entriesread = 0;
 *		infonres.entries = 0;
 *		param->result.level = param->level;	// for marshalling
 *		param->result.bufptr.p = &infonres;
 */
struct mslm_infonres {
	DWORD		entriesread;
	void *		entries;
};
#endif


/*
 * SRVSVC - Server Service
 */

/* Windows NT */
#define SRVSVC_OPNUM_NetCharDevEnum              0x00
#define SRVSVC_OPNUM_NetCharDevGetInfo           0x01
#define SRVSVC_OPNUM_NetCharDevControl           0x02
#define SRVSVC_OPNUM_NetCharDevQEnum             0x03
#define SRVSVC_OPNUM_NetCharDevQGetInfo          0x04
#define SRVSVC_OPNUM_NetCharDevQSetInfo          0x05
#define SRVSVC_OPNUM_NetCharDevQPurge            0x06
#define SRVSVC_OPNUM_NetCharDevQPurgeSelf        0x07
#define SRVSVC_OPNUM_NetConnectEnum              0x08
#define SRVSVC_OPNUM_NetFileEnum                 0x09
#define SRVSVC_OPNUM_NetFileGetInfo              0x0a
#define SRVSVC_OPNUM_NetFileClose                0x0b
#define SRVSVC_OPNUM_NetSessionEnum              0x0c
#define SRVSVC_OPNUM_NetSessionDel               0x0d
#define SRVSVC_OPNUM_NetShareAdd                 0x0e
#define SRVSVC_OPNUM_NetShareEnum                0x0f
#define SRVSVC_OPNUM_NetShareGetInfo             0x10
#define SRVSVC_OPNUM_NetShareSetInfo             0x11
#define SRVSVC_OPNUM_NetShareDel                 0x12
#define SRVSVC_OPNUM_NetShareDelSticky           0x13
#define SRVSVC_OPNUM_NetShareCheck               0x14
#define SRVSVC_OPNUM_NetServerGetInfo            0x15
#define SRVSVC_OPNUM_NetServerSetInfo            0x16
#define SRVSVC_OPNUM_NetServerDiskEnum           0x17
#define SRVSVC_OPNUM_NetServerStatisticsGet      0x18
#define SRVSVC_OPNUM_NetServerTransportAdd       0x19
#define SRVSVC_OPNUM_NetServerTransportEnum      0x1a
#define SRVSVC_OPNUM_NetServerTransportDel       0x1b
#define SRVSVC_OPNUM_NetRemoteTOD                0x1c
#define SRVSVC_OPNUM_NetServerSetServiceBits     0x1d
#define SRVSVC_OPNUM_NetPathType                 0x1e
#define SRVSVC_OPNUM_NetPathCanonicalize         0x1f
#define SRVSVC_OPNUM_NetPathCompare              0x20
#define SRVSVC_OPNUM_NetNameValidate             0x21
#define SRVSVC_OPNUM_NetNameCanonicalize         0x22
#define SRVSVC_OPNUM_NetNameCompare              0x23
#define SRVSVC_OPNUM_NetShareEnumSticky          0x24
#define SRVSVC_OPNUM_NetShareDelStart            0x25
#define SRVSVC_OPNUM_NetShareDelCommit           0x26
#define SRVSVC_OPNUM_NetGetFileSecurity          0x27
#define SRVSVC_OPNUM_NetSetFileSecurity          0x28
#define SRVSVC_OPNUM_NetServerTransportAddEx     0x29
#define SRVSVC_OPNUM_NetServerSetServiceBitsEx   0x2a
#define SRVSVC_OPNUM_NetDfsGetVersion            0x2b

/* Windows 2000 */
#define SRVSVC_OPNUM_NetDfsCreateLocalPartition  0x2c
#define SRVSVC_OPNUM_NetDfsDeleteLocalPartition  0x2d
#define SRVSVC_OPNUM_NetDfsSetLocalVolumeState   0x2e
#define SRVSVC_OPNUM_NetDfsSetServerInfo         0x2f
#define SRVSVC_OPNUM_NetDfsCreateExitPoint       0x30
#define SRVSVC_OPNUM_NetDfsDeleteExitPoint       0x31
#define SRVSVC_OPNUM_NetDfsModifyPrefix          0x32
#define SRVSVC_OPNUM_NetDfsFixLocalVolume        0x33
#define SRVSVC_OPNUM_NetDfsManagerReportSiteInfo 0x34

/* Windows XP and Windows Server 2003 */
#define SRVSVC_OPNUM_NetServerTransportDelEx     0x35

/* Windows Vista */
#define SRVSVC_OPNUM_NetServerAliasAdd           0x36
#define SRVSVC_OPNUM_NetServerAliasEnum          0x37
#define SRVSVC_OPNUM_NetServerAliasDel           0x38
#define SRVSVC_OPNUM_NetShareDelEx               0x39

/*
 ***********************************************************************
 * NetConnectEnum
 ***********************************************************************
 */

/* 
 * Level 0 connect information.
 */
struct mslm_NetConnectInfoBuf0 {
        DWORD coni0_id;
};
typedef struct mslm_NetConnectInfoBuf0 srvsvc_NetConnectInfoBuf0_t;

struct mslm_NetConnectInfo0 {
	DWORD entries_read;
  SIZE_IS(entries_read)
        struct mslm_NetConnectInfoBuf0 *ci0;
};
typedef struct mslm_NetConnectInfo0 srvsvc_NetConnectInfo0_t;

/* 
 * Level 1 connect information.
 */	
struct mslm_NetConnectInfoBuf1 {
	DWORD coni1_id;
	DWORD coni1_type;
	DWORD coni1_num_opens;
	DWORD coni1_num_users;
	DWORD coni1_time;
	LPTSTR coni1_username;
	LPTSTR coni1_netname; /* share name */
};
typedef struct mslm_NetConnectInfoBuf1 srvsvc_NetConnectInfoBuf1_t;

struct mslm_NetConnectInfo1 {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslm_NetConnectInfoBuf1 *ci1;
};
typedef struct mslm_NetConnectInfo1 srvsvc_NetConnectInfo1_t;

union mslm_NetConnectInfoResUnion {
	CASE(0) struct mslm_NetConnectInfo0 *info0;
	CASE(1) struct mslm_NetConnectInfo1 *info1;
	DEFAULT	char *nullptr;
};

struct mslm_NetConnectInfo {
	DWORD level;
	DWORD switch_value;
  SWITCH(switch_value)
	union mslm_NetConnectInfoResUnion ru;
};
typedef struct mslm_NetConnectInfo srvsvc_NetConnectInfo_t;

OPERATION(SRVSVC_OPNUM_NetConnectEnum)
struct mslm_NetConnectEnum {
	IN	LPTSTR servername;		
	IN	LPTSTR qualifier; /* share name */
	INOUT	struct mslm_NetConnectInfo info;
	IN	DWORD pref_max_len;
	OUT 	DWORD total_entries;
	INOUT	DWORD *resume_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * NetFileEnum
 ***********************************************************************
 */
struct mslm_NetFileInfoBuf2 {
	DWORD fi2_id;
};
typedef struct mslm_NetFileInfoBuf2 srvsvc_NetFileInfoBuf2_t;

struct mslm_NetFileInfo2 {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslm_NetFileInfoBuf2 *fi2;
};
typedef struct mslm_NetFileInfo2 srvsvc_NetFileInfo2_t;

struct mslm_NetFileInfoBuf3 {
	DWORD fi3_id;
	DWORD fi3_permissions;
	DWORD fi3_num_locks;
	LPTSTR fi3_pathname;
	LPTSTR fi3_username;
};
typedef struct mslm_NetFileInfoBuf3 srvsvc_NetFileInfoBuf3_t;

struct mslm_NetFileInfo3 {
	DWORD entries_read;
  SIZE_IS(entries_read)
	struct mslm_NetFileInfoBuf3 *fi3;
};
typedef struct mslm_NetFileInfo3 srvsvc_NetFileInfo3_t;

union mslm_NetFileInfoResUnion {
	CASE(2)	struct mslm_NetFileInfo2 *info2;
	CASE(3)	struct mslm_NetFileInfo3 *info3;
	DEFAULT	char *nullptr;
};

struct mslm_NetFileInfo {
	DWORD level;
	DWORD switch_value;
  SWITCH(switch_value)
	union mslm_NetFileInfoResUnion ru;
};

OPERATION(SRVSVC_OPNUM_NetFileEnum)
struct mslm_NetFileEnum {
	IN	LPTSTR servername;
	IN	DWORD basepath;
	IN	DWORD username;
	INOUT	struct mslm_NetFileInfo info;
	IN	DWORD pref_max_len;
	OUT	DWORD total_entries;
	INOUT	DWORD *resume_handle;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * NetFileClose
 *
 * Close files using a file id reported by NetFileEnum.
 ***********************************************************************
 */
OPERATION(SRVSVC_OPNUM_NetFileClose)
struct mslm_NetFileClose {
	IN	LPTSTR servername;
	IN	DWORD file_id;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * NetShareGetInfo/NetShareSetInfo: netname is the name of a share.
 *
 * Levels:
 *  0      The share name.
 *  1      Information about the shared resource: name, type of resource
 *         and a comment.
 *  2      Information about the shared resource: name, type, permissions,
 *         password and number of connections.
 *  501    Information about the shared resource: name, type of resource
 *         and a comment.
 *  502    Information about the shared resource, including the name, type,
 *         permissions, number of connections etc.
 *  503    Contains information about the shared resource; identical to 502
 *         except for the addition of a servername.
 *  1004   A comment for the shared resource.
 *  1005   A set of flags describing the shared resource.
 *  1006   The maximum number of concurrent connections that the shared
 *         resource can accommodate.
 *  1501   Specifies the SECURITY_DESCRIPTOR for the share.
 *
 * Windows Me/98/95 supports level 50, which is similar to level 1.
 *
 * shi1005_flags: SHI1005_VALID_FLAGS_SET defines the set of flags that
 * can be set with the NetShareSetInfo function. SHI1005_FLAGS_DFS and
 * SHI1005_FLAGS_DFS_ROOT can only be returned, but not set.
 *
 * 0x01    SHI1005_FLAGS_DFS
 *         The specified share is present in a Dfs tree structure.
 *         This flag cannot be set with NetShareSetInfo. 
 *
 * 0x02    SHI1005_FLAGS_DFS_ROOT
 *         The specified share is the root volume in a Dfs tree.
 *         This flag cannot be set with NetShareSetInfo. 
 *
 * 0x30    CSC_MASK               Client-side caching (CSC) state:
 *   0x00  CSC_CACHE_MANUAL_REINT Automatic file-by-file
 *                                reintegration not allowed. 
 *   0x10  CSC_CACHE_AUTO_REINT   File-by-file reintegration allowed. 
 *   0x20  CSC_CACHE_VDO          File opens do not need to be flowed. 
 *   0x30  CSC_CACHE_NONE         CSC is disabled for this share.  
 *
 * 0x0100  SHI1005_FLAGS_RESTRICT_EXCLUSIVE_OPENS
 *         The specified share disallows exclusive file opens,
 *         where reads to an open file are disallowed. 
 *
 * 0x0200  SHI1005_FLAGS_FORCE_SHARED_DELETE
 *         Shared files in the specified share can be forcibly deleted. 
 *
 * 0x0400  SHI1005_FLAGS_ALLOW_NAMESPACE_CACHING
 *         Clients are allowed to cache the namespace of the share. 
 *
 * 0x0800  SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM
 *         The server will filter directory entries based on the access
 *         permissions of the client.  The access-based enumeration (ABE)
 *         flag may also appear as SHI1005_FLAGS_ENFORCE_NAMESPACE_ACCESS.
 *
 * Support for Access-based Enumeration (ABE) was added to Windows in
 * Windows Server 2003 Service Pack 1. ABE filters directory contents
 * (and other shared resources) returned via a share based on a user's
 * access rights, i.e. a user would not see objects that are
 * inaccessible to that user. ABE requests are made using info level
 * 1005 with the value 0x0800 in the flags field.
 ***********************************************************************
 */

#define	CSC_MASK		0x30
#define	CSC_CACHE_MANUAL_REINT	0x00
#define	CSC_CACHE_AUTO_REINT	0x10
#define	CSC_CACHE_VDO		0x20
#define	CSC_CACHE_NONE		0x30

#define	MLSM_SID_AUTH_MAX	6
/*
 * Definition for a SID. The ndl compiler does not allow a typedef of
 * a structure containing variable size members.
 */
struct mslm_sid {
	BYTE		revision;
	BYTE		sub_auth_count;
	BYTE		authority[MLSM_SID_AUTH_MAX];
  SIZE_IS(sub_auth_count)
	DWORD		sub_authority[ANY_SIZE_ARRAY];
};

struct mslm_ace_hdr {
	BYTE		type;
	BYTE		flags;
	WORD		size;
};
typedef struct mslm_ace_hdr mslm_ace_hdr_t;

struct mslm_ace {
	mslm_ace_hdr_t	header;
	DWORD		mask;
	struct mslm_sid	*sid;
};
typedef struct mslm_ace mslm_ace_t;

struct mslm_acl {
	BYTE		revision;
	BYTE		sbz1;
	WORD		size;
	WORD		ace_count;
	WORD		sbz2;
    SIZE_IS(ace_count)
	mslm_ace_t	ace[ANY_SIZE_ARRAY];
};

/*
 * SRVSVC definition of a security_descriptor.
 */
struct mslm_security_descriptor {
	BYTE revision;
	BYTE sbz1;
	WORD control;
	DWORD offset_owner;
	DWORD offset_group;
	DWORD offset_sacl;
	DWORD offset_dacl;
	struct mslm_sid *owner;
	struct mslm_sid *group;
	struct mslm_acl *sacl;
	struct mslm_acl *dacl;
};
typedef struct mslm_security_descriptor mslm_security_descriptor_t;

struct mslm_NetShareInfo_0 {
	LPTSTR shi0_netname;
};

struct mslm_NetShareInfo_1 {
	LPTSTR shi1_netname;
	DWORD shi1_type; /* type of resource such as IPC$ */
	LPTSTR shi1_comment;
};

struct mslm_NetShareInfo_2 {
	LPTSTR shi2_netname;
	DWORD shi2_type;
	LPTSTR shi2_comment;
	DWORD shi2_permissions;
	DWORD shi2_max_uses;
	DWORD shi2_current_uses;
	LPTSTR shi2_path;
	LPTSTR shi2_passwd;
};

struct mslm_NetShareInfo_501 {
	LPTSTR shi501_netname;
	DWORD shi501_type;
	LPTSTR shi501_comment;
	DWORD shi501_flags;
};

struct mslm_NetShareInfo_502 {
	LPTSTR shi502_netname;
	DWORD shi502_type;
	LPTSTR shi502_comment;
	DWORD shi502_permissions;
	DWORD shi502_max_uses;
	DWORD shi502_current_uses;
	LPTSTR shi502_path;
	LPTSTR shi502_passwd;
	DWORD shi502_reserved;
    SIZE_IS(shi502_reserved)
	LPBYTE shi502_security_descriptor;
};

struct mslm_NetShareInfo_503 {
	LPTSTR shi503_netname;
	DWORD shi503_type;
	LPTSTR shi503_comment;
	DWORD shi503_permissions;
	DWORD shi503_max_uses;
	DWORD shi503_current_uses;
	LPTSTR shi503_path;
	LPTSTR shi503_passwd;
	LPTSTR shi503_servername;
	DWORD shi503_reserved;
    SIZE_IS(shi503_reserved)
	LPBYTE shi503_security_descriptor;
};

struct mslm_NetShareInfo_1004 {
	LPTSTR shi1004_comment;
};

struct mslm_NetShareInfo_1005 {
	DWORD shi1005_flags;
};

struct mslm_NetShareInfo_1006 {
	DWORD shi1006_max_uses;
};

struct mslm_NetShareInfo_1501 {
	DWORD shi1501_reserved;
    SIZE_IS(shi1501_reserved)
	LPBYTE shi1501_security_descriptor;
};

union mlsm_NetShareInfoResUnion {
	CASE(0)		struct mslm_NetShareInfo_0 *info0;
	CASE(1)		struct mslm_NetShareInfo_1 *info1;
	CASE(2)		struct mslm_NetShareInfo_2 *info2;
	CASE(501)	struct mslm_NetShareInfo_501 *info501;
	CASE(502)	struct mslm_NetShareInfo_502 *info502;
	CASE(503)	struct mslm_NetShareInfo_503 *info503;
	CASE(1004)	struct mslm_NetShareInfo_1004 *info1004;
	CASE(1005)	struct mslm_NetShareInfo_1005 *info1005;
	CASE(1006)	struct mslm_NetShareInfo_1006 *info1006;
	CASE(1501)	struct mslm_NetShareInfo_1501 *info1501;
	DEFAULT	char *nullptr;
};


struct mlsm_NetShareInfoRes {
	DWORD switch_value;
  SWITCH(switch_value)
	union mlsm_NetShareInfoResUnion ru;
};


OPERATION(SRVSVC_OPNUM_NetShareGetInfo)
struct mlsm_NetShareGetInfo {
	IN	LPTSTR servername;
	IN REFERENCE	LPTSTR netname;
	IN	DWORD level;
	OUT	struct mlsm_NetShareInfoRes result;
	OUT	DWORD status;
};


OPERATION(SRVSVC_OPNUM_NetShareSetInfo)
struct mlsm_NetShareSetInfo {
	IN	LPTSTR servername;
	IN REFERENCE	LPTSTR netname;
	IN	DWORD level;
	IN	struct mlsm_NetShareInfoRes result;
	INOUT	DWORD *parm_err;
	OUT	DWORD status;
};


/*
 ***********************************************************************
 * NetSessionEnum 
 *
 * The NetSessionEnum function provides information about sessions
 * established on a server.
 *
 * Only members of the Administrators or Account Operators local groups
 * can successfully execute the NetSessionEnum function at level 1 or
 * level 2. No special group membership is required for level 0 or level
 * 10 calls.
 *
 * Windows NT/2000/XP: The parameter order is as follows.
 *
 * NET_API_STATUS NetSessionEnum(LPWSTR servername,
 *                               LPWSTR UncClientName,
 *                               LPWSTR username,
 *                               DWORD level,
 *                               LPBYTE *bufptr,
 *                               DWORD prefmaxlen,
 *                               LPDWORD entriesread,
 *                               LPDWORD totalentries,
 *                               LPDWORD resume_handle);
 *
 * Windows 95/98/Me: The calling application must use the cbBuffer parameter
 * to specify the size, in bytes, of the information buffer pointed to by the
 * pbBuffer parameter. (The cbBuffer parameter replaces the prefmaxlen
 * parameter.) Neither a user name parameter nor a resume handle parameter is
 * available on this platform. Therefore, the parameter list is as follows.
 *
 * API_FUNCTION NetSessionEnum(const char FAR *pszServer,
 *                             short sLevel,
 *                             char FAR *pbBuffer,
 *                             unsigned short cbBuffer,
 *                             unsigned short FAR *pcEntriesRead,
 *                             unsigned short FAR *pcTotalAvail);
 *
 * Parameters
 *
 * servername
 * [in] Pointer to a string that specifies the DNS or NetBIOS name of the
 * remote server on which the function is to execute. If this parameter is
 * NULL, the local computer is used.
 * Windows NT 4.0 and earlier: This string must begin with \\.
 *
 * UncClientName
 * [in] Pointer to a string that specifies the name of the computer session
 * for which information is to be returned. If this parameter is NULL,
 * NetSessionEnum returns information for all computer sessions on the server.
 *
 * username
 * [in] Pointer to a string that specifies the name of the user for which 
 * information is to be returned. If this parameter is NULL, NetSessionEnum 
 * returns information for all users.
 *
 * level
 * [in] Specifies the information level of the data. This parameter can be
 * one of the following values.
 * Windows NT/2000/XP: The following levels are valid.
 * Value    Meaning
 * 0        Return the name of the computer that established the session.
 *          The bufptr parameter points to an array of SESSION_INFO_0
 *          structures.
 * 1        Return the name of the computer, name of the user, and open files,
 *          pipes, and devices on the computer. The bufptr parameter points to
 *          an array of SESSION_INFO_1 structures.
 * 2        In addition to the information indicated for level 1, return the
 *          type of client and how the user established the session. The bufptr
 *          parameter points to an array of SESSION_INFO_2 structures.
 * 10       Return the name of the computer, name of the user, and active and
 *          idle times for the session. The bufptr parameter points to an array
 *          of SESSION_INFO_10 structures. 
 * 502      Return the name of the computer; name of the user; open files, 
 *          pipes, and devices on the computer; and the name of the transport 
 *          the  client is using. The bufptr parameter points to an array of 
 *          SESSION_INFO_502 structures. 
 *
 * Windows 95/98/Me: The following level is valid. 
 * Value    Meaning 
 * 50       Return the name of the computer, name of the user, open files on 
 *          the computer, and the name of the transport protocol the client is 
 *          using. The pbBuffer parameter points to an array of session_info_50 
 *          structures. 
 *
 * bufptr 
 * [out] Pointer to the buffer that receives the data. The format of this 
 * data depends on the value of the level parameter. 
 * Windows NT/2000/XP: This buffer is allocated by the system and must be 
 * freed using the NetApiBufferFree function. Note that you must free the 
 * buffer even if the function fails with ERROR_MORE_DATA. 
 * Windows 95/98/Me: The caller must allocate and deallocate this buffer. 
 *
 * prefmaxlen 
 * [in] Specifies the preferred maximum length of returned data, in bytes. 
 * If you specify MAX_PREFERRED_LENGTH, the function allocates the amount 
 * of memory required for the data. If you specify another value in this 
 * parameter, it can restrict the number of bytes that the function returns. 
 * If the buffer size is insufficient to hold all entries, the function 
 * returns ERROR_MORE_DATA. For more information, see Network Management 
 * Function Buffers and Network Management Function Buffer Lengths. 
 *
 * entriesread 
 * [out] Pointer to a value that receives the count of elements actually 
 * enumerated.
 *
 * totalentries 
 * [out] Pointer to a value that receives the total number of entries that 
 * could have been enumerated from the current resume position. 
 *
 * resume_handle 
 * [in/out] Pointer to a value that contains a resume handle which is used 
 * to continue an existing session search. The handle should be zero on the 
 * first call and left unchanged for subsequent calls. If resume_handle is 
 * NULL, no resume handle is stored. 
 *
 *
 * SESSION_INFO_1
 * ==============
 * The SESSION_INFO_1 structure contains information about the session,
 * including name of the computer; name of the user; and open files, pipes,
 * and devices on the computer.
 *
 * Members
 *
 * sesi1_cname
 * Pointer to a Unicode string specifying the name of the computer that
 * established the session.
 *
 * sesi1_username
 * Pointer to a Unicode string specifying the name of the user who established
 * the session.
 *
 * sesi1_num_opens
 * Specifies a DWORD value that contains the number of files, devices,
 * and pipes opened during the session.
 *
 * sesi1_time
 * Specifies a DWORD value that contains the number of seconds the session
 * has been active.
 * 
 * sesi1_idle_time
 * Specifies a DWORD value that contains the number of seconds the session
 * has been idle.
 *
 * sesi1_user_flags
 * Specifies a DWORD value that describes how the user established the
 * session. This member can be one of the following values:
 * SESS_GUEST           The user specified by the sesi1_username member
 *                      established the session using a guest account.
 * SESS_NOENCRYPTION    The user specified by the sesi1_username member
 *                      established the session without using password
 *                      encryption.
 ***********************************************************************
 */

#define SESS_GUEST          0x00000001
#define SESS_NOENCRYPTION   0x00000002

struct mslm_SESSION_INFO_0 {
	LPTSTR sesi0_cname;
};
INFONRES_RESULT(mslm_SESSION_INFO, 0)

struct mslm_SESSION_INFO_1 {
	LPTSTR sesi1_cname;
	LPTSTR sesi1_uname;
	DWORD  sesi1_nopens;
	DWORD  sesi1_time;
	DWORD  sesi1_itime;
	DWORD  sesi1_uflags;
};
INFONRES_RESULT(mslm_SESSION_INFO, 1)

struct mslm_SESSION_INFO_2 {
	LPTSTR sesi2_cname;
	LPTSTR sesi2_uname;
	DWORD  sesi2_nopens;
	DWORD  sesi2_time;
	DWORD  sesi2_itime;
	DWORD  sesi2_uflags;
	LPTSTR sesi2_cltype_name;
};
INFONRES_RESULT(mslm_SESSION_INFO, 2)

struct mslm_SESSION_INFO_10 {
	LPTSTR sesi10_cname;
	LPTSTR sesi10_uname;
	DWORD  sesi10_time;
	DWORD  sesi10_itime;
};
INFONRES_RESULT(mslm_SESSION_INFO, 10)

struct mslm_SESSION_INFO_502 {
	LPTSTR sesi502_cname;
	LPTSTR sesi502_uname;
	DWORD  sesi502_nopens;
	DWORD  sesi502_time;
	DWORD  sesi502_itime;
	DWORD  sesi502_uflags;
	LPTSTR sesi502_cltype_name;
	LPTSTR sesi502_transport;
};
INFONRES_RESULT(mslm_SESSION_INFO, 502)

INFONRES_DEFINITION(mslm_NetSessionEnum,
	INFONRES_UNION_ENTRY(mslm_SESSION_INFO, 0)
	INFONRES_UNION_ENTRY(mslm_SESSION_INFO, 1)
	INFONRES_UNION_ENTRY(mslm_SESSION_INFO, 2)
	INFONRES_UNION_ENTRY(mslm_SESSION_INFO, 10)
	INFONRES_UNION_ENTRY(mslm_SESSION_INFO, 502))

OPERATION(SRVSVC_OPNUM_NetSessionEnum)
struct mslm_NetSessionEnum {
	IN		LPTSTR servername;
	IN		DWORD unc_clientname; 
	IN		DWORD username;
	INOUT	DWORD level;
	INOUT	struct mslm_NetSessionEnum_result result;
	IN		DWORD pref_max_len;
	OUT		DWORD total_entries;
	INOUT	DWORD *resume_handle;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * NetSessionDel (Platform SDK: Network Management)
 *
 * The NetSessionDel function ends a network session between a server
 * and a workstation.
 *
 * Security Requirements
 * Only members of the Administrators or Account Operators local group
 * can successfully execute the NetSessionDel function.
 *
 * Windows NT/2000/XP: The parameter order is as follows.
 *
 * NET_API_STATUS NetSessionDel(LPWSTR servername,
 *                              LPWSTR UncClientName,
 *                              LPWSTR username);
 *
 * Windows 95/98/Me: The sReserved parameter replaces the username
 * parameter. For more information, see the following Remarks section.
 * The parameter list is as follows.
 *
 * API_FUNCTION NetSessionDel(const char FAR *pszServer,
 *                            const char FAR *pszClientName,
 *                            short  sReserved);
 *
 * Parameters
 * 
 * servername
 * [in] Pointer to a string that specifies the DNS or NetBIOS name
 * of the server.  Servers should not validate this parameter.
 * This parameter may be NULL and on Windows NT 4.0 and earlier it
 * should begin with \\.
 *
 * UncClientName
 * [in] Pointer to a string that specifies the name of the client
 * to disconnect. If UncClientName is NULL, all sessions associated
 * with the specified user will be disconnected.
 *
 * username
 * [in] Pointer to a string that specifies the name of the user whose
 * session is to be terminated. If username is NULL, all sessions
 * from the specified client will be disconnected.
 *
 * Remarks
 * Windows 95/98/Me: You must specify the session key in the sReserved
 * parameter when you call NetSessionDel. The session key is returned by
 * the NetSessionEnum function or the NetSessionGetInfo function in the
 * sesi50_key member of the session_info_50 structure.
 ***********************************************************************
 */

OPERATION(SRVSVC_OPNUM_NetSessionDel)
struct mslm_NetSessionDel {
	IN	LPTSTR servername;
	IN	LPTSTR unc_clientname;
	IN	LPTSTR username;
	OUT	DWORD status;
};


/*
 * SRVSVC NetServerGetInfo (
 *	IN LPTSTR	servername,
 *	IN DWORD	level,
 *	OUT union switch(level) {
 *		case 100: _SERVER_INFO_100 *	p100;
 *		case 101: _SERVER_INFO_101 *	p101;
 *		case 102: _SERVER_INFO_102 *	p102;
 *	    }		bufptr,
 *	OUT DWORD	status
 *      )
 */

/* for svX_platform */
#define	SV_PLATFORM_ID_DOS		300
#define	SV_PLATFORM_ID_OS2		400
#define	SV_PLATFORM_ID_NT		500
#define	SV_PLATFORM_ID_OSF		600
#define	SV_PLATFORM_ID_VMS		700

/* Bit-mapped values for svX_type fields */
#define SV_TYPE_WORKSTATION         0x00000001
#define SV_TYPE_SERVER              0x00000002
#define SV_TYPE_SQLSERVER           0x00000004
#define SV_TYPE_DOMAIN_CTRL         0x00000008
#define SV_TYPE_DOMAIN_BAKCTRL      0x00000010
#define SV_TYPE_TIME_SOURCE         0x00000020
#define SV_TYPE_AFP                 0x00000040
#define SV_TYPE_NOVELL              0x00000080
#define SV_TYPE_DOMAIN_MEMBER       0x00000100
#define SV_TYPE_PRINTQ_SERVER       0x00000200
#define SV_TYPE_DIALIN_SERVER       0x00000400
#define SV_TYPE_XENIX_SERVER        0x00000800
#define SV_TYPE_SERVER_UNIX         SV_TYPE_XENIX_SERVER
#define SV_TYPE_NT                  0x00001000	/* NT Workstation */
#define SV_TYPE_WFW                 0x00002000	/* Windows for Workgroups */

#define SV_TYPE_SERVER_MFPN         0x00004000
#define SV_TYPE_SERVER_NT           0x00008000	/* NT Server */
#define SV_TYPE_POTENTIAL_BROWSER   0x00010000
#define SV_TYPE_BACKUP_BROWSER      0x00020000
#define SV_TYPE_MASTER_BROWSER      0x00040000
#define SV_TYPE_DOMAIN_MASTER       0x00080000
#define SV_TYPE_SERVER_OSF          0x00100000
#define SV_TYPE_SERVER_VMS          0x00200000
#define SV_TYPE_WINDOWS             0x00400000  /* Windows95 and above */
#define SV_TYPE_ALTERNATE_XPORT     0x20000000  /* Return alt transport list */
#define SV_TYPE_LOCAL_LIST_ONLY     0x40000000  /* Return local list only */
#define SV_TYPE_DOMAIN_ENUM         0x80000000
#define SV_TYPE_ALL                 0xFFFFFFFF  /* handy for NetServerEnum2 */

#define SV_TYPE_DEFAULT (SV_TYPE_WORKSTATION | SV_TYPE_SERVER | SV_TYPE_NT | \
    SV_TYPE_SERVER_NT)

/* Special value for sv102_disc that specifies infinite disconnect time */
#define SV_NODISC           (-1L)  /* No autodisconnect timeout enforced */

/* Values of svX_security field */
#define SV_USERSECURITY     1
#define SV_SHARESECURITY    0

/* Values of svX_hidden field */
#define SV_HIDDEN       1
#define SV_VISIBLE      0


struct mslm_SERVER_INFO_100 {
	DWORD		sv100_platform_id;
	LPTSTR		sv100_name;
};

struct mslm_SERVER_INFO_101 {
	DWORD		sv101_platform_id;
	LPTSTR		sv101_name;
	DWORD		sv101_version_major;
	DWORD		sv101_version_minor;
	DWORD		sv101_type;
	LPTSTR		sv101_comment;
};

struct mslm_SERVER_INFO_102 {
	DWORD		sv102_platform_id;
	LPTSTR		sv102_name;
	DWORD		sv102_version_major;
	DWORD		sv102_version_minor;
	DWORD		sv102_type;
	LPTSTR		sv102_comment;
	DWORD		sv102_users;
	DWORD		sv102_disc;
	DWORD		sv102_hidden;		/* BOOL */
	DWORD		sv102_announce;
	DWORD		sv102_anndelta;
	DWORD		sv102_licenses;
	LPTSTR		sv102_userpath;
};

struct mslm_SERVER_INFO_502 {
	DWORD sv502_sessopens;
	DWORD sv502_sessvcs;
	DWORD sv502_opensearch;
	DWORD sv502_sizreqbuf;
	DWORD sv502_initworkitems;
	DWORD sv502_maxworkitems;
	DWORD sv502_rawworkitems;
	DWORD sv502_irpstacksize;
	DWORD sv502_maxrawbuflen;
	DWORD sv502_sessusers;
	DWORD sv502_sessconns;
	DWORD sv502_maxpagedmemoryusage;
	DWORD sv502_maxnonpagedmemoryusage;
	DWORD sv502_enablesoftcompat;
	DWORD sv502_enableforcedlogoff;
	DWORD sv502_timesource;
	DWORD sv502_acceptdownlevelapis;
	DWORD sv502_lmannounce;
};

struct mslm_SERVER_INFO_503 {
	DWORD sv503_sessopens;
	DWORD sv503_sessvcs;
	DWORD sv503_opensearch;
	DWORD sv503_sizreqbuf;
	DWORD sv503_initworkitems;
	DWORD sv503_maxworkitems;
	DWORD sv503_rawworkitems;
	DWORD sv503_irpstacksize;
	DWORD sv503_maxrawbuflen;
	DWORD sv503_sessusers;
	DWORD sv503_sessconns;
	DWORD sv503_maxpagedmemoryusage;
	DWORD sv503_maxnonpagedmemoryusage;
	DWORD sv503_enablesoftcompat;
	DWORD sv503_enableforcedlogoff;
	DWORD sv503_timesource;
	DWORD sv503_acceptdownlevelapis;
	DWORD sv503_lmannounce;
	LPTSTR sv503_domain;
	DWORD sv503_maxcopyreadlen;
	DWORD sv503_maxcopywritelen;
	DWORD sv503_minkeepsearch;
	DWORD sv503_maxkeepsearch;
	DWORD sv503_minkeepcomplsearch;
	DWORD sv503_maxkeepcomplsearch;
	DWORD sv503_threadcountadd;
	DWORD sv503_numblockthreads;
	DWORD sv503_scavtimeout;
	DWORD sv503_minrcvqueue;
	DWORD sv503_minfreeworkitems;
	DWORD sv503_xactmemsize;
	DWORD sv503_threadpriority;
	DWORD sv503_maxmpxct;
	DWORD sv503_oplockbreakwait;
	DWORD sv503_oplockbreakresponsewait;
	DWORD sv503_enableoplocks;
	DWORD sv503_enableoplockforceclose;
	DWORD sv503_enablefcbopens;
	DWORD sv503_enableraw;
	DWORD sv503_enablesharednetdrives;
	DWORD sv503_minfreeconnections;
	DWORD sv503_maxfreeconnections;
};

union mslm_NetServerGetInfo_ru {
	CASE(100)	struct mslm_SERVER_INFO_100 *bufptr100;
	CASE(101)	struct mslm_SERVER_INFO_101 *bufptr101;
	CASE(102)	struct mslm_SERVER_INFO_102 *bufptr102;
	CASE(502)	struct mslm_SERVER_INFO_502 *bufptr502;
	CASE(503)	struct mslm_SERVER_INFO_503 *bufptr503;
	DEFAULT		char *nullptr;
};

struct mslm_NetServerGetInfo_result {
	DWORD level;
  SWITCH(level)
	union mslm_NetServerGetInfo_ru bufptr;
};


OPERATION(SRVSVC_OPNUM_NetServerGetInfo)
struct mslm_NetServerGetInfo {
	IN  LPTSTR	servername;
	IN  DWORD	level;
	OUT struct mslm_NetServerGetInfo_result result;
	OUT DWORD	status;
};

/*
 * SRVSVC NetRemoteTOD (
 *	IN LPTSTR	servername,
 *	OUT _TIME_OF_DAY_INFO *bufptr,
 *	OUT long	status
 *      )
 */

struct mslm_TIME_OF_DAY_INFO {
	DWORD		tod_elapsedt;
	DWORD		tod_msecs;
	DWORD		tod_hours;
	DWORD		tod_mins;
	DWORD		tod_secs;
	DWORD		tod_hunds;
	DWORD		tod_timezone;
	DWORD		tod_tinterval;
	DWORD		tod_day;
	DWORD		tod_month;
	DWORD		tod_year;
	DWORD		tod_weekday;
};

OPERATION(SRVSVC_OPNUM_NetRemoteTOD)
struct mslm_NetRemoteTOD {
	IN  LPTSTR	servername;
	OUT struct mslm_TIME_OF_DAY_INFO *bufptr;
	OUT DWORD	status;
};

#define	NAMEFLAG_LM2		0x80000000

#define	NAMETYPE_USER		1
#define	NAMETYPE_PASSWORD	2
#define	NAMETYPE_GROUP		3
#define	NAMETYPE_COMPUTER	4
#define	NAMETYPE_EVENT		5
#define	NAMETYPE_DOMAIN		6
#define	NAMETYPE_SERVICE	7
#define	NAMETYPE_NET		8
#define	NAMETYPE_SHARE		9
#define	NAMETYPE_MESSAGE	10
#define	NAMETYPE_MESSAGEDEST	11
#define	NAMETYPE_SHAREPASSWORD	12
#define	NAMETYPE_WORKGROUP	13

OPERATION(SRVSVC_OPNUM_NetNameValidate)
struct mslm_NetNameValidate {
 	IN  LPTSTR		servername;
 	IN  REFERENCE LPTSTR 	pathname;
	IN  DWORD		type;
	IN  DWORD		flags;
	OUT DWORD		status;
};

/*
 * SRVSVC NetShareEnum (
 *	IN  LPTSTR	servername,
 *	IN  DWORD	level;
 *	OUT union switch(level) {
 *		case 0: struct {
 *				DWORD entriesread;
 *			     [size_is(entriesread)]
 *				_SHARE_INFO_0 *entries;
 *			} *bufptr0;
 *		case 1: struct {
 *				DWORD entriesread;
 *			     [size_is(entriesread)]
 *				_SHARE_INFO_1 *entries;
 *			} *bufptr1;
 *		...
 *	    }		bufptr,
 *	IN  DWORD	prefmaxlen,
 *	OUT DWORD	totalentries,
 *	IN OUT DWORD ?*	resume_handle,
 *	OUT DWORD	status
 *      )
 */

/*
 * Share types for shiX_type fields - duplicated from smb.h
 */
#ifndef _SHARE_TYPES_DEFINED_
#define _SHARE_TYPES_DEFINED_
#define STYPE_DISKTREE          0x00000000
#define STYPE_PRINTQ            0x00000001
#define STYPE_DEVICE            0x00000002
#define STYPE_IPC               0x00000003
#define STYPE_MASK              0x0000000F
#define STYPE_DFS               0x00000064
#define STYPE_HIDDEN            0x80000000
#define STYPE_SPECIAL           0x80000000
#endif /* _SHARE_TYPES_DEFINED_ */

/* Maximum uses for shiX_max_uses fields */
#define SHI_USES_UNLIMITED      (DWORD)-1

INFONRES_RESULT(mslm_NetShareInfo,0)
INFONRES_RESULT(mslm_NetShareInfo,1)
INFONRES_RESULT(mslm_NetShareInfo,2)
INFONRES_RESULT(mslm_NetShareInfo,501)
INFONRES_RESULT(mslm_NetShareInfo,502)

union mslm_NetShareAddInfo_u {
	CASE(2)     struct mslm_NetShareInfo_2 *info2;
	CASE(502)   struct mslm_NetShareInfo_502 *info502;
	DEFAULT	char *nullptr;
};

struct mslm_NetShareAddInfo {
	DWORD switch_value;
  SWITCH(switch_value)
	union mslm_NetShareAddInfo_u un;
};


OPERATION(SRVSVC_OPNUM_NetShareAdd)
struct mslm_NetShareAdd {
	IN	LPTSTR servername;
	IN	DWORD level;
	IN	struct mslm_NetShareAddInfo info;
	INOUT	DWORD *parm_err;
	OUT	DWORD status;
};


INFONRES_DEFINITION(mslm_NetShareEnum,
	INFONRES_UNION_ENTRY(mslm_NetShareInfo,0)
	INFONRES_UNION_ENTRY(mslm_NetShareInfo,1)
	INFONRES_UNION_ENTRY(mslm_NetShareInfo,2)
	INFONRES_UNION_ENTRY(mslm_NetShareInfo,501)
	INFONRES_UNION_ENTRY(mslm_NetShareInfo,502))

/*
 * NetShareEnum: enumerate all shares (see also NetShareEnumSticky).
 * Note: the server should ignore the content of servername.
 */
OPERATION(SRVSVC_OPNUM_NetShareEnum)
struct mslm_NetShareEnum {
	IN  		LPTSTR	servername;
	INOUT  		DWORD	level;
	INOUT 		struct mslm_NetShareEnum_result result;
	IN  		DWORD	prefmaxlen;
	OUT 		DWORD	totalentries;
	INOUT 		DWORD	*resume_handle;
	OUT 		DWORD	status;
};

/*
 * Delete a share. The reserved field appears in netmon
 * but I've left it out in case it's not always present.
 * This won't affect RPC processing.
 */
OPERATION(SRVSVC_OPNUM_NetShareDel)
struct mslm_NetShareDel {
	IN	LPTSTR servername;
	IN REFERENCE	LPTSTR netname;
	/* IN	DWORD reserved; */
	OUT	DWORD status;
};

OPERATION(SRVSVC_OPNUM_NetShareCheck)
struct mslm_NetShareCheck {
	IN	LPTSTR servername;
	IN REFERENCE	LPTSTR path;
	OUT	DWORD stype;
	OUT	DWORD status;
};

/*
 * NetShareEnumSticky is the same as NetShareEnum except that
 * STYPE_SPECIAL (hidden or special) shares are not returned.
 * Note: the server should ignore the content of servername.
 */
OPERATION(SRVSVC_OPNUM_NetShareEnumSticky)
struct mslm_NetShareEnumSticky {
	IN  		LPTSTR	servername;
	INOUT  		DWORD	level;
	INOUT 		struct mslm_NetShareEnum_result result;
	IN  		DWORD	prefmaxlen;
	OUT 		DWORD	totalentries;
	INOUT 		DWORD	*resume_handle;
	OUT 		DWORD	status;
};

/*
 * When you install Windows NT Server Tools on a Win95 client,
 * a security tab will be added to properties dialog box of files/folders.
 * Within this security tab, when you try to get/set permissions on a
 * file/folder the next two RPC calls are used.
 */
OPERATION(SRVSVC_OPNUM_NetGetFileSecurity)
struct mslm_NetGetFileSecurity {
	IN  		LPTSTR	servername;
	IN			LPTSTR	sharename;
	IN REFERENCE LPTSTR	filename;
	IN			DWORD	securityinfo;	
	
	/*
	 * Right now, we can't send back SD of the requested object
	 * in RPC code, so we just reply with access denied error
	 * code. Thus, this output declaration is only valid in this
	 * case i.e., it's not complete.
	 * It looks like:
	 *
	 *   A Pointer
	 *   A Length
	 *   
	 *   A Pointer
	 *   A Length (equal to the prev length)
	 *   A buffer
	 *
	 *   return value
	 */
	OUT			DWORD	length;
	OUT 		DWORD	status;
};

/*
 * This is the request:
 *
 * R_SRVSVC: RPC Client call srvsvc:NetrpSetFileSecurity(..)
 *	 R_SRVSVC: SRVSVC_HANDLE ServerName = \\WK76-177
 *	 R_SRVSVC: LPWSTR ShareName = AFSHIN
 *	 R_SRVSVC: LPWSTR lpFileName = \salek.txt
 *	 R_SRVSVC: SECURITY_INFORMATION SecurityInformation = 4 (0x4)
 *  -R_SRVSVC: PADT_SECURITY_DESCRIPTOR SecurityDescriptor {..}
 *  R_SRVSVC: DWORD Length = 64 (0x40)
 *  R_SRVSVC: LPBYTE Buffer = 4496048 (0x449AB0)
 *  R_SRVSVC: LPBYTE Buffer [..] = 01 00 04 80 00 00 00 00 00 00 00 00 00 00 00
 *  ...
 *
 *  000000A0        00 83 46 00 0B 00 00 00 00 00 00 00 0B 00   ..F...........
 *  000000B0  00 00 5C 00 5C 00 57 00 4B 00 37 00 36 00 2D 00 ..\.\.W.K.7.6.-.
 *  000000C0  31 00 37 00 37 00 00 00 08 00 16 83 46 00 07 00 1.7.7.......F...
 *  000000D0  00 00 00 00 00 00 07 00 00 00 41 00 46 00 53 00 ..........A.F.S.
 *  000000E0  48 00 49 00 4E 00 00 00 00 00 0B 00 00 00 00 00 H.I.N...........
 *  000000F0  00 00 0B 00 00 00 5C 00 73 00 61 00 6C 00 65 00 ......\.s.a.l.e.
 *  00000100  6B 00 2E 00 74 00 78 00 74 00 00 00 00 00 04 00 k...t.x.t.......
 *  00000110  00 00 40 00 00 00 B0 9A 44 00 40 00 00 00 01 00 ..@.....D.@.....
 *  00000120  04 80 00 00 00 00 00 00 00 00 00 00 00 00 14 00 ................
 *  00000130  00 00 02 00 2C 00 01 00 00 00 00 00 24 00 00 00 ....,.......$...
 *  00000140  00 A0 01 05 00 00 00 00 00 05 15 00 00 00 1A 24 ...............$
 *  00000150  44 38 90 00 0F 02 65 3A BE 4C FF 03 00 00 00 00 D8....e:.L......
 *  00000160  00 00 00 00 00 00 00 00 00 00                   ..........      
 */
OPERATION(SRVSVC_OPNUM_NetSetFileSecurity)
struct mslm_NetSetFileSecurity {
	IN  		LPTSTR	servername;
	IN			LPTSTR	sharename;
	IN REFERENCE LPTSTR	filename;
	IN			DWORD	securityinfo;	
	/*
	 * IN Security Descriptor (looks like):
	 * Length1
	 * Pointer
	 * Length2 (== Length1)
	 * buffer itself
	 */

	OUT 		DWORD	status;
};

/*
 * The SRVSVC already
 */
INTERFACE(0)
union srvsvc_interface {
    CASE(SRVSVC_OPNUM_NetConnectEnum)
	struct mslm_NetConnectEnum	NetConnectEnum;
    CASE(SRVSVC_OPNUM_NetFileEnum)
	struct mslm_NetFileEnum		NetFileEnum;
    CASE(SRVSVC_OPNUM_NetFileClose)
	struct mslm_NetFileClose	NetFileClose;
    CASE(SRVSVC_OPNUM_NetShareGetInfo)
	struct mlsm_NetShareGetInfo	NetShareGetInfo;
    CASE(SRVSVC_OPNUM_NetShareSetInfo)
	struct mlsm_NetShareSetInfo	NetShareSetInfo;
    CASE(SRVSVC_OPNUM_NetSessionDel)
	struct mslm_NetSessionDel	NetSessionDel;
    CASE(SRVSVC_OPNUM_NetSessionEnum)
	struct mslm_NetSessionEnum	NetSessionEnum;
    CASE(SRVSVC_OPNUM_NetServerGetInfo)
	struct mslm_NetServerGetInfo	NetServerGetInfo;
    CASE(SRVSVC_OPNUM_NetRemoteTOD)
	struct mslm_NetRemoteTOD	NetRemoteTOD;
    CASE(SRVSVC_OPNUM_NetNameValidate)
	struct mslm_NetNameValidate	NetNameValidate;
    CASE(SRVSVC_OPNUM_NetShareAdd)
	struct mslm_NetShareAdd		NetShareAdd;
    CASE(SRVSVC_OPNUM_NetShareDel)
	struct mslm_NetShareDel		NetShareDel;
    CASE(SRVSVC_OPNUM_NetShareCheck)
	struct mslm_NetShareCheck	NetShareCheck;
    CASE(SRVSVC_OPNUM_NetShareEnum)
	struct mslm_NetShareEnum	NetShareEnum;
    CASE(SRVSVC_OPNUM_NetShareEnumSticky)
	struct mslm_NetShareEnumSticky	NetShareEnumSticky;
    CASE(SRVSVC_OPNUM_NetGetFileSecurity)
	struct mslm_NetGetFileSecurity	NetGetFileSecurity;
    CASE(SRVSVC_OPNUM_NetSetFileSecurity)
	struct mslm_NetSetFileSecurity	NetSetFileSecurity;
};
typedef union srvsvc_interface	srvsvc_interface_t;
EXTERNTYPEINFO(srvsvc_interface)



/*
 * WKSSVC - Workstation Service
 */

/* Windows NT */
#define WKSSVC_OPNUM_NetWkstaGetInfo		0x00
#define WKSSVC_OPNUM_NetWkstaSetInfo		0x01
#define WKSSVC_OPNUM_NetWkstaUserEnum		0x02
#define WKSSVC_OPNUM_NetWkstaUserGetInfo	0x03
#define WKSSVC_OPNUM_NetWkstaUserSetInfo	0x04
#define WKSSVC_OPNUM_NetWkstaTransportEnum	0x05
#define WKSSVC_OPNUM_NetWkstaTransportAdd	0x06
#define WKSSVC_OPNUM_NetWkstaTransportDel	0x07
#define WKSSVC_OPNUM_NetUseAdd			0x08
#define WKSSVC_OPNUM_NetUseGetInfo		0x09
#define WKSSVC_OPNUM_NetUseDel			0x0a
#define WKSSVC_OPNUM_NetUseEnum			0x0b
#define WKSSVC_OPNUM_NetMessageBufferSend	0x0c
#define WKSSVC_OPNUM_NetWkstaStatisticsGet	0x0d
#define WKSSVC_OPNUM_NetLogonDomainNameAdd	0x0e

/* Windows 2000 */
#define WKSSVC_OPNUM_NetLogonDomainNameDel	0x0f
#define WKSSVC_OPNUM_NetJoinDomain		0x10
#define WKSSVC_OPNUM_NetUnjoinDomain		0x11
#define WKSSVC_OPNUM_NetValidateName		0x12
#define WKSSVC_OPNUM_NetRenameMachineInDomain	0x13
#define WKSSVC_OPNUM_NetGetJoinInformation	0x14
#define WKSSVC_OPNUM_NetGetJoinableOUs		0x15
#define WKSSVC_OPNUM_NetJoinDomain2		0x16
#define WKSSVC_OPNUM_NetUnjoinDomain2		0x17
#define WKSSVC_OPNUM_NetRenameMachineInDomain2	0x18
#define WKSSVC_OPNUM_NetValidateName2		0x19
#define WKSSVC_OPNUM_NetGetJoinableOUs2		0x1a

/* Windows XP and Windows Server 2003 */
#define WKSSVC_OPNUM_NetAddAlternateComputerName	0x1b
#define WKSSVC_OPNUM_NetRemoveAlternateComputerName	0x1c
#define WKSSVC_OPNUM_NetSetPrimaryComputerName		0x1d
#define WKSSVC_OPNUM_NetEnumerateComputerNames		0x1e
#define WKSSVC_OPNUM_NetWorkstationResetDfsCache	0x1f


struct mslm_WKSTA_INFO_100 {
    DWORD   wki100_platform_id;
    LPTSTR  wki100_computername;
    LPTSTR  wki100_langroup;
    DWORD   wki100_ver_major;
    DWORD   wki100_ver_minor;
};

/* NetWkstaGetInfo only.  System information - user access */
struct mslm_WKSTA_INFO_101 {
    DWORD   wki101_platform_id;
    LPTSTR  wki101_computername;
    LPTSTR  wki101_langroup;
    DWORD   wki101_ver_major;
    DWORD   wki101_ver_minor;
    LPTSTR  wki101_lanroot;
};

/* NetWkstaGetInfo only.  System information - admin or operator access */
struct mslm_WKSTA_INFO_102 {
    DWORD   wki102_platform_id;
    LPTSTR  wki102_computername;
    LPTSTR  wki102_langroup;
    DWORD   wki102_ver_major;
    DWORD   wki102_ver_minor;
    LPTSTR  wki102_lanroot;
    DWORD   wki102_logged_on_users;
};

struct mslm_WKSTA_INFO_502 {
	DWORD char_wait;
	DWORD collection_time;
	DWORD maximum_collection_count;
	DWORD keep_connection;
	DWORD max_commands;
	DWORD session_timeout;
	DWORD size_char_buf;
	DWORD max_threads;
	DWORD lock_quota;
	DWORD lock_increment;
	DWORD lock_maximum;
	DWORD pipe_increment;
	DWORD pipe_maximum;
	DWORD cache_file_timeout;
	DWORD dormant_file_limit;
	DWORD read_ahead_throughput;
	DWORD num_mailslot_buffers;
	DWORD num_srv_announce_buffers;
	DWORD max_illegal_dgram_events;
	DWORD dgram_event_reset_freq;
	DWORD log_election_packets;
	DWORD use_opportunistic_locking;
	DWORD use_unlock_behind;
	DWORD use_close_behind;
	DWORD buf_named_pipes;
	DWORD use_lock_read_unlock;
	DWORD utilize_nt_caching;
	DWORD use_raw_read;
	DWORD use_raw_write;
	DWORD use_write_raw_data;
	DWORD use_encryption;
	DWORD buf_files_deny_write;
	DWORD buf_read_only_files;
	DWORD force_core_create_mode;
	DWORD use_512_byte_max_transfer;
};

INFO1RES_DEFINITION(mslm_NetWkstaGetInfo,
	INFO1RES_UNION_ENTRY(mslm_WKSTA_INFO,100)
	INFO1RES_UNION_ENTRY(mslm_WKSTA_INFO,101)
	INFO1RES_UNION_ENTRY(mslm_WKSTA_INFO,102)
	INFO1RES_UNION_ENTRY(mslm_WKSTA_INFO,502))

INFO1RESBUF_DEFINITION(mslm_NetWkstaGetInfo,
	INFO1RESBUF_UNION_ENTRY(mslm_WKSTA_INFO,100)
	INFO1RESBUF_UNION_ENTRY(mslm_WKSTA_INFO,101)
	INFO1RESBUF_UNION_ENTRY(mslm_WKSTA_INFO,102)
	INFO1RESBUF_UNION_ENTRY(mslm_WKSTA_INFO,502))


OPERATION(WKSSVC_OPNUM_NetWkstaGetInfo)
struct mslm_NetWkstaGetInfo {
	IN  LPTSTR	servername;
	IN  DWORD	level;
	OUT struct mslm_NetWkstaGetInfo_result result;
	OUT DWORD	status;
};

/*
 ***********************************************************************
 * NetWkstaTransportEnum
 ***********************************************************************
 */

struct mslm_NetWkstaTransportInfo0 {
	DWORD quality_of_service;
	DWORD num_vcs;
	LPTSTR transport_name;
	LPTSTR transport_address;
	DWORD wan_ish;
};

struct mslm_NetWkstaTransportCtr0 {
	DWORD count;
    SIZE_IS(count)
	struct mslm_NetWkstaTransportInfo0 *ti0;
};

union mslm_NetWkstaTransportInfo_ru {
	CASE(0) struct mslm_NetWkstaTransportCtr0 *info0;
	DEFAULT char *nullptr;
};

struct mslm_NetWkstaTransportInfo {
	DWORD address;
	DWORD level;
    SWITCH(level)
	union mslm_NetWkstaTransportInfo_ru ru;
};

OPERATION(WKSSVC_OPNUM_NetWkstaTransportEnum)
struct mslm_NetWkstaTransportEnum {
	IN 	LPTSTR	servername;
	INOUT	struct mslm_NetWkstaTransportInfo info;
	IN	DWORD	pref_max_len;
	OUT 	DWORD	total_entries;
	INOUT	DWORD	*resume_handle;
	OUT	DWORD	status;
};

/*
 * The WKSSVC already
 */
INTERFACE(0)
union wkssvc_interface {
    CASE(WKSSVC_OPNUM_NetWkstaGetInfo)
	struct mslm_NetWkstaGetInfo		NetWkstaGetInfo;
    CASE(WKSSVC_OPNUM_NetWkstaTransportEnum)
	struct mslm_NetWkstaTransportEnum	NetWkstaTransportEnum;
};
typedef union wkssvc_interface	wkssvc_interface_t;
EXTERNTYPEINFO(wkssvc_interface)


#endif /* _MLSVC_LANMAN_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_SVCCTL_NDL_
#define _MLSVC_SVCCTL_NDL_

/*
 * NT Service Control Services (SVCCTL) RPC interface definition.
 * This interface provides remote access to add, remove, start and
 * stop services.
 */

#include <libmlrpc/ndrtypes.ndl>

/* Windows NT */
#define SVCCTL_OPNUM_Close			0x00
#define	SVCCTL_OPNUM_ControlService		0x01
#define	SVCCTL_OPNUM_DeleteService		0x02
#define	SVCCTL_OPNUM_LockServiceDatabase	0x03
#define	SVCCTL_OPNUM_QueryServiceSecurity	0x04
#define	SVCCTL_OPNUM_SetServiceSecurity		0x05
#define SVCCTL_OPNUM_QueryServiceStatus		0x06
#define	SVCCTL_OPNUM_SetServiceStatus		0x07
#define	SVCCTL_OPNUM_UnlockServiceDatabase	0x08
#define	SVCCTL_OPNUM_NotifyBootConfigStatus	0x09
#define	SVCCTL_OPNUM_SetServiceBits		0x0a
#define	SVCCTL_OPNUM_ChangeServiceConfig	0x0b
#define	SVCCTL_OPNUM_CreateService		0x0c
#define	SVCCTL_OPNUM_EnumDependentServices	0x0d
#define SVCCTL_OPNUM_EnumServicesStatus		0x0E
#define SVCCTL_OPNUM_OpenManager		0x0F
#define SVCCTL_OPNUM_OpenService		0x10
#define SVCCTL_OPNUM_QueryServiceConfig		0x11
#define	SVCCTL_OPNUM_QueryServiceLockStatus	0x12
#define	SVCCTL_OPNUM_StartService		0x13
#define	SVCCTL_OPNUM_GetServiceDisplayNameW	0x14
#define	SVCCTL_OPNUM_GetServiceKeyNameW		0x15
#define	SVCCTL_OPNUM_SetServiceBitsA		0x16
#define	SVCCTL_OPNUM_ChangeServiceConfigA	0x17
#define	SVCCTL_OPNUM_CreateServiceA		0x18
#define	SVCCTL_OPNUM_EnumDependentServicesA	0x19
#define	SVCCTL_OPNUM_EnumServicesStatusA	0x1a
#define	SVCCTL_OPNUM_OpenSCManagerA		0x1b
#define	SVCCTL_OPNUM_OpenServiceA		0x1c
#define	SVCCTL_OPNUM_QueryServiceConfigA	0x1d
#define	SVCCTL_OPNUM_QueryServiceLockStatusA	0x1e
#define	SVCCTL_OPNUM_StartServiceA		0x1f
#define	SVCCTL_OPNUM_GetServiceDisplayNameA	0x20
#define	SVCCTL_OPNUM_GetServiceKeyNameA		0x21
#define	SVCCTL_OPNUM_GetCurrentGroupStateW	0x22
#define	SVCCTL_OPNUM_EnumServiceGroupW		0x23
#define	SVCCTL_OPNUM_ChangeServiceConfig2A	0x24
#define	SVCCTL_OPNUM_ChangeServiceConfig2W	0x25
#define	SVCCTL_OPNUM_QueryServiceConfig2A	0x26

/* Windows 2000 */
#define	SVCCTL_OPNUM_QueryServiceConfig2W	0x27
#define	SVCCTL_OPNUM_QueryServiceStatusEx	0x28
#define	SVCCTL_OPNUM_EnumServicesStatusExA	0x29
#define	SVCCTL_OPNUM_EnumServicesStatusExW	0x2a

/* Windows XP and Windows Server 2003 */
#define	SVCCTL_OPNUM_SendTSMessage		0x2b

/* Windows Vista */
#define	SVCCTL_OPNUM_CreateServiceWOW64A	0x2c
#define	SVCCTL_OPNUM_CreateServiceWOW64W	0x2d
#define	SVCCTL_OPNUM_QueryServiceTagInfo	0x2e
#define	SVCCTL_OPNUM_NotifyServiceStatusChange	0x2f
#define	SVCCTL_OPNUM_GetNotifyResult		0x30
#define	SVCCTL_OPNUM_CloseNotifyHandle		0x31
#define	SVCCTL_OPNUM_ControlServiceExA		0x32
#define	SVCCTL_OPNUM_ControlServiceExW		0x33
#define	SVCCTL_OPNUM_SendPnPMessage		0x34
#define	SVCCTL_OPNUM_ValidatePnPService		0x35
#define	SVCCTL_OPNUM_OpenServiceStatusHandle	0x36

CONTEXT_HANDLE(svcctl_handle) svcctl_handle_t;

/*
 * String definition for the ASCII interface.
 */
struct svcctl_value {
	DWORD	vc_first_is;	/* 0 */
	DWORD	vc_length_is;
    SIZE_IS(vc_length_is)
	BYTE	value[ANY_SIZE_ARRAY];
};

/*
 * The svc_status (SERVICE_STATUS) structure contains information about a
 * service. The ControlService, EnumDependentServices, EnumServicesStatus,
 * and QueryServiceStatus functions use this structure to return information
 * about a service. A service uses this structure in the SetServiceStatus
 * function to report its current status to the service control manager.
 *
 * service_type
 *	The type of service. This member can be one of the following values.
 *
 *      SERVICE_FILE_SYSTEM_DRIVER
 *      SERVICE_KERNEL_DRIVER
 *      SERVICE_WIN32_OWN_PROCESS
 *      SERVICE_WIN32_SHARE_PROCESS
 *
 * If the service type is either SERVICE_WIN32_OWN_PROCESS or
 * SERVICE_WIN32_SHARE_PROCESS, and the service is running in
 * the context of the LocalSystem account, the following type
 * may also be specified to indicate that the service can
 * interact with the desktop.
 *
 *      SERVICE_INTERACTIVE_PROCESS
 *
 * cur_state
 *	The current state of the service. This member can be one of the
 *	following values.
 *
 *      SERVICE_CONTINUE_PENDING
 *      SERVICE_PAUSE_PENDING
 *      SERVICE_PAUSED
 *      SERVICE_RUNNING
 *      SERVICE_START_PENDING
 *      SERVICE_STOP_PENDING
 *      SERVICE_STOPPED
 *
 * ctrl_accepted
 *	The control codes that the service will accept and process in its
 *	handler function (see Handler and HandlerEx). A user interface
 *	process can control a service by specifying a control command in
 *	the ControlService function. By default, all services accept the
 *	SERVICE_CONTROL_INTERROGATE value. The following are the control
 *	codes.
 *
 *      SERVICE_ACCEPT_STOP        
 *      SERVICE_ACCEPT_PAUSE_CONTINUE
 *      SERVICE_ACCEPT_SHUTDOWN     
 *      SERVICE_ACCEPT_PARAMCHANGE 
 *      SERVICE_ACCEPT_NETBINDCHANGE
 *
 * w32_exitcode
 *  An error code that the service uses to report an error that occurs when
 *  it is starting or stopping. To return an error code specific to the
 *  service, the service must set this value to ERROR_SERVICE_SPECIFIC_ERROR
 *  to indicate that the dwServiceSpecificExitCode member contains the error
 *  code. The service should set this value to NO_ERROR when it is running
 *  and on normal termination. 
 *
 * svc_specified_exitcode
 *  A service-specific error code that the service returns when an error 
 *  occurs while the service is starting or stopping. This value is ignored 
 *  unless the w32_exitcode member is set to ERROR_SERVICE_SPECIFIC_ERROR. 
 *
 * check_point
 *  A value that the service increments periodically to report its progress 
 *  during a lengthy start, stop, pause, or continue operation. For example, 
 *  the service should increment this value as it completes each step of its 
 *  initialization when it is starting up. The user interface program that 
 *  invoked the operation on the service uses this value to track the progress 
 *  of the service during a lengthy operation. This value is not valid and 
 *  should be zero when the service does not have a start, stop, pause, or 
 *  continue operation pending. 
 *
 * wait_hint
 *  An estimate of the amount of time, in milliseconds, that the service
 *  expects a pending start, stop, pause, or continue operation to take
 *  before the service makes its next call to the SetServiceStatus
 *  function with either an incremented check_point value or a change in
 *  dwCurrentState. If the amount of time specified by wait_hint passes,
 *  and check_point has not been incremented, or cur_state has not changed,
 *  the service control manager or service control program can assume that
 *  an error has occurred and the service should be stopped. 
 */
struct svc_status {
	DWORD service_type;
	DWORD cur_state;
	DWORD ctrl_accepted;
	DWORD w32_exitcode;
	DWORD svc_specified_exitcode;
	DWORD check_point;
	DWORD wait_hint;
}; 
typedef struct svc_status svc_status_t;

struct svc_enum_status {
	DWORD svc_name;		/* offset within response buffer */
	DWORD display_name;	/* offset within response buffer */
	svc_status_t svc_status;
};
typedef struct svc_enum_status svc_enum_status_t;

struct svc_config { 
	DWORD  service_type; 
	DWORD  start_type; 
	DWORD  error_control; 
	LPTSTR binary_pathname; 
	LPTSTR loadorder_group; 
	DWORD  tag_id; 
	LPTSTR dependencies; 
	LPTSTR service_startname; 
	LPTSTR display_name; 
};
typedef struct svc_config svc_config_t;

struct svc_failure_actions {
	DWORD reset_period;
	DWORD rebootmsg_offset;
	DWORD command_offset;
	DWORD actions;
	DWORD actions_offset;
};
typedef struct svc_failure_actions svc_failure_actions_t;

struct svc_description {
	DWORD desc;		/* offset of description string */
};
typedef struct svc_description svc_description_t;

/* Boolean flag to control delayed start of service. Set 1=true, 0=false */
struct svc_delayed_auto_start {
	DWORD dstart;
};
typedef struct svc_delayed_auto_start svc_delayed_auto_start_t;

/* Boolean flag to control configured failure action. Set 1=true, 0=false */
struct svc_config_failure_action {
	DWORD cfa;
};
typedef struct svc_config_failure_action svc_config_failure_action_t;

/*
 ***********************************************************************
 * Close
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_Close)
struct svcctl_Close {
	IN		svcctl_handle_t handle;
	OUT		svcctl_handle_t result_handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * ControlService
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_ControlService)
struct svcctl_ControlService {
	IN		svcctl_handle_t service_handle;
	IN		DWORD control;
	OUT		svc_status_t service_status;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * DeleteService
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_DeleteService)
struct svcctl_DeleteService {
	IN		svcctl_handle_t service_handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * QueryServiceSecurity
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_QueryServiceSecurity)
struct svcctl_QueryServiceSecurity {
	IN		svcctl_handle_t service_handle;
	IN		DWORD security_info;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE buffer;
	OUT		DWORD bytes_needed;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * SetServiceSecurity
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_SetServiceSecurity)
struct svcctl_SetServiceSecurity {
	IN		svcctl_handle_t service_handle;
	IN		DWORD security_info;
    SIZE_IS(buf_size)
	IN REFERENCE	LPBYTE buffer;
	IN		DWORD buf_size;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * OpenManager
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_OpenManager)
struct svcctl_OpenManager {
	IN		LPTSTR machine_name;
	IN		LPTSTR database_name;
	IN		DWORD desired_access;
	OUT		svcctl_handle_t handle;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * OpenService
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_OpenService)
struct svcctl_OpenService {
	IN		svcctl_handle_t manager_handle;
	IN REFERENCE	LPTSTR service_name;
	IN		DWORD desired_access;
	OUT		svcctl_handle_t service_handle;
	OUT		DWORD status;
};


/*
 ***********************************************************************
 * QueryServiceStatus
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_QueryServiceStatus)
struct svcctl_QueryServiceStatus {
	IN		svcctl_handle_t service_handle;
	OUT		svc_status_t service_status;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * EnumDependentServices
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_EnumDependentServices)
struct svcctl_EnumDependentServices {
	IN		svcctl_handle_t service_handle;
	IN		DWORD svc_state;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE services;
	OUT		DWORD bytes_needed;
	OUT		DWORD svc_num;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * EnumServicesStatus
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_EnumServicesStatus)
struct svcctl_EnumServicesStatus {
	IN		svcctl_handle_t manager_handle;
	IN		DWORD svc_type;
	IN		DWORD svc_state;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE services;
	OUT		DWORD bytes_needed;
	OUT		DWORD svc_num;
	INOUT		DWORD *resume_handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * QueryServiceConfig	
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_QueryServiceConfig)
struct svcctl_QueryServiceConfig {
	IN		svcctl_handle_t service_handle;
	IN		DWORD buf_size;
	OUT		svc_config_t service_cfg;
	OUT		DWORD cfg_bytes;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * StartService
 *
 * argc:	The number of strings in argv.  If argv is NULL,
 *		argc may be 0.
 * argv:	A pointer to a buffer containing an array of
 *		null-terminated Unicode strings.
 *
 * For service management support, this should probably be:
 *	IN		DWORD argc;
 *    SIZE_IS(buf_size)
 *	IN REFERENCE	LPBYTE argv;
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_StartService)
struct svcctl_StartService {
	IN		svcctl_handle_t service_handle;
	IN		DWORD argc;
	IN		DWORD argv;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * GetServiceDisplayNameW       
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_GetServiceDisplayNameW)
struct svcctl_GetServiceDisplayNameW {
	IN		svcctl_handle_t manager_handle;
	IN REFERENCE	LPTSTR service_name;
	OUT REFERENCE	LPTSTR display_name;
	INOUT		DWORD buf_size;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * GetServiceKeyNameW   
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_GetServiceKeyNameW)
struct svcctl_GetServiceKeyNameW {
	IN		svcctl_handle_t manager_handle;
	IN REFERENCE	LPTSTR service_name;
	OUT REFERENCE	LPTSTR key_name;
	INOUT		DWORD buf_size;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * OpenSCManagerA
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_OpenSCManagerA)
struct svcctl_OpenSCManagerA {
	IN		struct svcctl_value *machine_name;
	IN		struct svcctl_value *database_name;
	IN		DWORD desired_access;
	OUT		svcctl_handle_t handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * OpenServiceA
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_OpenServiceA)
struct svcctl_OpenServiceA {
	IN		svcctl_handle_t manager_handle;
	IN REFERENCE	struct svcctl_value *service_name;
	IN		DWORD desired_access;
	OUT		svcctl_handle_t service_handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * EnumServicesStatusA
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_EnumServicesStatusA)
struct svcctl_EnumServicesStatusA {
	IN		svcctl_handle_t manager_handle;
	IN		DWORD svc_type;
	IN		DWORD svc_state;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE services;
	OUT		DWORD bytes_needed;
	OUT		DWORD svc_num;
	INOUT		DWORD *resume_handle;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * QueryServiceConfig2W  
 ***********************************************************************
 */
OPERATION(SVCCTL_OPNUM_QueryServiceConfig2W)
struct svcctl_QueryServiceConfig2W {
	IN		svcctl_handle_t service_handle;
	IN		DWORD info_level;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE buffer;
	OUT		DWORD bytes_needed;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * QueryServiceStatusEx  
 ***********************************************************************
 */
struct svc_status_ex {
	DWORD service_type;
	DWORD cur_state;
	DWORD ctrl_accepted;
	DWORD w32_exitcode;
	DWORD svc_specified_exitcode;
	DWORD check_point;
	DWORD wait_hint;
	DWORD process_id;
	DWORD service_flags;
}; 
typedef struct svc_status_ex svc_status_ex_t;

OPERATION(SVCCTL_OPNUM_QueryServiceStatusEx)
struct svcctl_QueryServiceStatusEx {
	IN		svcctl_handle_t service_handle;
	IN		DWORD info_level;
	IN		DWORD buf_size;
    SIZE_IS(buf_size)
	OUT REFERENCE	LPBYTE buffer;
	OUT		DWORD bytes_needed;
	OUT		DWORD status;
};

/*
 ***********************************************************************
 * The SVCCTL interface definition.
 ***********************************************************************
 */
INTERFACE(0)
union svcctl_interface {
	CASE(SVCCTL_OPNUM_Close)
		struct svcctl_Close			SvcClose;
	CASE(SVCCTL_OPNUM_ControlService)
		struct svcctl_ControlService		SvcControlService;
	CASE(SVCCTL_OPNUM_DeleteService)
		struct svcctl_DeleteService		SvcDeleteService;
	CASE(SVCCTL_OPNUM_QueryServiceSecurity)
		struct svcctl_QueryServiceSecurity	SvcQueryServiceSecurity;
	CASE(SVCCTL_OPNUM_SetServiceSecurity)
		struct svcctl_SetServiceSecurity	SvcSetServiceSecurity;
	CASE(SVCCTL_OPNUM_OpenManager)
		struct svcctl_OpenManager		SvcOpenManager;
	CASE(SVCCTL_OPNUM_OpenService)
		struct svcctl_OpenService		SvcOpenService;
	CASE(SVCCTL_OPNUM_QueryServiceStatus)
		struct svcctl_QueryServiceStatus	SvcQueryServiceStatus;
	CASE(SVCCTL_OPNUM_EnumDependentServices)
		struct svcctl_EnumDependentServices Svc_EnumDependentServices;
	CASE(SVCCTL_OPNUM_EnumServicesStatus)
		struct svcctl_EnumServicesStatus	SvcEnumServicesStatus;
	CASE(SVCCTL_OPNUM_QueryServiceConfig)
		struct svcctl_QueryServiceConfig	SvcQueryServiceConfig;
	CASE(SVCCTL_OPNUM_StartService)
		struct svcctl_StartService		SvcStartService;
	CASE(SVCCTL_OPNUM_GetServiceDisplayNameW)
		struct svcctl_GetServiceDisplayNameW SvcGetServiceDisplayNameW;
	CASE(SVCCTL_OPNUM_GetServiceKeyNameW)
		struct svcctl_GetServiceKeyNameW	SvcGetServiceKeyNameW;
	CASE(SVCCTL_OPNUM_OpenSCManagerA)
		struct svcctl_OpenSCManagerA		SvcOpenSCManagerA;
	CASE(SVCCTL_OPNUM_OpenServiceA)
		struct svcctl_OpenServiceA		SvcOpenServiceA;
	CASE(SVCCTL_OPNUM_EnumServicesStatusA)
		struct svcctl_EnumServicesStatusA	SvcEnumServicesStatusA;
	CASE(SVCCTL_OPNUM_QueryServiceConfig2W)
		struct svcctl_QueryServiceConfig2W	SvcQueryServiceConfig2W;
	CASE(SVCCTL_OPNUM_QueryServiceStatusEx)
		struct svcctl_QueryServiceStatusEx	SvcQueryServiceStatusEx;
};

typedef union svcctl_interface	svcctl_interface_t;
EXTERNTYPEINFO(svcctl_interface)


#endif /* _MLSVC_SVCCTL_NDL_ */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _MLSVC_WINREG_NDL_
#define _MLSVC_WINREG_NDL_

/*
 * Windows Registry (WINREG) RPC interface definition.
 *
 * The Windows registry is split into a number of hives, which are divided
 * by function.  The hive names are abbreviated and prefixed by HKEY or HK.
 *
 * HKEY_CLASSES_ROOT     (HKCR)	Information about registered applications
 * HKEY_CURRENT_USER     (HKCU)	Settings for the current logged in user.
 * HKEY_LOCAL_MACHINE    (HKLM)	Settings for all users on the computer.
 * HKEY_USERS            (HKU)	HKEY_CURRENT_USER subkeys for user accounts.
 * HKEY_CURRENT_CONFIG   (HKCC)	Runtime configuration information.
 * HKEY_PERFORMANCE_DATA (HKPD)	Runtime performance data.
 * HKEY_DYN_DATA         (HKDD)	Runtime data for Windows 9x applications.
 * HKEY_PERFORMANCE_TEXT (HKPT)	Runtime performance information.
 * HKEY_PERFORMANCE_NLS  (HKPN)	Runtime performance information.
 */

#include <libmlrpc/ndrtypes.ndl>

/* Windows NT */
#define WINREG_OPNUM_OpenHKCR		0x00
#define WINREG_OPNUM_OpenHKCU		0x01
#define WINREG_OPNUM_OpenHKLM		0x02
#define WINREG_OPNUM_OpenHKPD		0x03
#define WINREG_OPNUM_OpenHKUsers	0x04
#define WINREG_OPNUM_Close		0x05
#define WINREG_OPNUM_CreateKey		0x06
#define WINREG_OPNUM_DeleteKey		0x07
#define WINREG_OPNUM_DeleteValue	0x08
#define WINREG_OPNUM_EnumKey		0x09
#define WINREG_OPNUM_EnumValue		0x0a
#define WINREG_OPNUM_FlushKey		0x0b
#define WINREG_OPNUM_GetKeySec		0x0c
#define WINREG_OPNUM_LoadKey		0x0d
#define WINREG_OPNUM_NotifyChange	0x0e
#define WINREG_OPNUM_OpenKey		0x0f
#define WINREG_OPNUM_QueryKey		0x10
#define WINREG_OPNUM_QueryValue		0x11
#define WINREG_OPNUM_ReplaceKey		0x12
#define WINREG_OPNUM_RestoreKey		0x13
#define WINREG_OPNUM_SaveKey		0x14
#define WINREG_OPNUM_SetKeySec		0x15

/* Windows 2000 */
#define WINREG_OPNUM_CreateValue	0x16
#define WINREG_OPNUM_UnloadKey		0x17
#define WINREG_OPNUM_Shutdown		0x18
#define WINREG_OPNUM_AbortShutdown	0x19
#define WINREG_OPNUM_GetVersion		0x1a
#define WINREG_OPNUM_OpenHKCC		0x1b
#define WINREG_OPNUM_OpenHKDD		0x1c
#define WINREG_OPNUM_QueryMultiValues	0x1d
#define WINREG_OPNUM_ShutdownEx		0x1e

/* Windows XP and Windows Server 2003 */
#define WINREG_OPNUM_SavekeyEx		0x1f
#define WINREG_OPNUM_OpenHKPT		0x20
#define WINREG_OPNUM_OpenHKPN		0x21

/* Windows 2003 SP1 */
#define WINREG_OPNUM_QueryMultiValues2	0x22
#define WINREG_OPNUM_DeleteKeyEx	0x23

#define	WINREG_TYPE_NONE		0
#define WINREG_SZ			1
#define WINREG_EXPAND_SZ		2
#define WINREG_BINARY			3
#define WINREG_DWORD			4
#define WINREG_DWORD_BIG_ENDIAN		5
#define WINREG_LINK			6
#define WINREG_MULTI_SZ			7
#define WINREG_RESOURCE_LIST		8
#define WINREG_RESOURCE_DESC		9
#define WINREG_RESOURCE_REQ_LIST	10
#define WINREG_QWORD			11

#define	WINREG_ACCESS_QUERY_VALUE	0x00000001
#define WINREG_ACCESS_SET_VALUE		0x00000002
#define WINREG_ACCESS_CREATE_KEY	0x00000004
#define WINREG_ACCESS_ENUMERATE		0x00000008
#define WINREG_ACCESS_NOTIFY		0x00000010
#define WINREG_ACCESS_CREATE_LINK	0x00000020
#define WINREG_ACCESS_KEY64		0x00000100
#define WINREG_ACCESS_KEY32		0x00000200

CONTEXT_HANDLE(winreg_handle) winreg_handle_t;

struct winreg_string_desc {
	WORD	length;
	WORD	allosize;
	LPTSTR	str;
};
typedef struct winreg_string_desc winreg_string_t;

/*
 * Fake Varying/Conformant with a funny conformant.
 */
struct winreg_value {
	DWORD	vc_first_is;	/* 0 */
	DWORD	vc_length_is;
    SIZE_IS(vc_length_is)
	BYTE	value[ANY_SIZE_ARRAY];
};

struct winreg_vcs {
	DWORD	vc_first_is;	/* 0 */
	DWORD	vc_length_is;
    SIZE_IS(vc_length_is)
	WORD	value[ANY_SIZE_ARRAY];
};

struct winreg_vcbuf {
	WORD wclen;
	WORD wcsize;
	struct winreg_vcs *buf;
};
typedef struct winreg_vcbuf winreg_vcbuf_t;

struct file_time {
	DWORD	low;
	DWORD	high;
};
typedef struct file_time file_time_t;

struct winreg_secdesc {
	struct winreg_value	*sd_buf;
	DWORD			sd_len;
	DWORD			sd_size;
};

OPERATION(WINREG_OPNUM_OpenHKCR)
struct winreg_OpenHKCR {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKCU)
struct winreg_OpenHKCU {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKLM)
struct winreg_OpenHKLM {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKPD)
struct winreg_OpenHKPD {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKUsers)
struct winreg_OpenHKUsers {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};


OPERATION(WINREG_OPNUM_Close)
struct winreg_Close {
	IN  winreg_handle_t	handle;
	OUT winreg_handle_t	result_handle;
	OUT DWORD		status;
};

#define	WINREG_ACTION_NONE		0
#define	WINREG_ACTION_NEW_KEY		1
#define	WINREG_ACTION_EXISTING_KEY	2

OPERATION(WINREG_OPNUM_CreateKey)
struct winreg_CreateKey {
	IN winreg_handle_t	handle;
	IN winreg_string_t	subkey;
	IN winreg_string_t	keyclass;
	IN DWORD		options;
	IN DWORD		access_mask;
	IN DWORD		*sd;
	OUT winreg_handle_t	result_handle;
	OUT DWORD		*action;
	OUT DWORD		status;
};


OPERATION(WINREG_OPNUM_DeleteKey)
struct winreg_DeleteKey {
	IN winreg_handle_t	handle;
	IN winreg_string_t	subkey;
	OUT DWORD		status;
};


OPERATION(WINREG_OPNUM_DeleteValue)
struct winreg_DeleteValue {
	IN winreg_handle_t	handle;
	IN winreg_string_t	name;
	OUT DWORD		status;
};

/*
 * Some of the OUT parameters are also supplied
 * as IN parameters but we can ignore them.
 */
OPERATION(WINREG_OPNUM_EnumKey)
struct winreg_EnumKey {
	IN	winreg_handle_t	handle;
	IN	DWORD	index;
	IN	winreg_string_t	name_in;
	IN	winreg_string_t	*class_in;
	OUT	winreg_string_t	name_out;
	OUT	winreg_string_t	*class_out;
	INOUT	file_time_t	*change_time;
	OUT	DWORD		status;
};

/*
 * Some of the OUT parameters are also supplied
 * as IN parameters but we can ignore them.
 */
OPERATION(WINREG_OPNUM_EnumValue)
struct winreg_EnumValue {
	IN winreg_handle_t	handle;
	IN DWORD		index;
	/* IN	ignore the remaining input data */

	OUT winreg_vcbuf_t	name;
	OUT DWORD		*type;
	OUT struct winreg_value *value;
	OUT DWORD		*value_size;
	OUT DWORD		*value_size_total;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_FlushKey)
struct winreg_FlushKey {
	IN winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_GetKeySec)
struct winreg_GetKeySec {
	IN		winreg_handle_t		handle;
	IN		DWORD			sec_info;
	OUT REFERENCE	struct winreg_secdesc	*sd;
	OUT		DWORD			status;
};

OPERATION(WINREG_OPNUM_NotifyChange)
struct winreg_NotifyChange {
	IN  winreg_handle_t	handle;
	IN  DWORD		watch_subtree;
	IN  DWORD		notify_filter;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenKey)
struct winreg_OpenKey {
	IN  winreg_handle_t	handle;
	IN  winreg_string_t	name;
	IN  DWORD		options;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	result_handle;
	OUT DWORD		status;
};


OPERATION(WINREG_OPNUM_QueryKey)
struct winreg_QueryKey {
	IN  winreg_handle_t	handle;
	INOUT winreg_string_t	name;
	OUT DWORD 		num_subkeys;
	OUT DWORD 		max_subkey_len;
	OUT DWORD 		max_class_len;
	OUT DWORD 		num_values;
	OUT DWORD 		max_value_namelen;
	OUT DWORD 		max_value_len;
	OUT DWORD 		secdesc_size;
	OUT file_time_t 	last_write_time;
	OUT DWORD		status;
};


/*
 * Some of the OUT parameters are also supplied
 * as IN parameters but we can ignore them.
 */
OPERATION(WINREG_OPNUM_QueryValue)
struct winreg_QueryValue {
	IN  winreg_handle_t	handle;
	IN  winreg_string_t	value_name;
	/* IN	ignore the remaining input data */

	OUT DWORD		*type;
	OUT struct winreg_value	*value;
	OUT DWORD		*value_size;
	OUT DWORD		*value_size_total;
	OUT DWORD		status;
};


OPERATION(WINREG_OPNUM_SetKeySec)
struct winreg_SetKeySec {
	IN winreg_handle_t	handle;
	IN DWORD		access_mask;
	IN DWORD		sd;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_CreateValue)
struct winreg_CreateValue {
	IN winreg_handle_t	handle;
	IN winreg_string_t	name;
	IN winreg_string_t	class;
	IN DWORD		options;
	/* IN	ignore the remaining input data */

	OUT DWORD		status;
};


/*
 * The real structure of shutdown passes some strings, a timeout
 * and reboot/shutdown flags but this allows us to accept the call,
 * without anything appearing in the log, and return access denied.
 */
OPERATION(WINREG_OPNUM_Shutdown)
struct winreg_Shutdown {
	IN DWORD		ignored;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_AbortShutdown)
struct winreg_AbortShutdown {
	IN DWORD		ignored;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_GetVersion)
struct winreg_GetVersion {
	IN winreg_handle_t	handle;
	OUT DWORD		version;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKCC)
struct winreg_OpenHKCC {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKDD)
struct winreg_OpenHKDD {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKPT)
struct winreg_OpenHKPT {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

OPERATION(WINREG_OPNUM_OpenHKPN)
struct winreg_OpenHKPN {
	IN  DWORD		*server;
	IN  DWORD		access_mask;
	OUT winreg_handle_t	handle;
	OUT DWORD		status;
};

/*
 * The WINREG interface.
 */
INTERFACE(0)
union winreg_interface {
	CASE(WINREG_OPNUM_OpenHKCR)
		struct winreg_OpenHKCR		OpenHKCR;
	CASE(WINREG_OPNUM_OpenHKCU)
		struct winreg_OpenHKCU		OpenHKCU;
	CASE(WINREG_OPNUM_OpenHKLM)
		struct winreg_OpenHKLM		OpenHKLM;
	CASE(WINREG_OPNUM_OpenHKPD)
		struct winreg_OpenHKPD		OpenHKPD;
	CASE(WINREG_OPNUM_OpenHKUsers)
		struct winreg_OpenHKUsers	OpenHKUsers;
	CASE(WINREG_OPNUM_Close)
		struct winreg_Close		Close;
	CASE(WINREG_OPNUM_CreateKey)
		struct winreg_CreateKey		CreateKey;
	CASE(WINREG_OPNUM_DeleteKey)
		struct winreg_DeleteKey		DeleteKey;
	CASE(WINREG_OPNUM_DeleteValue)
		struct winreg_DeleteValue	DeleteValue;
	CASE(WINREG_OPNUM_EnumKey)
		struct winreg_EnumKey		EnumKey;
	CASE(WINREG_OPNUM_EnumValue)
		struct winreg_EnumValue		EnumValue;
	CASE(WINREG_OPNUM_FlushKey)
		struct winreg_FlushKey		FlushKey;
	CASE(WINREG_OPNUM_GetKeySec)
		struct winreg_GetKeySec		GetKeySec;
	CASE(WINREG_OPNUM_NotifyChange)
		struct winreg_NotifyChange	NotifyChange;
	CASE(WINREG_OPNUM_OpenKey)
		struct winreg_OpenKey		OpenKey;
	CASE(WINREG_OPNUM_QueryKey)
		struct winreg_QueryKey		QueryKey;
	CASE(WINREG_OPNUM_QueryValue)
		struct winreg_QueryValue	QueryValue;
	CASE(WINREG_OPNUM_SetKeySec)
		struct winreg_SetKeySec		SetKeySec;
	CASE(WINREG_OPNUM_CreateValue)
		struct winreg_CreateValue	CreateValue;
	CASE(WINREG_OPNUM_Shutdown)
		struct winreg_Shutdown		Shutdown;
	CASE(WINREG_OPNUM_AbortShutdown)
		struct winreg_AbortShutdown	AbortShutdown;
	CASE(WINREG_OPNUM_GetVersion)
		struct winreg_GetVersion	GetVersion;
	CASE(WINREG_OPNUM_OpenHKCC)
		struct winreg_OpenHKCC		OpenHKCC;
	CASE(WINREG_OPNUM_OpenHKDD)
		struct winreg_OpenHKDD		OpenHKDD;
	CASE(WINREG_OPNUM_OpenHKPT)
		struct winreg_OpenHKPT		OpenHKPT;
	CASE(WINREG_OPNUM_OpenHKPN)
		struct winreg_OpenHKPN		OpenHKPN;
};
typedef union winreg_interface	winreg_interface_t;
EXTERNTYPEINFO(winreg_interface)

#endif /* _MLSVC_WINREG_NDL_ */