xref: /titanic_41/usr/src/uts/common/smbsrv/ndl/lsarpc.ndl (revision f3312ec0e8acbd249df97358fb8c3ca92f4e089c)

/*
 * 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.
 */

#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 "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_ */