sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

r18185: add librpc/idl and relevant IDL files from SAMBA_4_0

Browse Source
This commit is contained in:
Gerald Carter 2006-09-06 18:04:51 +00:00 committed by Gerald (Jerry) Carter
parent 7d5356fd5d
commit 6da1ef0f1c
15 changed files with 8423 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
source/librpc/idl/echo.idl Normal file
View File

@ -0,0 +1,128 @@
[
uuid("60a15ec5-4de8-11d7-a637-005056a20182"),
endpoint("ncacn_np:[\\pipe\\rpcecho]", "ncacn_ip_tcp:", "ncalrpc:"),
pointer_default(unique),
version(1.0),
helpstring("Simple echo pipe"),
keepref
]
interface rpcecho
{
/* Add one to an integer */
void echo_AddOne(
[in] uint32 in_data,
[out] uint32 *out_data
);
/* Echo an array of bytes back at the caller */
void echo_EchoData(
[in] uint32 len,
[in] [size_is(len)] uint8 in_data[],
[out] [size_is(len)] uint8 out_data[]
);
/* Sink data to the server */
void echo_SinkData(
[in] uint32 len,
[in,size_is(len)] uint8 data[]
);
/* Source data from server */
void echo_SourceData(
[in] uint32 len,
[out,size_is(len)] uint8 data[]
);
/* test strings */
void echo_TestCall (
[in,string,charset(UTF16)] uint16 *s1,
[out,string,charset(UTF16)] uint16 *s2
);
/* test some alignment issues */
typedef struct {
uint8 v;
} echo_info1;
typedef struct {
uint16 v;
} echo_info2;
typedef struct {
uint32 v;
} echo_info3;
typedef struct {
hyper v;
} echo_info4;
typedef struct {
uint8 v1;
hyper v2;
} echo_info5;
typedef struct {
uint8 v1;
echo_info1 info1;
} echo_info6;
typedef struct {
uint8 v1;
echo_info4 info4;
} echo_info7;
typedef [switch_type(uint16)] union {
[case(1)] echo_info1 info1;
[case(2)] echo_info2 info2;
[case(3)] echo_info3 info3;
[case(4)] echo_info4 info4;
[case(5)] echo_info5 info5;
[case(6)] echo_info6 info6;
[case(7)] echo_info7 info7;
} echo_Info;
NTSTATUS echo_TestCall2 (
[in] uint16 level,
[out,switch_is(level)] echo_Info *info
);
uint32 echo_TestSleep(
[in] uint32 seconds
);
typedef enum {
ECHO_ENUM1 = 1,
ECHO_ENUM2 = 2
} echo_Enum1;
typedef [v1_enum] enum {
ECHO_ENUM1_32 = 1,
ECHO_ENUM2_32 = 2
} echo_Enum1_32;
typedef struct {
echo_Enum1 e1;
echo_Enum1_32 e2;
} echo_Enum2;
typedef [switch_type(uint16)] union {
[case(ECHO_ENUM1)] echo_Enum1 e1;
[case(ECHO_ENUM2)] echo_Enum2 e2;
} echo_Enum3;
void echo_TestEnum(
[in,out,ref] echo_Enum1 *foo1,
[in,out,ref] echo_Enum2 *foo2,
[in,out,ref,switch_is(*foo1)] echo_Enum3 *foo3
);
typedef struct {
uint32 x;
[size_is(x)] uint16 surrounding[*];
} echo_Surrounding;
void echo_TestSurrounding(
[in,out,ref] echo_Surrounding *data
);
uint16 echo_TestDoublePointer([in] uint16 ***data);
}

178
source/librpc/idl/eventlog.idl Normal file
View File

@ -0,0 +1,178 @@
#include "idl_types.h"
/*
eventlog interface definition
*/
[ uuid("82273fdc-e32a-18c3-3f78-827929dc23ea"),
version(0.0),
depends(lsa,security),
pointer_default(unique),
helpstring("Event Logger"),
keepref
] interface eventlog
{
typedef bitmap {
EVENTLOG_SEQUENTIAL_READ = 0x0001,
EVENTLOG_SEEK_READ = 0x0002,
EVENTLOG_FORWARDS_READ = 0x0004,
EVENTLOG_BACKWARDS_READ = 0x0008
} eventlogReadFlags;
typedef bitmap {
EVENTLOG_SUCCESS = 0x0000,
EVENTLOG_ERROR_TYPE = 0x0001,
EVENTLOG_WARNING_TYPE = 0x0002,
EVENTLOG_INFORMATION_TYPE = 0x0004,
EVENTLOG_AUDIT_SUCCESS = 0x0008,
EVENTLOG_AUDIT_FAILURE = 0x0010
} eventlogEventTypes;
typedef struct {
uint16 unknown0;
uint16 unknown1;
} eventlog_OpenUnknown0;
typedef [public] struct {
uint32 size;
uint32 reserved;
uint32 record_number;
uint32 time_generated;
uint32 time_written;
uint32 event_id;
uint16 event_type;
uint16 num_of_strings;
uint16 event_category;
uint16 reserved_flags;
uint32 closing_record_number;
uint32 stringoffset;
uint32 sid_length;
uint32 sid_offset;
uint32 data_length;
uint32 data_offset;
nstring source_name;
nstring computer_name;
nstring strings[num_of_strings];
astring raw_data;
} eventlog_Record;
/******************/
/* Function: 0x00 */
NTSTATUS eventlog_ClearEventLogW(
[in] policy_handle *handle,
[in,unique] lsa_String *unknown
);
/******************/
/* Function: 0x01 */
NTSTATUS eventlog_BackupEventLogW();
/******************/
/* Function: 0x02 */
NTSTATUS eventlog_CloseEventLog(
[in,out] policy_handle *handle
);
/******************/
/* Function: 0x03 */
NTSTATUS eventlog_DeregisterEventSource();
/******************/
/* Function: 0x04 */
NTSTATUS eventlog_GetNumRecords(
[in] policy_handle *handle,
[out] uint32 number
);
/******************/
/* Function: 0x05 */
NTSTATUS eventlog_GetOldestRecord();
/******************/
/* Function: 0x06 */
NTSTATUS eventlog_ChangeNotify();
/******************/
/* Function: 0x07 */
NTSTATUS eventlog_OpenEventLogW(
[in,unique] eventlog_OpenUnknown0 *unknown0,
[in] lsa_String logname,
[in] lsa_String servername,
[in] uint32 unknown2,
[in] uint32 unknown3,
[out] policy_handle *handle
);
/******************/
/* Function: 0x08 */
NTSTATUS eventlog_RegisterEventSourceW();
/******************/
/* Function: 0x09 */
NTSTATUS eventlog_OpenBackupEventLogW();
/******************/
/* Function: 0x0a */
NTSTATUS eventlog_ReadEventLogW(
[in] policy_handle *handle,
[in] uint32 flags,
[in] uint32 offset,
[in] uint32 number_of_bytes,
[out,size_is(number_of_bytes)] uint8 *data,
[out] uint32 sent_size,
[out] uint32 real_size
);
/*****************/
/* Function 0x0b */
NTSTATUS eventlog_ReportEventW();
/*****************/
/* Function 0x0c */
NTSTATUS eventlog_ClearEventLogA();
/******************/
/* Function: 0x0d */
NTSTATUS eventlog_BackupEventLogA();
/*****************/
/* Function 0x0e */
NTSTATUS eventlog_OpenEventLogA();
/*****************/
/* Function 0x0f */
NTSTATUS eventlog_RegisterEventSourceA();
/*****************/
/* Function 0x10 */
NTSTATUS eventlog_OpenBackupEventLogA();
/*****************/
/* Function 0x11 */
NTSTATUS eventlog_ReadEventLogA();
/*****************/
/* Function 0x12 */
NTSTATUS eventlog_ReportEventA();
/*****************/
/* Function 0x13 */
NTSTATUS eventlog_RegisterClusterSvc();
/*****************/
/* Function 0x14 */
NTSTATUS eventlog_DeregisterClusterSvc();
/*****************/
/* Function 0x15 */
NTSTATUS eventlog_WriteClusterEvents();
/*****************/
/* Function 0x16 */
NTSTATUS eventlog_GetLogIntormation();
/*****************/
/* Function 0x17 */
NTSTATUS eventlog_FlushEventLog(
[in] policy_handle *handle
);
}

47
source/librpc/idl/initshutdown.idl Normal file
View File

@ -0,0 +1,47 @@
#include "idl_types.h"
/*
initshutdown interface definition
*/
[
uuid("894de0c0-0d55-11d3-a322-00c04fa321a1"),
version(1.0),
endpoint("ncacn_np:[\\pipe\\InitShutdown]"),
pointer_default(unique),
helpstring("Init shutdown service"),
keepref
] interface initshutdown
{
typedef struct {
[value(strlen_m_term(name))] uint32 name_size;
[flag(STR_LEN4|STR_NOTERM)] string name;
} initshutdown_String_sub;
typedef [public] struct {
[value(strlen_m(r->name->name)*2)] uint16 name_len;
[value(strlen_m_term(r->name->name)*2)] uint16 name_size;
initshutdown_String_sub *name;
} initshutdown_String;
WERROR initshutdown_Init(
[in,unique] uint16 *hostname,
[in,unique] initshutdown_String *message,
[in] uint32 timeout,
[in] uint8 force_apps,
[in] uint8 reboot
);
WERROR initshutdown_Abort(
[in,unique] uint16 *server
);
WERROR initshutdown_InitEx(
[in,unique] uint16 *hostname,
[in,unique] initshutdown_String *message,
[in] uint32 timeout,
[in] uint8 force_apps,
[in] uint8 reboot,
[in] uint32 reason
);
}

975
source/librpc/idl/lsa.idl Normal file
View File

@ -0,0 +1,975 @@
#include "idl_types.h"
/*
lsa interface definition
*/
[ uuid("12345778-1234-abcd-ef00-0123456789ab"),
version(0.0),
endpoint("ncacn_np:[\\pipe\\lsarpc]","ncacn_np:[\\pipe\\netlogon]","ncacn_np:[\\pipe\\lsass]", "ncacn_ip_tcp:", "ncalrpc:"),
pointer_default(unique),
helpstring("Local Security Authority"),
depends(security),
keepref
] interface lsarpc
{
declare bitmap security_secinfo;
typedef [public,noejs] struct {
[value(2*strlen_m(string))] uint16 length;
[value(2*strlen_m(string))] uint16 size;
[charset(UTF16),size_is(size/2),length_is(length/2)] uint16 *string;
} lsa_String;
typedef [public] struct {
[value(2*strlen_m(string))] uint16 length;
[value(2*(strlen_m(string)+1))] uint16 size;
[charset(UTF16),size_is(size/2),length_is(length/2)] uint16 *string;
} lsa_StringLarge;
typedef [public] struct {
uint32 count;
[size_is(count)] lsa_String *names;
} lsa_Strings;
typedef [public] struct {
[value(strlen_m(string))] uint16 length;
[value(strlen_m(string))] uint16 size;
ascstr_noterm *string;
} lsa_AsciiString;
/******************/
/* Function: 0x00 */
NTSTATUS lsa_Close (
[in,out] policy_handle *handle
);
/******************/
/* Function: 0x01 */
NTSTATUS lsa_Delete (
[in] policy_handle *handle
);
/******************/
/* Function: 0x02 */
typedef struct {
uint32 low;
uint32 high;
} lsa_LUID;
typedef struct {
lsa_StringLarge name;
lsa_LUID luid;
} lsa_PrivEntry;
typedef struct {
uint32 count;
[size_is(count)] lsa_PrivEntry *privs;
} lsa_PrivArray;
NTSTATUS lsa_EnumPrivs (
[in] policy_handle *handle,
[in,out] uint32 *resume_handle,
[in] uint32 max_count,
[out] lsa_PrivArray *privs
);
/******************/
/* Function: 0x03 */
NTSTATUS lsa_QuerySecurity (
[in] policy_handle *handle,
[in] security_secinfo sec_info,
[out,unique] sec_desc_buf *sdbuf
);
/******************/
/* Function: 0x04 */
NTSTATUS lsa_SetSecObj ();
/******************/
/* Function: 0x05 */
NTSTATUS lsa_ChangePassword ();
/******************/
/* Function: 0x06 */
typedef struct {
uint32 len; /* ignored */
uint16 impersonation_level;
uint8 context_mode;
uint8 effective_only;
} lsa_QosInfo;
typedef struct {
uint32 len; /* ignored */
uint8 *root_dir;
[string,charset(UTF16)] uint16 *object_name;
uint32 attributes;
security_descriptor *sec_desc;
lsa_QosInfo *sec_qos;
} lsa_ObjectAttribute;
/* notice the screwup with the system_name - thats why MS created
OpenPolicy2 */
NTSTATUS lsa_OpenPolicy (
[in,unique] uint16 *system_name,
[in] lsa_ObjectAttribute *attr,
[in] uint32 access_mask,
[out] policy_handle *handle
);
/******************/
/* Function: 0x07 */
typedef struct {
uint32 percent_full;
uint32 log_size;
NTTIME retention_time;
uint8 shutdown_in_progress;
NTTIME time_to_shutdown;
uint32 next_audit_record;
uint32 unknown;
} lsa_AuditLogInfo;
typedef struct {
uint32 auditing_mode;
[size_is(count)] uint32 *settings;
uint32 count;
} lsa_AuditEventsInfo;
typedef struct {
lsa_StringLarge name;
dom_sid2 *sid;
} lsa_DomainInfo;
typedef struct {
lsa_String name;
} lsa_PDAccountInfo;
typedef struct {
uint16 unknown; /* an midl padding bug? */
uint16 role;
} lsa_ServerRole;
typedef struct {
lsa_String source;
lsa_String account;
} lsa_ReplicaSourceInfo;
typedef struct {
uint32 paged_pool;
uint32 non_paged_pool;
uint32 min_wss;
uint32 max_wss;
uint32 pagefile;
hyper unknown;
} lsa_DefaultQuotaInfo;
typedef struct {
hyper modified_id;
NTTIME db_create_time;
} lsa_ModificationInfo;
typedef struct {
uint8 shutdown_on_full;
} lsa_AuditFullSetInfo;
typedef struct {
uint16 unknown; /* an midl padding bug? */
uint8 shutdown_on_full;
uint8 log_is_full;
} lsa_AuditFullQueryInfo;
typedef struct {
/* it's important that we use the lsa_StringLarge here,
* because otherwise windows clients result with such dns hostnames
* e.g. w2k3-client.samba4.samba.orgsamba4.samba.org
* where it should be
* w2k3-client.samba4.samba.org
*/
lsa_StringLarge name;
lsa_StringLarge dns_domain;
lsa_StringLarge dns_forest;
GUID domain_guid;
dom_sid2 *sid;
} lsa_DnsDomainInfo;
typedef enum {
LSA_POLICY_INFO_AUDIT_LOG=1,
LSA_POLICY_INFO_AUDIT_EVENTS=2,
LSA_POLICY_INFO_DOMAIN=3,
LSA_POLICY_INFO_PD=4,
LSA_POLICY_INFO_ACCOUNT_DOMAIN=5,
LSA_POLICY_INFO_ROLE=6,
LSA_POLICY_INFO_REPLICA=7,
LSA_POLICY_INFO_QUOTA=8,
LSA_POLICY_INFO_DB=9,
LSA_POLICY_INFO_AUDIT_FULL_SET=10,
LSA_POLICY_INFO_AUDIT_FULL_QUERY=11,
LSA_POLICY_INFO_DNS=12
} lsaPolicyInfo;
typedef [switch_type(uint16)] union {
[case(LSA_POLICY_INFO_AUDIT_LOG)] lsa_AuditLogInfo audit_log;
[case(LSA_POLICY_INFO_AUDIT_EVENTS)] lsa_AuditEventsInfo audit_events;
[case(LSA_POLICY_INFO_DOMAIN)] lsa_DomainInfo domain;
[case(LSA_POLICY_INFO_PD)] lsa_PDAccountInfo pd;
[case(LSA_POLICY_INFO_ACCOUNT_DOMAIN)] lsa_DomainInfo account_domain;
[case(LSA_POLICY_INFO_ROLE)] lsa_ServerRole role;
[case(LSA_POLICY_INFO_REPLICA)] lsa_ReplicaSourceInfo replica;
[case(LSA_POLICY_INFO_QUOTA)] lsa_DefaultQuotaInfo quota;
[case(LSA_POLICY_INFO_DB)] lsa_ModificationInfo db;
[case(LSA_POLICY_INFO_AUDIT_FULL_SET)] lsa_AuditFullSetInfo auditfullset;
[case(LSA_POLICY_INFO_AUDIT_FULL_QUERY)] lsa_AuditFullQueryInfo auditfullquery;
[case(LSA_POLICY_INFO_DNS)] lsa_DnsDomainInfo dns;
} lsa_PolicyInformation;
NTSTATUS lsa_QueryInfoPolicy (
[in] policy_handle *handle,
[in] uint16 level,
[out,unique,switch_is(level)] lsa_PolicyInformation *info
);
/******************/
/* Function: 0x08 */
NTSTATUS lsa_SetInfoPolicy ();
/******************/
/* Function: 0x09 */
NTSTATUS lsa_ClearAuditLog ();
/******************/
/* Function: 0x0a */
NTSTATUS lsa_CreateAccount (
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[in] uint32 access_mask,
[out] policy_handle *acct_handle
);
/******************/
/* NOTE: This only returns accounts that have at least
one privilege set
*/
/* Function: 0x0b */
typedef struct {
dom_sid2 *sid;
} lsa_SidPtr;
typedef [public] struct {
[range(0,1000)] uint32 num_sids;
[size_is(num_sids)] lsa_SidPtr *sids;
} lsa_SidArray;
NTSTATUS lsa_EnumAccounts (
[in] policy_handle *handle,
[in,out] uint32 *resume_handle,
[in,range(0,8192)] uint32 num_entries,
[out] lsa_SidArray *sids
);
/*************************************************/
/* Function: 0x0c */
NTSTATUS lsa_CreateTrustedDomain(
[in] policy_handle *handle,
[in] lsa_DomainInfo *info,
[in] uint32 access_mask,
[out] policy_handle *trustdom_handle
);
/******************/
/* Function: 0x0d */
/* w2k3 treats max_size as max_domains*60 */
const int LSA_ENUM_TRUST_DOMAIN_MULTIPLIER = 60;
typedef struct {
uint32 count;
[size_is(count)] lsa_DomainInfo *domains;
} lsa_DomainList;
NTSTATUS lsa_EnumTrustDom (
[in] policy_handle *handle,
[in,out] uint32 *resume_handle,
[in,range(0,1000)] uint32 max_size,
[out] lsa_DomainList *domains
);
/******************/
/* Function: 0x0e */
typedef enum {
SID_NAME_USE_NONE = 0,/* NOTUSED */
SID_NAME_USER = 1, /* user */
SID_NAME_DOM_GRP = 2, /* domain group */
SID_NAME_DOMAIN = 3, /* domain: don't know what this is */
SID_NAME_ALIAS = 4, /* local group */
SID_NAME_WKN_GRP = 5, /* well-known group */
SID_NAME_DELETED = 6, /* deleted account: needed for c2 rating */
SID_NAME_INVALID = 7, /* invalid account */
SID_NAME_UNKNOWN = 8 /* oops. */
} lsa_SidType;
typedef struct {
lsa_SidType sid_type;
uint32 rid;
uint32 sid_index;
} lsa_TranslatedSid;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_TranslatedSid *sids;
} lsa_TransSidArray;
const int LSA_REF_DOMAIN_LIST_MULTIPLIER = 32;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_DomainInfo *domains;
uint32 max_size;
} lsa_RefDomainList;
NTSTATUS lsa_LookupNames (
[in] policy_handle *handle,
[in,range(0,1000)] uint32 num_names,
[in,size_is(num_names)] lsa_String names[],
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransSidArray *sids,
[in] uint16 level,
[in,out] uint32 *count
);
/******************/
/* Function: 0x0f */
typedef struct {
lsa_SidType sid_type;
lsa_String name;
uint32 sid_index;
} lsa_TranslatedName;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_TranslatedName *names;
} lsa_TransNameArray;
NTSTATUS lsa_LookupSids (
[in] policy_handle *handle,
[in] lsa_SidArray *sids,
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransNameArray *names,
[in] uint16 level,
[in,out] uint32 *count
);
/* Function: 0x10 */
NTSTATUS lsa_CreateSecret(
[in] policy_handle *handle,
[in] lsa_String name,
[in] uint32 access_mask,
[out] policy_handle *sec_handle
);
/*****************************************/
/* Function: 0x11 */
NTSTATUS lsa_OpenAccount (
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[in] uint32 access_mask,
[out] policy_handle *acct_handle
);
/****************************************/
/* Function: 0x12 */
typedef struct {
lsa_LUID luid;
uint32 attribute;
} lsa_LUIDAttribute;
typedef struct {
[range(0,1000)] uint32 count;
uint32 unknown;
[size_is(count)] lsa_LUIDAttribute set[*];
} lsa_PrivilegeSet;
NTSTATUS lsa_EnumPrivsAccount (
[in] policy_handle *handle,
[out,unique] lsa_PrivilegeSet *privs
);
/****************************************/
/* Function: 0x13 */
NTSTATUS lsa_AddPrivilegesToAccount(
[in] policy_handle *handle,
[in] lsa_PrivilegeSet *privs
);
/****************************************/
/* Function: 0x14 */
NTSTATUS lsa_RemovePrivilegesFromAccount(
[in] policy_handle *handle,
[in] uint8 remove_all,
[in,unique] lsa_PrivilegeSet *privs
);
/* Function: 0x15 */
NTSTATUS lsa_GetQuotasForAccount();
/* Function: 0x16 */
NTSTATUS lsa_SetQuotasForAccount();
/* Function: 0x17 */
NTSTATUS lsa_GetSystemAccessAccount();
/* Function: 0x18 */
NTSTATUS lsa_SetSystemAccessAccount();
/* Function: 0x19 */
NTSTATUS lsa_OpenTrustedDomain(
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[in] uint32 access_mask,
[out] policy_handle *trustdom_handle
);
typedef [flag(NDR_PAHEX)] struct {
uint32 length;
uint32 size;
[size_is(size),length_is(length)] uint8 *data;
} lsa_DATA_BUF;
typedef [flag(NDR_PAHEX)] struct {
[range(0,65536)] uint32 size;
[size_is(size)] uint8 *data;
} lsa_DATA_BUF2;
typedef enum {
LSA_TRUSTED_DOMAIN_INFO_NAME = 1,
LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO = 2,
LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET = 3,
LSA_TRUSTED_DOMAIN_INFO_PASSWORD = 4,
LSA_TRUSTED_DOMAIN_INFO_BASIC = 5,
LSA_TRUSTED_DOMAIN_INFO_INFO_EX = 6,
LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO = 7,
LSA_TRUSTED_DOMAIN_INFO_FULL_INFO = 8,
LSA_TRUSTED_DOMAIN_INFO_11 = 11,
LSA_TRUSTED_DOMAIN_INFO_INFO_ALL = 12
} lsa_TrustDomInfoEnum;
typedef struct {
lsa_StringLarge netbios_name;
} lsa_TrustDomainInfoName;
typedef struct {
uint32 posix_offset;
} lsa_TrustDomainInfoPosixOffset;
typedef struct {
lsa_DATA_BUF *password;
lsa_DATA_BUF *old_password;
} lsa_TrustDomainInfoPassword;
typedef struct {
lsa_String netbios_name;
dom_sid2 *sid;
} lsa_TrustDomainInfoBasic;
typedef struct {
lsa_StringLarge domain_name;
lsa_StringLarge netbios_name;
dom_sid2 *sid;
uint32 trust_direction;
uint32 trust_type;
uint32 trust_attributes;
} lsa_TrustDomainInfoInfoEx;
typedef struct {
NTTIME_hyper last_update_time;
uint32 secret_type;
lsa_DATA_BUF2 data;
} lsa_TrustDomainInfoBuffer;
typedef struct {
uint32 incoming_count;
lsa_TrustDomainInfoBuffer *incoming_current_auth_info;
lsa_TrustDomainInfoBuffer *incoming_previous_auth_info;
uint32 outgoing_count;
lsa_TrustDomainInfoBuffer *outgoing_current_auth_info;
lsa_TrustDomainInfoBuffer *outgoing_previous_auth_info;
} lsa_TrustDomainInfoAuthInfo;
typedef struct {
lsa_TrustDomainInfoInfoEx info_ex;
lsa_TrustDomainInfoPosixOffset posix_offset;
lsa_TrustDomainInfoAuthInfo auth_info;
} lsa_TrustDomainInfoFullInfo;
typedef struct {
lsa_TrustDomainInfoInfoEx info_ex;
lsa_DATA_BUF2 data1;
} lsa_TrustDomainInfo11;
typedef struct {
lsa_TrustDomainInfoInfoEx info_ex;
lsa_DATA_BUF2 data1;
lsa_TrustDomainInfoPosixOffset posix_offset;
lsa_TrustDomainInfoAuthInfo auth_info;
} lsa_TrustDomainInfoInfoAll;
typedef [switch_type(lsa_TrustDomInfoEnum)] union {
[case(LSA_TRUSTED_DOMAIN_INFO_NAME)] lsa_TrustDomainInfoName name;
[case(LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET)] lsa_TrustDomainInfoPosixOffset posix_offset;
[case(LSA_TRUSTED_DOMAIN_INFO_PASSWORD)] lsa_TrustDomainInfoPassword password;
[case(LSA_TRUSTED_DOMAIN_INFO_BASIC)] lsa_TrustDomainInfoBasic info_basic;
[case(LSA_TRUSTED_DOMAIN_INFO_INFO_EX)] lsa_TrustDomainInfoInfoEx info_ex;
[case(LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO)] lsa_TrustDomainInfoAuthInfo auth_info;
[case(LSA_TRUSTED_DOMAIN_INFO_FULL_INFO)] lsa_TrustDomainInfoFullInfo full_info;
[case(LSA_TRUSTED_DOMAIN_INFO_11)] lsa_TrustDomainInfo11 info11;
[case(LSA_TRUSTED_DOMAIN_INFO_INFO_ALL)] lsa_TrustDomainInfoInfoAll info_all;
} lsa_TrustedDomainInfo;
/* Function: 0x1a */
NTSTATUS lsa_QueryTrustedDomainInfo(
[in] policy_handle *trustdom_handle,
[in] lsa_TrustDomInfoEnum level,
[out,switch_is(level),unique] lsa_TrustedDomainInfo *info
);
/* Function: 0x1b */
NTSTATUS lsa_SetInformationTrustedDomain();
/* Function: 0x1c */
NTSTATUS lsa_OpenSecret(
[in] policy_handle *handle,
[in] lsa_String name,
[in] uint32 access_mask,
[out] policy_handle *sec_handle
);
/* Function: 0x1d */
NTSTATUS lsa_SetSecret(
[in] policy_handle *sec_handle,
[in,unique] lsa_DATA_BUF *new_val,
[in,unique] lsa_DATA_BUF *old_val
);
typedef struct {
lsa_DATA_BUF *buf;
} lsa_DATA_BUF_PTR;
/* Function: 0x1e */
NTSTATUS lsa_QuerySecret (
[in] policy_handle *sec_handle,
[in,out,unique] lsa_DATA_BUF_PTR *new_val,
[in,out,unique] NTTIME_hyper *new_mtime,
[in,out,unique] lsa_DATA_BUF_PTR *old_val,
[in,out,unique] NTTIME_hyper *old_mtime
);
/* Function: 0x1f */
NTSTATUS lsa_LookupPrivValue(
[in] policy_handle *handle,
[in] lsa_String *name,
[out] lsa_LUID *luid
);
/* Function: 0x20 */
NTSTATUS lsa_LookupPrivName (
[in] policy_handle *handle,
[in] lsa_LUID *luid,
[out,unique] lsa_StringLarge *name
);
/*******************/
/* Function: 0x21 */
NTSTATUS lsa_LookupPrivDisplayName (
[in] policy_handle *handle,
[in] lsa_String *name,
[out,unique] lsa_StringLarge *disp_name,
/* see http://www.microsoft.com/globaldev/nlsweb/ for
language definitions */
[in,out] uint16 *language_id,
[in] uint16 unknown
);
/* Function: 0x22 */
NTSTATUS lsa_DeleteObject();
/*******************/
/* Function: 0x23 */
NTSTATUS lsa_EnumAccountsWithUserRight (
[in] policy_handle *handle,
[in,unique] lsa_String *name,
[out] lsa_SidArray *sids
);
/* Function: 0x24 */
typedef struct {
[string,charset(UTF16)] uint16 *name;
} lsa_RightAttribute;
typedef struct {
uint32 count;
[size_is(count)] lsa_StringLarge *names;
} lsa_RightSet;
NTSTATUS lsa_EnumAccountRights (
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[out] lsa_RightSet *rights
);
/**********************/
/* Function: 0x25 */
NTSTATUS lsa_AddAccountRights (
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[in] lsa_RightSet *rights
);
/**********************/
/* Function: 0x26 */
NTSTATUS lsa_RemoveAccountRights (
[in] policy_handle *handle,
[in] dom_sid2 *sid,
[in] uint32 unknown,
[in] lsa_RightSet *rights
);
/* Function: 0x27 */
NTSTATUS lsa_QueryTrustedDomainInfoBySid(
[in] policy_handle *handle,
[in] dom_sid2 *dom_sid,
[in] lsa_TrustDomInfoEnum level,
[out,switch_is(level),unique] lsa_TrustedDomainInfo *info
);
/* Function: 0x28 */
NTSTATUS lsa_SetTrustedDomainInfo();
/* Function: 0x29 */
NTSTATUS lsa_DeleteTrustedDomain(
[in] policy_handle *handle,
[in] dom_sid2 *dom_sid
);
/* Function: 0x2a */
NTSTATUS lsa_StorePrivateData();
/* Function: 0x2b */
NTSTATUS lsa_RetrievePrivateData();
/**********************/
/* Function: 0x2c */
NTSTATUS lsa_OpenPolicy2 (
[in,unique] [string,charset(UTF16)] uint16 *system_name,
[in] lsa_ObjectAttribute *attr,
[in] uint32 access_mask,
[out] policy_handle *handle
);
/**********************/
/* Function: 0x2d */
typedef struct {
lsa_String *string;
} lsa_StringPointer;
NTSTATUS lsa_GetUserName(
[in,unique] [string,charset(UTF16)] uint16 *system_name,
[in,out,unique] lsa_String *account_name,
[in,out,unique] lsa_StringPointer *authority_name
);
/**********************/
/* Function: 0x2e */
NTSTATUS lsa_QueryInfoPolicy2(
[in] policy_handle *handle,
[in] uint16 level,
[out,unique,switch_is(level)] lsa_PolicyInformation *info
);
/* Function 0x2f */
NTSTATUS lsa_SetInfoPolicy2();
/**********************/
/* Function 0x30 */
NTSTATUS lsa_QueryTrustedDomainInfoByName(
[in] policy_handle *handle,
[in] lsa_String trusted_domain,
[in] lsa_TrustDomInfoEnum level,
[out,unique,switch_is(level)] lsa_TrustedDomainInfo *info
);
/**********************/
/* Function 0x31 */
NTSTATUS lsa_SetTrustedDomainInfoByName(
[in] policy_handle *handle,
[in] lsa_String trusted_domain,
[in] lsa_TrustDomInfoEnum level,
[in,unique,switch_is(level)] lsa_TrustedDomainInfo *info
);
/* Function 0x32 */
/* w2k3 treats max_size as max_domains*82 */
const int LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER = 82;
typedef struct {
uint32 count;
[size_is(count)] lsa_TrustDomainInfoInfoEx *domains;
} lsa_DomainListEx;
NTSTATUS lsa_EnumTrustedDomainsEx (
[in] policy_handle *handle,
[in,out] uint32 *resume_handle,
[out] lsa_DomainListEx *domains,
[in] uint32 max_size
);
/* Function 0x33 */
NTSTATUS lsa_CreateTrustedDomainEx();
/* Function 0x34 */
NTSTATUS lsa_CloseTrustedDomainEx(
[in,out] policy_handle *handle
);
/* Function 0x35 */
/* w2k3 returns either 0x000bbbd000000000 or 0x000a48e800000000
for unknown6 - gd */
typedef struct {
uint32 enforce_restrictions;
hyper service_tkt_lifetime;
hyper user_tkt_lifetime;
hyper user_tkt_renewaltime;
hyper clock_skew;
hyper unknown6;
} lsa_DomainInfoKerberos;
typedef struct {
uint32 blob_size;
[size_is(blob_size)] uint8 *efs_blob;
} lsa_DomainInfoEfs;
typedef enum {
LSA_DOMAIN_INFO_POLICY_EFS=2,
LSA_DOMAIN_INFO_POLICY_KERBEROS=3
} lsa_DomainInfoEnum;
typedef [switch_type(uint16)] union {
[case(LSA_DOMAIN_INFO_POLICY_EFS)] lsa_DomainInfoEfs efs_info;
[case(LSA_DOMAIN_INFO_POLICY_KERBEROS)] lsa_DomainInfoKerberos kerberos_info;
} lsa_DomainInformationPolicy;
NTSTATUS lsa_QueryDomainInformationPolicy(
[in] policy_handle *handle,
[in] uint16 level,
[out,unique,switch_is(level)] lsa_DomainInformationPolicy *info
);
/* Function 0x36 */
NTSTATUS lsa_SetDomainInformationPolicy(
[in] policy_handle *handle,
[in] uint16 level,
[in,unique,switch_is(level)] lsa_DomainInformationPolicy *info
);
/**********************/
/* Function 0x37 */
NTSTATUS lsa_OpenTrustedDomainByName(
[in] policy_handle *handle,
[in] lsa_String name,
[in] uint32 access_mask,
[out] policy_handle *trustdom_handle
);
/* Function 0x38 */
NTSTATUS lsa_TestCall();
/**********************/
/* Function 0x39 */
typedef struct {
lsa_SidType sid_type;
lsa_String name;
uint32 sid_index;
uint32 unknown;
} lsa_TranslatedName2;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_TranslatedName2 *names;
} lsa_TransNameArray2;
NTSTATUS lsa_LookupSids2(
[in] policy_handle *handle,
[in] lsa_SidArray *sids,
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransNameArray2 *names,
[in] uint16 level,
[in,out] uint32 *count,
[in] uint32 unknown1,
[in] uint32 unknown2
);
/**********************/
/* Function 0x3a */
typedef struct {
lsa_SidType sid_type;
uint32 rid;
uint32 sid_index;
uint32 unknown;
} lsa_TranslatedSid2;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_TranslatedSid2 *sids;
} lsa_TransSidArray2;
NTSTATUS lsa_LookupNames2 (
[in] policy_handle *handle,
[in,range(0,1000)] uint32 num_names,
[in,size_is(num_names)] lsa_String names[],
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransSidArray2 *sids,
[in] uint16 level,
[in,out] uint32 *count,
[in] uint32 unknown1,
[in] uint32 unknown2
);
/* Function 0x3b */
NTSTATUS lsa_CreateTrustedDomainEx2();
/* Function 0x3c */
NTSTATUS lsa_CREDRWRITE();
/* Function 0x3d */
NTSTATUS lsa_CREDRREAD();
/* Function 0x3e */
NTSTATUS lsa_CREDRENUMERATE();
/* Function 0x3f */
NTSTATUS lsa_CREDRWRITEDOMAINCREDENTIALS();
/* Function 0x40 */
NTSTATUS lsa_CREDRREADDOMAINCREDENTIALS();
/* Function 0x41 */
NTSTATUS lsa_CREDRDELETE();
/* Function 0x42 */
NTSTATUS lsa_CREDRGETTARGETINFO();
/* Function 0x43 */
NTSTATUS lsa_CREDRPROFILELOADED();
/**********************/
/* Function 0x44 */
typedef struct {
lsa_SidType sid_type;
dom_sid2 *sid;
uint32 sid_index;
uint32 unknown;
} lsa_TranslatedSid3;
typedef struct {
[range(0,1000)] uint32 count;
[size_is(count)] lsa_TranslatedSid3 *sids;
} lsa_TransSidArray3;
NTSTATUS lsa_LookupNames3 (
[in] policy_handle *handle,
[in,range(0,1000)] uint32 num_names,
[in,size_is(num_names)] lsa_String names[],
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransSidArray3 *sids,
[in] uint16 level,
[in,out] uint32 *count,
[in] uint32 unknown1,
[in] uint32 unknown2
);
/* Function 0x45 */
NTSTATUS lsa_CREDRGETSESSIONTYPES();
/* Function 0x46 */
NTSTATUS lsa_LSARREGISTERAUDITEVENT();
/* Function 0x47 */
NTSTATUS lsa_LSARGENAUDITEVENT();
/* Function 0x48 */
NTSTATUS lsa_LSARUNREGISTERAUDITEVENT();
/* Function 0x49 */
NTSTATUS lsa_LSARQUERYFORESTTRUSTINFORMATION();
/* Function 0x4a */
NTSTATUS lsa_LSARSETFORESTTRUSTINFORMATION();
/* Function 0x4b */
NTSTATUS lsa_CREDRRENAME();
/*****************/
/* Function 0x4c */
NTSTATUS lsa_LookupSids3(
[in] lsa_SidArray *sids,
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransNameArray2 *names,
[in] uint16 level,
[in,out] uint32 *count,
[in] uint32 unknown1,
[in] uint32 unknown2
);
/* Function 0x4d */
NTSTATUS lsa_LookupNames4(
[in,range(0,1000)] uint32 num_names,
[in,size_is(num_names)] lsa_String names[],
[out,unique] lsa_RefDomainList *domains,
[in,out] lsa_TransSidArray3 *sids,
[in] uint16 level,
[in,out] uint32 *count,
[in] uint32 unknown1,
[in] uint32 unknown2
);
/* Function 0x4e */
NTSTATUS lsa_LSAROPENPOLICYSCE();
/* Function 0x4f */
NTSTATUS lsa_LSARADTREGISTERSECURITYEVENTSOURCE();
/* Function 0x50 */
NTSTATUS lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE();
/* Function 0x51 */
NTSTATUS lsa_LSARADTREPORTSECURITYEVENT();
}

47
source/librpc/idl/misc.idl Normal file
View File

@ -0,0 +1,47 @@
/*
miscellaneous IDL structures
*/
[
pointer_default(unique)
]
interface misc
{
typedef [public,noprint,gensize,noejs] struct {
uint32 time_low;
uint16 time_mid;
uint16 time_hi_and_version;
uint8 clock_seq[2];
uint8 node[6];
} GUID;
typedef [public] struct {
uint32 handle_type;
GUID uuid;
} policy_handle;
/* secure channel types */
/* Only SEC_CHAN_WKSTA can forward requests to other domains. */
typedef [public] enum {
SEC_CHAN_WKSTA = 2,
SEC_CHAN_DOMAIN = 4,
SEC_CHAN_BDC = 6
} netr_SchannelType;
/* SAM database types */
typedef [public,v1_enum] enum {
SAM_DATABASE_DOMAIN = 0, /* Domain users and groups */
SAM_DATABASE_BUILTIN = 1, /* BUILTIN users and groups */
SAM_DATABASE_PRIVS = 2 /* Privileges */
} netr_SamDatabaseID;
typedef [public,v1_enum] enum {
SAMR_REJECT_OTHER = 0,
SAMR_REJECT_TOO_SHORT = 1,
SAMR_REJECT_COMPLEXITY = 2
} samr_RejectReason;
}

1203
source/librpc/idl/netlogon.idl Normal file
View File

File diff suppressed because it is too large Load Diff

77
source/librpc/idl/ntsvcs.idl Normal file
View File

@ -0,0 +1,77 @@
/*
plug and play services
*/
[
uuid("8d9f4e40-a03d-11ce-8f69-08003e30051b"),
version(1.0),
helpstring("Plug and Play services")
]
interface ntsvcs
{
void PNP_Disconnect();
void PNP_Connect();
void PNP_GetVersion();
void PNP_GetGlobalState();
void PNP_InitDetection();
void PNP_ReportLogOn();
void PNP_ValidateDeviceInstance();
void PNP_GetRootDeviceInstance();
void PNP_GetRelatedDeviceInstance();
void PNP_EnumerateSubKeys();
void PNP_GetDeviceList();
void PNP_GetDeviceListSize();
void PNP_GetDepth();
void PNP_GetDeviceRegProp();
void PNP_SetDeviceRegProp();
void PNP_GetClassInstance();
void PNP_CreateKey();
void PNP_DeleteRegistryKey();
void PNP_GetClassCount();
void PNP_GetClassName();
void PNP_DeleteClassKey();
void PNP_GetInterfaceDeviceAlias();
void PNP_GetInterfaceDeviceList();
void PNP_GetInterfaceDeviceListSize();
void PNP_RegisterDeviceClassAssociation();
void PNP_UnregisterDeviceClassAssociation();
void PNP_GetClassRegProp();
void PNP_SetClassRegProp();
void PNP_CreateDevInst();
void PNP_DeviceInstanceAction();
void PNP_GetDeviceStatus();
void PNP_SetDeviceProblem();
void PNP_DisableDevInst();
void PNP_UninstallDevInst();
void PNP_AddID();
void PNP_RegisterDriver();
void PNP_QueryRemove();
void PNP_RequestDeviceEject();
void PNP_IsDockStationPresent();
void PNP_RequestEjectPC();
void PNP_HwProfFlags();
void PNP_GetHwProfInfo();
void PNP_AddEmptyLogConf();
void PNP_FreeLogConf();
void PNP_GetFirstLogConf();
void PNP_GetNextLogConf();
void PNP_GetLogConfPriority();
void PNP_AddResDes();
void PNP_FreeResDes();
void PNP_GetNextResDes();
void PNP_GetResDesData();
void PNP_GetResDesDataSize();
void PNP_ModifyResDes();
void PNP_DetectResourceLimit();
void PNP_QueryResConfList();
void PNP_SetHwProf();
void PNP_QueryArbitratorFreeData();
void PNP_QueryArbitratorFreeSize();
void PNP_RunDetection();
void PNP_RegisterNotification();
void PNP_UnregisterNotification();
void PNP_GetCustomDevProp();
void PNP_GetVersionInternal();
void PNP_GetBlockedDriverInfo();
void PNP_GetServerSideDeviceInstallFlags();
}

1235
source/librpc/idl/samr.idl Normal file
View File

File diff suppressed because it is too large Load Diff

355
source/librpc/idl/security.idl Normal file
View File

@ -0,0 +1,355 @@
#include "idl_types.h"
/*
security IDL structures
*/
[
pointer_default(unique),
depends(misc,security)
]
interface security
{
/*
access masks are divided up like this:
0xabccdddd
where
a = generic rights bits SEC_GENERIC_
b = flags SEC_FLAG_
c = standard rights bits SEC_STD_
d = object type specific bits SEC_{FILE,DIR,REG,xxx}_
common combinations of bits are prefixed with SEC_RIGHTS_
*/
const int SEC_MASK_GENERIC = 0xF0000000;
const int SEC_MASK_FLAGS = 0x0F000000;
const int SEC_MASK_STANDARD = 0x00FF0000;
const int SEC_MASK_SPECIFIC = 0x0000FFFF;
/* generic bits */
const int SEC_GENERIC_ALL = 0x10000000;
const int SEC_GENERIC_EXECUTE = 0x20000000;
const int SEC_GENERIC_WRITE = 0x40000000;
const int SEC_GENERIC_READ = 0x80000000;
/* flag bits */
const int SEC_FLAG_SYSTEM_SECURITY = 0x01000000;
const int SEC_FLAG_MAXIMUM_ALLOWED = 0x02000000;
/* standard bits */
const int SEC_STD_DELETE = 0x00010000;
const int SEC_STD_READ_CONTROL = 0x00020000;
const int SEC_STD_WRITE_DAC = 0x00040000;
const int SEC_STD_WRITE_OWNER = 0x00080000;
const int SEC_STD_SYNCHRONIZE = 0x00100000;
const int SEC_STD_REQUIRED = 0x000F0000;
const int SEC_STD_ALL = 0x001F0000;
/* file specific bits */
const int SEC_FILE_READ_DATA = 0x00000001;
const int SEC_FILE_WRITE_DATA = 0x00000002;
const int SEC_FILE_APPEND_DATA = 0x00000004;
const int SEC_FILE_READ_EA = 0x00000008;
const int SEC_FILE_WRITE_EA = 0x00000010;
const int SEC_FILE_EXECUTE = 0x00000020;
const int SEC_FILE_READ_ATTRIBUTE = 0x00000080;
const int SEC_FILE_WRITE_ATTRIBUTE = 0x00000100;
const int SEC_FILE_ALL = 0x000001ff;
/* directory specific bits */
const int SEC_DIR_LIST = 0x00000001;
const int SEC_DIR_ADD_FILE = 0x00000002;
const int SEC_DIR_ADD_SUBDIR = 0x00000004;
const int SEC_DIR_READ_EA = 0x00000008;
const int SEC_DIR_WRITE_EA = 0x00000010;
const int SEC_DIR_TRAVERSE = 0x00000020;
const int SEC_DIR_DELETE_CHILD = 0x00000040;
const int SEC_DIR_READ_ATTRIBUTE = 0x00000080;
const int SEC_DIR_WRITE_ATTRIBUTE = 0x00000100;
/* registry entry specific bits */
const int SEC_REG_QUERY_VALUE = 0x00000001;
const int SEC_REG_SET_VALUE = 0x00000002;
const int SEC_REG_CREATE_SUBKEY = 0x00000004;
const int SEC_REG_ENUM_SUBKEYS = 0x00000008;
const int SEC_REG_NOTIFY = 0x00000010;
const int SEC_REG_CREATE_LINK = 0x00000020;
/* ldap specific access bits */
const int SEC_ADS_CREATE_CHILD = 0x00000001;
const int SEC_ADS_DELETE_CHILD = 0x00000002;
const int SEC_ADS_LIST = 0x00000004;
const int SEC_ADS_SELF_WRITE = 0x00000008;
const int SEC_ADS_READ_PROP = 0x00000010;
const int SEC_ADS_WRITE_PROP = 0x00000020;
const int SEC_ADS_DELETE_TREE = 0x00000040;
const int SEC_ADS_LIST_OBJECT = 0x00000080;
const int SEC_ADS_CONTROL_ACCESS = 0x00000100;
/* generic->specific mappings for files */
const int SEC_RIGHTS_FILE_READ = SEC_STD_READ_CONTROL |
SEC_STD_SYNCHRONIZE |
SEC_FILE_READ_DATA |
SEC_FILE_READ_ATTRIBUTE |
SEC_FILE_READ_EA;
const int 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;
const int SEC_RIGHTS_FILE_EXECUTE = SEC_STD_SYNCHRONIZE |
SEC_STD_READ_CONTROL |
SEC_FILE_READ_ATTRIBUTE |
SEC_FILE_EXECUTE;
const int SEC_RIGHTS_FILE_ALL = SEC_STD_ALL | SEC_FILE_ALL;
/* generic->specific mappings for directories (same as files) */
const int SEC_RIGHTS_DIR_READ = SEC_RIGHTS_FILE_READ;
const int SEC_RIGHTS_DIR_WRITE = SEC_RIGHTS_FILE_WRITE;
const int SEC_RIGHTS_DIR_EXECUTE = SEC_RIGHTS_FILE_EXECUTE;
const int SEC_RIGHTS_DIR_ALL = SEC_RIGHTS_FILE_ALL;
/***************************************************************/
/* WELL KNOWN SIDS */
/* a NULL sid */
const string SID_NULL = "S-1-0-0";
/* the world domain */
const string SID_WORLD_DOMAIN = "S-1-1";
const string SID_WORLD = "S-1-1-0";
/* SECURITY_CREATOR_SID_AUTHORITY */
const string SID_CREATOR_OWNER_DOMAIN = "S-1-3";
const string SID_CREATOR_OWNER = "S-1-3-0";
const string SID_CREATOR_GROUP = "S-1-3-1";
/* SECURITY_NT_AUTHORITY */
const string SID_NT_AUTHORITY = "S-1-5";
const string SID_NT_DIALUP = "S-1-5-1";
const string SID_NT_NETWORK = "S-1-5-2";
const string SID_NT_BATCH = "S-1-5-3";
const string SID_NT_INTERACTIVE = "S-1-5-4";
const string SID_NT_SERVICE = "S-1-5-6";
const string SID_NT_ANONYMOUS = "S-1-5-7";
const string SID_NT_PROXY = "S-1-5-8";
const string SID_NT_ENTERPRISE_DCS = "S-1-5-9";
const string SID_NT_SELF = "S-1-5-10";
const string SID_NT_AUTHENTICATED_USERS = "S-1-5-11";
const string SID_NT_RESTRICTED = "S-1-5-12";
const string SID_NT_TERMINAL_SERVER_USERS = "S-1-5-13";
const string SID_NT_REMOTE_INTERACTIVE = "S-1-5-14";
const string SID_NT_THIS_ORGANISATION = "S-1-5-15";
const string SID_NT_SYSTEM = "S-1-5-18";
const string SID_NT_LOCAL_SERVICE = "S-1-5-19";
const string SID_NT_NETWORK_SERVICE = "S-1-5-20";
/* SECURITY_BUILTIN_DOMAIN_RID */
const string SID_BUILTIN = "S-1-5-32";
const string SID_BUILTIN_ADMINISTRATORS = "S-1-5-32-544";
const string SID_BUILTIN_USERS = "S-1-5-32-545";
const string SID_BUILTIN_GUESTS = "S-1-5-32-546";
const string SID_BUILTIN_POWER_USERS = "S-1-5-32-547";
const string SID_BUILTIN_ACCOUNT_OPERATORS = "S-1-5-32-548";
const string SID_BUILTIN_SERVER_OPERATORS = "S-1-5-32-549";
const string SID_BUILTIN_PRINT_OPERATORS = "S-1-5-32-550";
const string SID_BUILTIN_BACKUP_OPERATORS = "S-1-5-32-551";
const string SID_BUILTIN_REPLICATOR = "S-1-5-32-552";
const string SID_BUILTIN_RAS_SERVERS = "S-1-5-32-553";
const string SID_BUILTIN_PREW2K = "S-1-5-32-554";
/* well-known domain RIDs */
const int DOMAIN_RID_LOGON = 9;
const int DOMAIN_RID_ADMINISTRATOR = 500;
const int DOMAIN_RID_GUEST = 501;
const int DOMAIN_RID_ADMINS = 512;
const int DOMAIN_RID_USERS = 513;
const int DOMAIN_RID_DCS = 516;
const int DOMAIN_RID_CERT_ADMINS = 517;
const int DOMAIN_RID_SCHEMA_ADMINS = 518;
const int DOMAIN_RID_ENTERPRISE_ADMINS = 519;
/*
privilege IDs. Please keep the IDs below 64. If we get more
than 64 then we need to change security_token
*/
typedef enum {
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
} sec_privilege;
/* a domain SID. Note that unlike Samba3 this contains a pointer,
so you can't copy them using assignment */
typedef [public,gensize,noprint,noejs,nosize] struct {
uint8 sid_rev_num; /**< SID revision number */
[range(0,15)] int8 num_auths; /**< Number of sub-authorities */
uint8 id_auth[6]; /**< Identifier Authority */
uint32 sub_auths[num_auths];
} dom_sid;
typedef [bitmap8bit] bitmap {
SEC_ACE_FLAG_OBJECT_INHERIT = 0x01,
SEC_ACE_FLAG_CONTAINER_INHERIT = 0x02,
SEC_ACE_FLAG_NO_PROPAGATE_INHERIT = 0x04,
SEC_ACE_FLAG_INHERIT_ONLY = 0x08,
SEC_ACE_FLAG_INHERITED_ACE = 0x10,
SEC_ACE_FLAG_VALID_INHERIT = 0x0f,
SEC_ACE_FLAG_SUCCESSFUL_ACCESS = 0x40,
SEC_ACE_FLAG_FAILED_ACCESS = 0x80
} security_ace_flags;
typedef [enum8bit] enum {
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
} security_ace_type;
typedef bitmap {
SEC_ACE_OBJECT_TYPE_PRESENT = 0x00000001,
SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT = 0x00000002
} security_ace_object_flags;
typedef [nodiscriminant] union {
/* this is the 'schemaIDGUID' attribute of the attribute object in the schema naming context */
[case(SEC_ACE_OBJECT_TYPE_PRESENT)] GUID type;
[default];
} security_ace_object_type;
typedef [nodiscriminant] union {
/* this is the 'schemaIDGUID' attribute of the objectclass object in the schema naming context
* (of the parent container)
*/
[case(SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)] GUID inherited_type;
[default];
} security_ace_object_inherited_type;
typedef struct {
security_ace_object_flags flags;
[switch_is(flags & SEC_ACE_OBJECT_TYPE_PRESENT)] security_ace_object_type type;
[switch_is(flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)] security_ace_object_inherited_type inherited_type;
} security_ace_object;
typedef [nodiscriminant] union {
[case(SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT)] security_ace_object object;
[case(SEC_ACE_TYPE_ACCESS_DENIED_OBJECT)] security_ace_object object;
[case(SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT)] security_ace_object object;
[case(SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT)] security_ace_object object;
[default];
} security_ace_object_ctr;
typedef [public,gensize,nosize] struct {
security_ace_type type; /* SEC_ACE_TYPE_* */
security_ace_flags flags; /* SEC_ACE_FLAG_* */
[value(ndr_size_security_ace(r,ndr->flags))] uint16 size;
uint32 access_mask;
[switch_is(type)] security_ace_object_ctr object;
dom_sid trustee;
} security_ace;
typedef enum {
SECURITY_ACL_REVISION_NT4 = 2,
SECURITY_ACL_REVISION_ADS = 4
} security_acl_revision;
const uint NT4_ACL_REVISION = SECURITY_ACL_REVISION_NT4;
typedef [public,gensize,nosize] struct {
security_acl_revision revision;
[value(ndr_size_security_acl(r,ndr->flags))] uint16 size;
[range(0,1000)] uint32 num_aces;
security_ace aces[num_aces];
} security_acl;
/* default revision for new ACLs */
typedef [enum8bit] enum {
SECURITY_DESCRIPTOR_REVISION_1 = 1
} security_descriptor_revision;
const int SD_REVISION = SECURITY_DESCRIPTOR_REVISION_1;
/* security_descriptor->type bits */
typedef [bitmap16bit] bitmap {
SEC_DESC_OWNER_DEFAULTED = 0x0001,
SEC_DESC_GROUP_DEFAULTED = 0x0002,
SEC_DESC_DACL_PRESENT = 0x0004,
SEC_DESC_DACL_DEFAULTED = 0x0008,
SEC_DESC_SACL_PRESENT = 0x0010,
SEC_DESC_SACL_DEFAULTED = 0x0020,
SEC_DESC_DACL_TRUSTED = 0x0040,
SEC_DESC_SERVER_SECURITY = 0x0080,
SEC_DESC_DACL_AUTO_INHERIT_REQ = 0x0100,
SEC_DESC_SACL_AUTO_INHERIT_REQ = 0x0200,
SEC_DESC_DACL_AUTO_INHERITED = 0x0400,
SEC_DESC_SACL_AUTO_INHERITED = 0x0800,
SEC_DESC_DACL_PROTECTED = 0x1000,
SEC_DESC_SACL_PROTECTED = 0x2000,
SEC_DESC_RM_CONTROL_VALID = 0x4000,
SEC_DESC_SELF_RELATIVE = 0x8000
} security_descriptor_type;
typedef [gensize,nosize,public,flag(NDR_LITTLE_ENDIAN)] struct {
security_descriptor_revision revision;
security_descriptor_type type; /* SEC_DESC_xxxx flags */
[relative] dom_sid *owner_sid;
[relative] dom_sid *group_sid;
[relative] security_acl *sacl; /* system ACL */
[relative] security_acl *dacl; /* user (discretionary) ACL */
} security_descriptor;
typedef [public] struct {
[range(0,0x40000),value(ndr_size_security_descriptor(sd,ndr->flags))] uint32 sd_size;
[subcontext(4)] security_descriptor *sd;
} sec_desc_buf;
typedef [public] struct {
dom_sid *user_sid;
dom_sid *group_sid;
uint32 num_sids;
[size_is(num_sids)] dom_sid *sids[*];
udlong privilege_mask;
} security_token;
/* bits that determine which parts of a security descriptor
are being queried/set */
typedef [public,bitmap32bit] bitmap {
SECINFO_OWNER = 0x00000001,
SECINFO_GROUP = 0x00000002,
SECINFO_DACL = 0x00000004,
SECINFO_SACL = 0x00000008
} security_secinfo;
}

1417
source/librpc/idl/spoolss.idl Normal file
View File

File diff suppressed because it is too large Load Diff

1504
source/librpc/idl/srvsvc.idl Normal file
View File

File diff suppressed because it is too large Load Diff

446
source/librpc/idl/svcctl.idl Normal file
View File

@ -0,0 +1,446 @@
#include "idl_types.h"
/*
svcctl interface definitions
*/
[ uuid("367abb81-9844-35f1-ad32-98f038001003"),
version(2.0),
pointer_default(unique),
pointer_default_top(unique),
endpoint("ncacn_np:[\\pipe\\svcctl]", "ncalrpc:"),
helpstring("Service Control"),
keepref
] interface svcctl
{
typedef struct {
uint32 is_locked;
[string,charset(UTF16)] uint16 *lock_owner;
uint32 lock_duration;
} SERVICE_LOCK_STATUS;
typedef struct {
uint32 type;
uint32 state;
uint32 controls_accepted;
uint32 win32_exit_code;
uint32 service_exit_code;
uint32 check_point;
uint32 wait_hint;
} SERVICE_STATUS;
typedef struct {
[relative] astring *service_name;
[relative] astring *display_name;
SERVICE_STATUS status;
} ENUM_SERVICE_STATUS;
const int SERVICE_TYPE_KERNEL_DRIVER = 0x01;
const int SERVICE_TYPE_FS_DRIVER = 0x02;
const int SERVICE_TYPE_ADAPTER = 0x04;
const int SERVICE_TYPE_RECOGNIZER_DRIVER = 0x08;
const int SERVICE_TYPE_DRIVER=SERVICE_TYPE_KERNEL_DRIVER|SERVICE_TYPE_FS_DRIVER|SERVICE_TYPE_RECOGNIZER_DRIVER;
const int SERVICE_TYPE_WIN32_OWN_PROCESS = 0x10;
const int SERVICE_TYPE_WIN32_SHARE_PROCESS = 0x20;
const int SERVICE_TYPE_WIN32=SERVICE_TYPE_WIN32_OWN_PROCESS|SERVICE_TYPE_WIN32_SHARE_PROCESS;
const int SERVICE_STATE_ACTIVE = 0x01;
const int SERVICE_STATE_INACTIVE = 0x02;
const int SERVICE_STATE_ALL = 0x03;
typedef [public,bitmap32bit] bitmap {
SV_TYPE_WORKSTATION = 0x00000001,
SV_TYPE_SERVER = 0x00000002,
SV_TYPE_SQLSERVER = 0x00000004,
SV_TYPE_DOMAIN_CTRL = 0x00000008,
SV_TYPE_DOMAIN_BAKCTRL = 0x00000010,
SV_TYPE_TIME_SOURCE = 0x00000020,
SV_TYPE_AFP = 0x00000040,
SV_TYPE_NOVELL = 0x00000080,
SV_TYPE_DOMAIN_MEMBER = 0x00000100,
SV_TYPE_PRINTQ_SERVER = 0x00000200,
SV_TYPE_DIALIN_SERVER = 0x00000400,
SV_TYPE_SERVER_UNIX = 0x00000800,
SV_TYPE_NT = 0x00001000,
SV_TYPE_WFW = 0x00002000,
SV_TYPE_SERVER_MFPN = 0x00004000,
SV_TYPE_SERVER_NT = 0x00008000,
SV_TYPE_POTENTIAL_BROWSER = 0x00010000,
SV_TYPE_BACKUP_BROWSER = 0x00020000,
SV_TYPE_MASTER_BROWSER = 0x00040000,
SV_TYPE_DOMAIN_MASTER = 0x00080000,
SV_TYPE_SERVER_OSF = 0x00100000,
SV_TYPE_SERVER_VMS = 0x00200000,
SV_TYPE_WIN95_PLUS = 0x00400000,
SV_TYPE_DFS_SERVER = 0x00800000,
SV_TYPE_ALTERNATE_XPORT = 0x20000000,
SV_TYPE_LOCAL_LIST_ONLY = 0x40000000,
SV_TYPE_DOMAIN_ENUM = 0x80000000
} svcctl_ServerType;
const uint32 SV_TYPE_ALL = 0xFFFFFFFF;
/*****************/
/* Function 0x00 */
WERROR svcctl_CloseServiceHandle(
[in,out,ref] policy_handle *handle
);
/*****************/
/* Function 0x01 */
typedef enum {
FIXME=1
} SERVICE_CONTROL;
WERROR svcctl_ControlService(
[in,ref] policy_handle *handle,
[in] uint32 control,
[out,ref] SERVICE_STATUS *status
);
/*****************/
/* Function 0x02 */
WERROR svcctl_DeleteService([in,ref] policy_handle *handle);
/*****************/
/* Function 0x03 */
WERROR svcctl_LockServiceDatabase(
[in,ref] policy_handle *handle,
[out] policy_handle lock
);
/*****************/
/* Function 0x04 */
WERROR svcctl_QueryServiceObjectSecurity();
/*****************/
/* Function 0x05 */
WERROR svcctl_SetServiceObjectSecurity();
/*****************/
/* Function 0x06 */
WERROR svcctl_QueryServiceStatus(
[in,ref] policy_handle *handle,
[out,ref] SERVICE_STATUS *status);
/*****************/
/* Function 0x07 */
WERROR svcctl_SetServiceStatus();
/*****************/
/* Function 0x08 */
WERROR svcctl_UnlockServiceDatabase(
[in,out,ref] policy_handle *lock
);
/*****************/
/* Function 0x09 */
WERROR svcctl_NotifyBootConfigStatus();
/*****************/
/* Function 0x0a */
WERROR svcctl_SCSetServiceBitsW(
[in,ref] policy_handle *handle,
[in] uint32 bits,
[in] boolean32 bitson,
[in] boolean32 immediate);
/*****************/
/* Function 0x0b */
WERROR svcctl_ChangeServiceConfigW([in,ref] policy_handle *handle,
[in] uint32 type,
[in] uint32 start,
[in] uint32 error,
[in] [string,charset(UTF16)] uint16 *binary_path,
[in] [string,charset(UTF16)] uint16 *load_order_group,
[out] uint32 tag_id,
[in] [string,charset(UTF16)] uint16 *dependencies,
[in] [string,charset(UTF16)] uint16 *service_start_name,
[in] [string,charset(UTF16)] uint16 *password,
[in] [string,charset(UTF16)] uint16 *display_name);
/*****************/
/* Function 0x0c */
WERROR svcctl_CreateServiceW([in,ref] policy_handle *scmanager_handle,
[in] [string,charset(UTF16)] uint16 ServiceName[],
[in] [string,charset(UTF16)] uint16 *DisplayName,
[in] uint32 desired_access,
[in] uint32 type,
[in] uint32 start_type,
[in] uint32 error_control,
[in] [string,charset(UTF16)] uint16 binary_path[],
[in] [string,charset(UTF16)] uint16 *LoadOrderGroupKey,
[in,out] uint32 *TagId,
[in,size_is(dependencies_size)] uint8 *dependencies,
[in] uint32 dependencies_size,
[in] [string,charset(UTF16)] uint16 *service_start_name,
[in,size_is(password_size)] uint8 *password,
[in] uint32 password_size,
[out,ref] policy_handle *handle);
/*****************/
/* Function 0x0d */
WERROR svcctl_EnumDependentServicesW([in,ref] policy_handle *service,
[in] uint32 state,
[out] ENUM_SERVICE_STATUS *status,
[in] uint32 buf_size,
[out] uint32 bytes_needed,
[out] uint32 services_returned);
/*****************/
/* Function 0x0e */
WERROR svcctl_EnumServicesStatusW(
[in,ref] policy_handle *handle,
[in] uint32 type,
[in] uint32 state,
[in] uint32 buf_size,
[out,size_is(buf_size)] uint8 service[*],
[out] uint32 bytes_needed,
[out] uint32 services_returned,
[in,out] uint32 *resume_handle
);
/*****************/
/* Function 0x0f */
WERROR svcctl_OpenSCManagerW(
[in] [string,charset(UTF16)] uint16 *MachineName,
[in] [string,charset(UTF16)] uint16 *DatabaseName,
[in] uint32 access_mask,
[out,ref] policy_handle *handle);
/*****************/
/* Function 0x10 */
WERROR svcctl_OpenServiceW([in,ref] policy_handle *scmanager_handle,
[in] [string,charset(UTF16)] uint16 ServiceName[],
[in] uint32 access_mask,
[out,ref] policy_handle *handle);
/*****************/
/* Function 0x11 */
WERROR svcctl_QueryServiceConfigW([in,ref] policy_handle *handle,
[out] uint8 query[buf_size], /*QUERY_SERVICE_CONFIG */
[in] uint32 buf_size,
[out] uint32 bytes_needed
);
/*****************/
/* Function 0x12 */
WERROR svcctl_QueryServiceLockStatusW(
[in,ref] policy_handle *handle,
[in] uint32 buf_size,
[out,ref] SERVICE_LOCK_STATUS *status,
[out,ref] uint32 *required_buf_size
);
/*****************/
/* Function 0x13 */
WERROR svcctl_StartServiceW(
[in,ref] policy_handle *handle,
[in] uint32 NumArgs,
[in,length_is(NumArgs)] [string,charset(UTF16)] uint16 *Arguments);
/*****************/
/* Function 0x14 */
WERROR svcctl_GetServiceDisplayNameW([in,ref] policy_handle *handle,
[in] [string,charset(UTF16)] uint16 *service_name,
[out] [string,charset(UTF16)] uint16 *display_name,
[in,out] uint32 *display_name_length);
/*****************/
/* Function 0x15 */
WERROR svcctl_GetServiceKeyNameW([in,ref] policy_handle *handle,
[in] [string,charset(UTF16)] uint16 *service_name,
[out] [string,charset(UTF16)] uint16 *key_name,
[in,out] uint32 *display_name_length);
/*****************/
/* Function 0x16 */
WERROR svcctl_SCSetServiceBitsA(
[in,ref] policy_handle *handle,
[in] uint32 bits,
[in] boolean32 bitson,
[in] boolean32 immediate);
/*****************/
/* Function 0x17 */
WERROR svcctl_ChangeServiceConfigA([in,ref] policy_handle *handle,
[in] uint32 type,
[in] uint32 start,
[in] uint32 error,
[in] [string,charset(UTF16)] uint16 *binary_path,
[in] [string,charset(UTF16)] uint16 *load_order_group,
[out] uint32 tag_id,
[in] [string,charset(UTF16)] uint16 *dependencies,
[in] [string,charset(UTF16)] uint16 *service_start_name,
[in] [string,charset(UTF16)] uint16 *password,
[in] [string,charset(UTF16)] uint16 *display_name);
/*****************/
/* Function 0x18 */
WERROR svcctl_CreateServiceA([in,ref] policy_handle *handle,
[in] [string,charset(UTF16)] uint16 *ServiceName,
[in] [string,charset(UTF16)] uint16 *DisplayName,
[in] uint32 desired_access,
[in] uint32 type,
[in] uint32 start_type,
[in] uint32 error_control,
[in] [string,charset(UTF16)] uint16 *binary_path,
[in] [string,charset(UTF16)] uint16 *LoadOrderGroupKey,
[out] uint32 *TagId,
[in] [string,charset(UTF16)] uint16 *dependencies,
[in] [string,charset(UTF16)] uint16 *service_start_name,
[in] [string,charset(UTF16)] uint16 *password);
/*****************/
/* Function 0x19 */
WERROR svcctl_EnumDependentServicesA([in,ref] policy_handle *service,
[in] uint32 state,
[out] ENUM_SERVICE_STATUS *status,
[in] uint32 buf_size,
[out] uint32 bytes_needed,
[out] uint32 services_returned);
/*****************/
/* Function 0x1a */
WERROR svcctl_EnumServicesStatusA(
[in,ref] policy_handle *handle,
[in] uint32 type,
[in] uint32 state,
[in] uint32 buf_size,
[out,size_is(buf_size)] uint8 service[*],
[out] uint32 bytes_needed,
[out] uint32 services_returned,
[in,out] uint32 *resume_handle
);
/*****************/
/* Function 0x1b */
WERROR svcctl_OpenSCManagerA(
[in] [string,charset(UTF16)] uint16 *MachineName,
[in] [string,charset(UTF16)] uint16 *DatabaseName,
[in] uint32 access_mask,
[out,ref] policy_handle *handle);
/*****************/
/* Function 0x1c */
WERROR svcctl_OpenServiceA([in,ref] policy_handle *scmanager_handle,
[in] [string,charset(UTF16)] uint16 *ServiceName,
[in] uint32 access_mask);
/*****************/
/* Function 0x1d */
WERROR svcctl_QueryServiceConfigA([in,ref] policy_handle *handle,
[out] uint8 query[buf_size], /*QUERYU_SERVICE_CONFIG */
[in] uint32 buf_size,
[out] uint32 bytes_needed
);
/*****************/
/* Function 0x1e */
WERROR svcctl_QueryServiceLockStatusA(
[in,ref] policy_handle *handle,
[in] uint32 buf_size,
[out,ref] SERVICE_LOCK_STATUS *status,
[out,ref] uint32 *required_buf_size
);
/*****************/
/* Function 0x1f */
WERROR svcctl_StartServiceA(
[in,ref] policy_handle *handle,
[in] uint32 NumArgs,
[in,length_is(NumArgs)] [string,charset(UTF16)] uint16 *Arguments);
/*****************/
/* Function 0x20 */
WERROR svcctl_GetServiceDisplayNameA([in,ref] policy_handle *handle,
[in] [string,charset(UTF16)] uint16 *service_name,
[out] [string,charset(UTF16)] uint16 *display_name,
[in,out] uint32 *display_name_length);
/*****************/
/* Function 0x21 */
WERROR svcctl_GetServiceKeyNameA([in,ref] policy_handle *handle,
[in] [string,charset(UTF16)] uint16 *service_name,
[out] [string,charset(UTF16)] uint16 *key_name,
[in,out] uint32 *display_name_length);
/*****************/
/* Function 0x22 */
WERROR svcctl_GetCurrentGroupeStateW();
/*****************/
/* Function 0x23 */
WERROR svcctl_EnumServiceGroupW();
/*****************/
/* Function 0x24 */
WERROR svcctl_ChangeServiceConfig2A([in,ref] policy_handle *handle,
[in] uint32 info_level,
[in] uint8 *info
);
/*****************/
/* Function 0x25 */
WERROR svcctl_ChangeServiceConfig2W([in,ref] policy_handle *handle,
[in] uint32 info_level,
[in] uint8 *info);
/*****************/
/* Function 0x26 */
WERROR svcctl_QueryServiceConfig2A(
[in,ref] policy_handle *handle,
[in] uint32 info_level,
[out] uint8 buffer[buf_size],
[in] uint32 buf_size,
[out] uint32 bytes_needed);
/*****************/
/* Function 0x27 */
WERROR svcctl_QueryServiceConfig2W(
[in,ref] policy_handle *handle,
[in] uint32 info_level,
[out] uint8 buffer[buf_size],
[in] uint32 buf_size,
[out] uint32 bytes_needed);
/*****************/
/* Function 0x28 */
WERROR svcctl_QueryServiceStatusEx(
[in,ref] policy_handle *handle,
[in] uint32 info_level,
[out] uint8 buffer[buf_size],
[in] uint32 buf_size,
[out] uint32 bytes_needed);
/*****************/
/* Function 0x29 */
WERROR EnumServicesStatusExA(
[in,ref] policy_handle *scmanager,
[in] uint32 info_level,
[in] uint32 type,
[in] uint32 state,
[out] uint8 services[buf_size],
[in] uint32 buf_size,
[out] uint32 bytes_needed,
[out] uint32 service_returned,
[in,out] uint32 *resume_handle,
[out] [string,charset(UTF16)] uint16 *group_name);
/*****************/
/* Function 0x2a */
WERROR EnumServicesStatusExW(
[in,ref] policy_handle *scmanager,
[in] uint32 info_level,
[in] uint32 type,
[in] uint32 state,
[out] uint8 services[buf_size],
[in] uint32 buf_size,
[out] uint32 bytes_needed,
[out] uint32 service_returned,
[in,out] uint32 *resume_handle,
[out] [string,charset(UTF16)] uint16 *group_name);
/*****************/
/* Function 0x2b */
WERROR svcctl_SCSendTSMessage();
}

55
source/librpc/idl/unixinfo.idl Normal file
View File

@ -0,0 +1,55 @@
/*
Unixinfo interface definition
*/
[ uuid("9c54e310-a955-4885-bd31-78787147dfa6"),
version(0.0),
endpoint("ncacn_np:[\\pipe\\unixinfo]", "ncacn_ip_tcp:", "ncalrpc:"),
pointer_default(unique),
helpstring("Unixinfo specific stuff"),
depends(security),
keepref
] interface unixinfo
{
/******************/
/* Function: 0x00 */
NTSTATUS unixinfo_SidToUid (
[in] dom_sid sid,
[out,ref] hyper *uid
);
/******************/
/* Function: 0x01 */
NTSTATUS unixinfo_UidToSid (
[in] hyper uid,
[out] dom_sid *sid
);
/******************/
/* Function: 0x02 */
NTSTATUS unixinfo_SidToGid (
[in] dom_sid sid,
[out,ref] hyper *gid
);
/******************/
/* Function: 0x03 */
NTSTATUS unixinfo_GidToSid (
[in] hyper gid,
[out,ref] dom_sid *sid
);
typedef struct {
NTSTATUS status;
[string,charset(UTF8)] uint8 *homedir;
[string,charset(UTF8)] uint8 *shell;
} unixinfo_GetPWUidInfo;
/******************/
/* Function: 0x04 */
NTSTATUS unixinfo_GetPWUid (
[in,out,ref,range(0,1023)] uint32 *count,
[in,size_is(*count)] hyper uids[],
[out,size_is(*count)] unixinfo_GetPWUidInfo *infos
);
}

362
source/librpc/idl/winreg.idl Normal file
View File

@ -0,0 +1,362 @@
/*
winreg interface definition
*/
[
uuid("338cd001-2244-31f1-aaaa-900038001003"),
version(1.0),
endpoint("ncacn_np:[\\pipe\\winreg]","ncacn_ip_tcp:","ncalrpc:"),
pointer_default(unique),
pointer_default_top(unique),
helpstring("Remote Registry Service"),
depends(lsa,initshutdown,security),
keepref
] interface winreg
{
declare bitmap security_secinfo;
typedef [v1_enum] enum {
REG_NONE = 0,
REG_SZ = 1,
REG_EXPAND_SZ = 2,
REG_BINARY = 3,
REG_DWORD = 4,
REG_DWORD_BIG_ENDIAN = 5,
REG_LINK = 6,
REG_MULTI_SZ = 7,
REG_RESOURCE_LIST = 8,
REG_FULL_RESOURCE_DESCRIPTOR = 9,
REG_RESOURCE_REQUIREMENTS_LIST = 10,
REG_QWORD = 11
} winreg_Type;
typedef [public,noejs] struct {
[value(strlen_m_term(name)*2)] uint16 name_len;
[value(strlen_m_term(name)*2)] uint16 name_size;
[string,charset(UTF16)] uint16 *name;
} winreg_String;
/******************/
/* Function: 0x00 */
WERROR winreg_OpenHKCR(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x01 */
WERROR winreg_OpenHKCU(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x02 */
WERROR winreg_OpenHKLM(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x03 */
WERROR winreg_OpenHKPD(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x04 */
WERROR winreg_OpenHKU(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x05 */
WERROR winreg_CloseKey(
[in,out,ref] policy_handle *handle
);
/******************/
/* Function: 0x06 */
typedef struct {
[size_is(size),length_is(len)] uint8 *data;
uint32 size;
uint32 len;
} KeySecurityData;
typedef struct {
uint32 length;
KeySecurityData sd;
boolean8 inherit;
} winreg_SecBuf;
typedef [v1_enum] enum {
REG_ACTION_NONE = 0, /* used by caller */
REG_CREATED_NEW_KEY = 1,
REG_OPENED_EXISTING_KEY = 2
} winreg_CreateAction;
WERROR winreg_CreateKey(
[in,ref] policy_handle *handle,
[in] winreg_String name,
[in] winreg_String class,
[in] uint32 options,
[in] uint32 access_mask,
[in,unique] winreg_SecBuf *secdesc,
[out,ref] policy_handle *new_handle,
[in,out,unique] winreg_CreateAction *action_taken
);
/******************/
/* Function: 0x07 */
WERROR winreg_DeleteKey(
[in,ref] policy_handle *handle,
[in] winreg_String key
);
/******************/
/* Function: 0x08 */
WERROR winreg_DeleteValue(
[in,ref] policy_handle *handle,
[in] winreg_String value
);
typedef struct {
[value(strlen_m_term(name)*2)] uint16 length;
/* size cannot be auto-set by value() as it is the
amount of space the server is allowed to use for this
string in the reply, not its current size */
uint16 size;
[size_is(size/2),length_is(length/2),charset(UTF16)] uint16 *name;
} winreg_StringBuf;
WERROR winreg_EnumKey(
[in,ref] policy_handle *handle,
[in] uint32 enum_index,
[in,out,ref] winreg_StringBuf *name,
[in,out,unique] winreg_StringBuf *class,
[in,out,unique] NTTIME *last_changed_time
);
/******************/
/* Function: 0x0a */
WERROR winreg_EnumValue(
[in,ref] policy_handle *handle,
[in] uint32 enum_index,
[in,out,ref] winreg_StringBuf *name,
[in,out,unique] winreg_Type *type,
[in,out,unique,size_is(*size),length_is(*length)] uint8 *value,
[in,out,unique] uint32 *size,
[in,out,unique] uint32 *length
);
/******************/
/* Function: 0x0b */
WERROR winreg_FlushKey(
[in,ref] policy_handle *handle
);
/******************/
/* Function: 0x0c */
WERROR winreg_GetKeySecurity(
[in,ref] policy_handle *handle,
[in] security_secinfo sec_info,
[in,out,ref] KeySecurityData *sd
);
/******************/
/* Function: 0x0d */
WERROR winreg_LoadKey(
[in,ref] policy_handle *handle,
[in] winreg_String *keyname,
[in] winreg_String *filename
);
/******************/
/* Function: 0x0e */
WERROR winreg_NotifyChangeKeyValue(
[in,ref] policy_handle *handle,
[in] uint8 watch_subtree,
[in] uint32 notify_filter,
[in] uint32 unknown,
[in] winreg_String string1,
[in] winreg_String string2,
[in] uint32 unknown2
);
/******************/
/* Function: 0x0f */
WERROR winreg_OpenKey(
[in,ref] policy_handle *handle,
[in] winreg_String keyname,
[in] uint32 unknown,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x10 */
WERROR winreg_QueryInfoKey(
[in,ref] policy_handle *handle,
[in] winreg_String class_in,
[out] winreg_String *class_out,
[out] uint32 num_subkeys,
[out] uint32 max_subkeylen,
[out] uint32 max_subkeysize,
[out] uint32 num_values,
[out] uint32 max_valnamelen,
[out] uint32 max_valbufsize,
[out] uint32 secdescsize,
[out] NTTIME last_changed_time
);
/******************/
/* Function: 0x11 */
WERROR winreg_QueryValue(
[in,ref] policy_handle *handle,
[in] winreg_String value_name,
[in,out] winreg_Type *type,
[in,out,size_is(*size),length_is(*length)] uint8 *data,
[in,out] uint32 *size,
[in,out] uint32 *length
);
/******************/
/* Function: 0x12 */
WERROR winreg_ReplaceKey(
);
/******************/
/* Function: 0x13 */
WERROR winreg_RestoreKey(
);
/******************/
/* Function: 0x14 */
WERROR winreg_SaveKey(
);
/******************/
/* Function: 0x15 */
WERROR winreg_SetKeySecurity(
[in,ref] policy_handle *handle,
[in] uint32 access_mask,
[in,out,ref] KeySecurityData *data
);
/******************/
/* Function: 0x16 */
WERROR winreg_SetValue(
[in,ref] policy_handle *handle,
[in] winreg_String name,
[in] winreg_Type type,
[in,size_is(size),ref] uint8 *data,
[in] uint32 size
);
/******************/
/* Function: 0x17 */
WERROR winreg_UnLoadKey(
);
/******************/
/* Function: 0x18 */
WERROR winreg_InitiateSystemShutdown(
[in] uint16 *hostname,
[in] initshutdown_String *message,
[in] uint32 timeout,
[in] uint8 force_apps,
[in] uint8 reboot
);
/******************/
/* Function: 0x19 */
WERROR winreg_AbortSystemShutdown(
[in] uint16 *server
);
/******************/
/* Function: 0x1a */
WERROR winreg_GetVersion(
[in,ref] policy_handle *handle,
[out] uint32 version
);
/******************/
/* Function: 0x1b */
WERROR winreg_OpenHKCC(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x1c */
WERROR winreg_OpenHKDD(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
typedef struct {
winreg_String *name;
winreg_Type type;
uint32 offset;
uint32 length;
} QueryMultipleValue;
/******************/
/* Function: 0x1d */
WERROR winreg_QueryMultipleValues(
[in,ref] policy_handle *key_handle,
[in,out,ref,size_is(num_values),length_is(num_values)] QueryMultipleValue *values,
[in] uint32 num_values,
[in,out,size_is(*buffer_size),length_is(*buffer_size)] uint8 *buffer,
[in,out,ref] uint32 *buffer_size
);
/******************/
/* Function: 0x1e */
WERROR winreg_InitiateSystemShutdownEx(
[in] uint16 *hostname,
[in] initshutdown_String *message,
[in] uint32 timeout,
[in] uint8 force_apps,
[in] uint8 reboot,
[in] uint32 reason
);
/******************/
/* Function: 0x1f */
WERROR winreg_SaveKeyEx(
);
/******************/
/* Function: 0x20 */
WERROR winreg_OpenHKPT(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x21 */
WERROR winreg_OpenHKPN(
[in] uint16 *system_name,
[in] uint32 access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x22 */
WERROR winreg_QueryMultipleValues2(
);
}

394
source/librpc/idl/wkssvc.idl Normal file
View File

@ -0,0 +1,394 @@
/*
wkssvc interface definitions
*/
[ uuid("6bffd098-a112-3610-9833-46c3f87e345a"),
version(1.0),
pointer_default(unique),
pointer_default_top(unique),
helpstring("Workstation Service"),
depends(srvsvc),
keepref
] interface wkssvc
{
declare [v1_enum] enum srvsvc_PlatformId;
#define BOOL uint32
/******************/
/* Function: 0x00 */
typedef struct {
srvsvc_PlatformId platform_id;
[string,charset(UTF16)] uint16 *server_name;
[string,charset(UTF16)] uint16 *domain_name;
uint32 version_major;
uint32 version_minor;
} wkssvc_NetWkstaInfo100;
typedef struct {
srvsvc_PlatformId platform_id;
[string,charset(UTF16)] uint16 *server_name;
[string,charset(UTF16)] uint16 *domain_name;
uint32 version_major;
uint32 version_minor;
[string,charset(UTF16)] uint16 *lan_root;
} wkssvc_NetWkstaInfo101;
typedef struct {
srvsvc_PlatformId platform_id;
[string,charset(UTF16)] uint16 *server_name;
[string,charset(UTF16)] uint16 *domain_name;
uint32 version_major;
uint32 version_minor;
[string,charset(UTF16)] uint16 *lan_root;
uint32 logged_on_users;
} wkssvc_NetWkstaInfo102;
typedef struct {
uint32 char_wait;
uint32 collection_time;
uint32 maximum_collection_count;
uint32 keep_connection;
uint32 max_commands;
uint32 session_timeout;
uint32 size_char_buf;
uint32 max_threads;
uint32 lock_quota;
uint32 lock_increment;
uint32 lock_maximum;
uint32 pipe_increment;
uint32 pipe_maximum;
uint32 cache_file_timeout;
uint32 dormant_file_limit;
uint32 read_ahead_throughput;
uint32 num_mailslot_buffers;
uint32 num_srv_announce_buffers;
uint32 max_illegal_dgram_events;
uint32 dgram_event_reset_freq;
BOOL log_election_packets;
BOOL use_opportunistic_locking;
BOOL use_unlock_behind;
BOOL use_close_behind;
BOOL buf_named_pipes;
BOOL use_lock_read_unlock;
BOOL utilize_nt_caching;
BOOL use_raw_read;
BOOL use_raw_write;
BOOL use_write_raw_data;
BOOL use_encryption;
BOOL buf_files_deny_write;
BOOL buf_read_only_files;
BOOL force_core_create_mode;
BOOL use_512_byte_max_transfer;
} wkssvc_NetWkstaInfo502;
typedef struct {
uint32 char_wait;
} wkssvc_NetWkstaInfo1010;
typedef struct {
uint32 collection_time;
} wkssvc_NetWkstaInfo1011;
typedef struct {
uint32 maximum_collection_count;
} wkssvc_NetWkstaInfo1012;
typedef struct {
uint32 keep_connection;
} wkssvc_NetWkstaInfo1013;
typedef struct {
uint32 session_timeout;
} wkssvc_NetWkstaInfo1018;
typedef struct {
uint32 size_char_buf;
} wkssvc_NetWkstaInfo1023;
typedef struct {
uint32 errorlog_sz;
} wkssvc_NetWkstaInfo1027;
typedef struct {
uint32 max_threads;
} wkssvc_NetWkstaInfo1033;
typedef union {
[case(100)] wkssvc_NetWkstaInfo100 *info100;
[case(101)] wkssvc_NetWkstaInfo101 *info101;
[case(102)] wkssvc_NetWkstaInfo102 *info102;
[case(502)] wkssvc_NetWkstaInfo502 *info502;
[case(1010)] wkssvc_NetWkstaInfo1010 *info1010;
[case(1011)] wkssvc_NetWkstaInfo1011 *info1011;
[case(1012)] wkssvc_NetWkstaInfo1012 *info1012;
[case(1013)] wkssvc_NetWkstaInfo1013 *info1013;
[case(1018)] wkssvc_NetWkstaInfo1018 *info1018;
[case(1023)] wkssvc_NetWkstaInfo1023 *info1023;
[case(1027)] wkssvc_NetWkstaInfo1027 *info1027;
[case(1033)] wkssvc_NetWkstaInfo1033 *info1033;
[default] ;
} wkssvc_NetWkstaInfo;
WERROR wkssvc_NetWkstaGetInfo(
[in] [string,charset(UTF16)] uint16 *server_name,
[in] uint32 level,
[out,switch_is(level),ref] wkssvc_NetWkstaInfo *info
);
/******************/
/* Function: 0x01 */
WERROR wkssvc_NetWkstaSetInfo(
[in] [string,charset(UTF16)] uint16 *server_name,
[in] uint32 level,
[in,switch_is(level),ref] wkssvc_NetWkstaInfo *info,
[in,out,ref] uint32 *parm_error
);
/*****************************/
/* Function 0x02 */
typedef struct {
[string,charset(UTF16)] uint16 *user;
} USER_INFO_0;
typedef struct {
uint32 entries_read;
[size_is(entries_read)] USER_INFO_0 *user0;
} USER_INFO_0_CONTAINER;
typedef struct {
[string,charset(UTF16)] uint16 *user_name;
[string,charset(UTF16)] uint16 *logon_domain;
[string,charset(UTF16)] uint16 *other_domains;
[string,charset(UTF16)] uint16 *logon_server;
} USER_INFO_1;
typedef struct {
uint32 entries_read;
[size_is(entries_read)] USER_INFO_1 *user1;
} USER_INFO_1_CONTAINER;
typedef [switch_type(uint32)] union {
[case(0)] USER_INFO_0_CONTAINER *user0;
[case(1)] USER_INFO_1_CONTAINER *user1;
} WKS_USER_ENUM_UNION;
WERROR wkssvc_NetWkstaEnumUsers(
[in] [string,charset(UTF16)] uint16 *server_name,
[in] uint32 level,
[in] [out] [ref] WKS_USER_ENUM_UNION *users,
[in] uint32 prefmaxlen,
[out] uint32 *entriesread,
[out] uint32 *totalentries,
[in] [out] [ref] uint32 *resumehandle
);
/*****************************/
/* Function 0x03 */
WERROR WKSSVC_NETRWKSTAUSERGETINFO ();
/*****************************/
/* Function 0x04 */
WERROR WKSSVC_NETRWKSTAUSERSETINFO ();
/*****************************/
/* Function 0x05 */
typedef struct {
uint32 quality_of_service;
uint32 vc_count;
[string,charset(UTF16)] uint16 *name;
[string,charset(UTF16)] uint16 *address;
uint32 wan_link;
} wkssvc_NetWkstaTransportInfo0;
typedef struct {
uint32 count;
[size_is(count)] wkssvc_NetWkstaTransportInfo0 *array;
} wkssvc_NetWkstaTransportCtr0;
typedef union {
[case(0)] wkssvc_NetWkstaTransportCtr0 *ctr0;
[default] ;
} wkssvc_NetWkstaTransportCtr;
WERROR wkssvc_NetWkstaTransportEnum (
[in] [string,charset(UTF16)] uint16 *server_name,
[in,out] uint32 level,
[in,out,switch_is(level),ref] wkssvc_NetWkstaTransportCtr *ctr,
[in] uint32 max_buffer,
[out] uint32 totalentries,
[in,out] uint32 *resume_handle
);
/*****************************/
/* Function 0x06 */
WERROR WKSSVC_NETRWKSTATRANSPORTADD ();
/*****************************/
/* Function 0x07 */
WERROR WKSSVC_NETRWKSTATRANSPORTDEL ();
/*****************************/
/* Function 0x08 */
WERROR WKSSVC_NETRUSEADD ();
/*****************************/
/* Function 0x09 */
WERROR WKSSVC_NETRUSEGETINFO ();
/*****************************/
/* Function 0x0a */
WERROR WKSSVC_NETRUSEDEL ();
/*****************************/
/* Function 0x0b */
WERROR WKSSVC_NETRUSEENUM ();
/*****************************/
/* Function 0x0c */
WERROR WKSSVC_NETRMESSAGEBUFFERSEND ();
/*****************************/
/* Function 0x0d */
WERROR WKSSVC_NETRWORKSTATIONSTATISTICSGET ();
/*****************************/
/* Function 0x0e */
WERROR WKSSVC_NETRLOGONDOMAINNAMEADD ();
/*****************************/
/* Function 0x0f */
WERROR WKSSVC_NETRLOGONDOMAINNAMEDEL ();
/*****************************/
/* Function 0x10 */
WERROR WKSSVC_NETRJOINDOMAIN ();
/*****************************/
/* Function 0x11 */
WERROR WKSSVC_NETRUNJOINDOMAIN ();
/*****************************/
/* Function 0x12 */
WERROR WKSSVC_NETRRENAMEMACHINEINDOMAIN ();
/*****************************/
/* Function 0x13 */
WERROR WKSSVC_NETRVALIDATENAME ();
/*****************************/
/* Function 0x14 */
WERROR WKSSVC_NETRGETJOININFORMATION ();
/*****************************/
/* Function 0x15 */
WERROR WKSSVC_NETRGETJOINABLEOUS ();
typedef struct {
uint8 data[524];
} wkssvc_PasswordBuffer;
typedef [bitmap32bit] bitmap {
/* TRUE: defer setting the SPN and dNSHostName until a rename operation */
WKSSVC_JOIN_FLAGS_DEFER_SPN = 0x00000100,
/* TRUE: set the machine password to the provided one after the join completes */
WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED = 0x00000080,
/* TRUE: perform an unsecured join */
WKSSVC_JOIN_FLAGS_JOIN_UNSECURE = 0x00000040,
/* TRUE: allow the join to complete even if the account already exists */
WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED = 0x00000020,
/* TRUE: this join is part of a w9x upgrade */
WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE = 0x00000010,
/* TRUE: delete the account when the domain is left */
WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE = 0x00000004,
/* TRUE: create the account in the domain */
WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE = 0x00000002,
/* TRUE: join domain FALSE: join workgroup */
WKSSVC_JOIN_FLAGS_JOIN_TYPE = 0x00000001
} wkssvc_joinflags;
/*****************************/
/* Function 0x16 */
WERROR wkssvc_NetrJoinDomain2 (
[in] [string,charset(UTF16)] uint16 *server_name,
[in] [string,charset(UTF16),ref] uint16 *domain_name,
[in] [string,charset(UTF16)] uint16 *account_name,
[in] [string,charset(UTF16)] uint16 *admin_account,
[in] wkssvc_PasswordBuffer *encrypted_password,
[in] wkssvc_joinflags join_flags
);
/*****************************/
/* Function 0x17 */
WERROR wkssvc_NetrUnjoinDomain2 (
[in] [unique] [string,charset(UTF16)] uint16 *server_name,
[in] [unique] [string,charset(UTF16)] uint16 *account,
[in] [unique] wkssvc_PasswordBuffer *encrypted_password,
[in] wkssvc_joinflags unjoin_flags
);
typedef [bitmap32bit] bitmap {
/* TRUE: create the account in the domain */
WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE = 0x00000002
} wkssvc_renameflags;
/*****************************/
/* Function 0x18 */
WERROR wkssvc_NetrRenameMachineInDomain2(
[in] [unique] [string,charset(UTF16)] uint16 *server_name,
[in] [unique] [string,charset(UTF16)] uint16 *NewMachineName,
[in] [unique] [string,charset(UTF16)] uint16 *Account,
[in] [unique] wkssvc_PasswordBuffer *EncryptedPassword,
[in] wkssvc_renameflags RenameOptions
);
/*****************************/
/* Function 0x19 */
WERROR WKSSVC_NETRVALIDATENAME2 ();
/*****************************/
/* Function 0x1a */
WERROR WKSSVC_NETRGETJOINABLEOUS2 ();
/*****************************/
/* Function 0x1b */
WERROR wkssvc_NetrAddAlternateComputerName(
[in] [unique] [string,charset(UTF16)] uint16 *server_name,
[in] [unique] [string,charset(UTF16)] uint16 *NewAlternateMachineName,
[in] [unique] [string,charset(UTF16)] uint16 *Account,
[in] [unique] wkssvc_PasswordBuffer *EncryptedPassword,
[in] uint32 Reserved
);
/*****************************/
/* Function 0x1c */
WERROR wkssvc_NetrRemoveAlternateComputerName(
[in] [unique] [string,charset(UTF16)] uint16 *server_name,
[in] [unique] [string,charset(UTF16)] uint16 *AlternateMachineNameToRemove,
[in] [unique] [string,charset(UTF16)] uint16 *Account,
[in] [unique] wkssvc_PasswordBuffer *EncryptedPassword,
[in] uint32 Reserved
);
/*****************************/
/* Function 0x1d */
WERROR WKSSVC_NETRSETPRIMARYCOMPUTERNAME ();
/*****************************/
/* Function 0x1e */
WERROR WKSSVC_NETRENUMERATECOMPUTERNAMES ();
}