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