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

r18618: * remove svn:externals

Browse Source 
* 'make idl' now requires pidl in the current PATH
* regenerate winreg ndr files
This commit is contained in:
Gerald Carter 2006-09-18 19:02:06 +00:00 committed by Gerald (Jerry) Carter
parent fd0579b963
commit e936d39e00
21 changed files with 8849 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
source/Makefile.in
View File

@ -849,14 +849,7 @@ cac: SHOWFLAGS $(LIBMSRPC)
## Perl IDL Compiler
IDL_FILES = unixinfo.idl lsa.idl dfs.idl echo.idl winreg.idl initshutdown.idl
pidl/Makefile: pidl/Makefile.PL
@echo Building Perl IDL Compiler....
@cd $(srcdir)/pidl && $(PERL) Makefile.PL
pidl/lib/Parse/Pidl/IDL.pm: pidl/Makefile
@cd $(srcdir)/pidl && make
idl: pidl/lib/Parse/Pidl/IDL.pm
idl:
@IDL_FILES="$(IDL_FILES)" CPP="$(CPP)" PERL="$(PERL)" \
srcdir="$(srcdir)" $(srcdir)/script/build_idl.sh $(PIDL_ARGS)

252
source/librpc/gen_ndr/ndr_winreg.c
View File

@ -2070,38 +2070,22 @@ NTSTATUS ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const str
if (r->out.class_out) {
NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.class_out));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.num_subkeys));
if (r->out.num_subkeys) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.max_subkeylen));
if (r->out.max_subkeylen) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.max_subkeysize));
if (r->out.max_subkeysize) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeysize));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.num_values));
if (r->out.num_values) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.max_valnamelen));
if (r->out.max_valnamelen) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.max_valbufsize));
if (r->out.max_valbufsize) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.secdescsize));
if (r->out.secdescsize) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));
}
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.last_changed_time));
if (r->out.last_changed_time) {
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
}
if (r->out.num_subkeys == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
if (r->out.max_subkeylen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
if (r->out.max_subkeysize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeysize));
if (r->out.num_values == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
if (r->out.max_valnamelen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));
if (r->out.max_valbufsize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));
if (r->out.secdescsize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));
if (r->out.last_changed_time == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
}
return NT_STATUS_OK;
@ -2110,14 +2094,6 @@ NTSTATUS ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const str
NTSTATUS ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct winreg_QueryInfoKey *r)
{
uint32_t _ptr_class_out;
uint32_t _ptr_num_subkeys;
uint32_t _ptr_max_subkeylen;
uint32_t _ptr_max_subkeysize;
uint32_t _ptr_num_values;
uint32_t _ptr_max_valnamelen;
uint32_t _ptr_max_valbufsize;
uint32_t _ptr_secdescsize;
uint32_t _ptr_last_changed_time;
TALLOC_CTX *_mem_save_handle_0;
TALLOC_CTX *_mem_save_class_out_0;
TALLOC_CTX *_mem_save_num_subkeys_0;
@ -2139,6 +2115,22 @@ NTSTATUS ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct wi
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.class_in));
NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
ZERO_STRUCTP(r->out.num_subkeys);
NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
ZERO_STRUCTP(r->out.max_subkeylen);
NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
ZERO_STRUCTP(r->out.max_subkeysize);
NDR_PULL_ALLOC(ndr, r->out.num_values);
ZERO_STRUCTP(r->out.num_values);
NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
ZERO_STRUCTP(r->out.max_valnamelen);
NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
ZERO_STRUCTP(r->out.max_valbufsize);
NDR_PULL_ALLOC(ndr, r->out.secdescsize);
ZERO_STRUCTP(r->out.secdescsize);
NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
ZERO_STRUCTP(r->out.last_changed_time);
}
if (flags & NDR_OUT) {
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_class_out));
@ -2153,102 +2145,62 @@ NTSTATUS ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct wi
NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.class_out));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_class_out_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_num_subkeys));
if (_ptr_num_subkeys) {
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
} else {
r->out.num_subkeys = NULL;
}
if (r->out.num_subkeys) {
_mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_max_subkeylen));
if (_ptr_max_subkeylen) {
_mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
} else {
r->out.max_subkeylen = NULL;
}
if (r->out.max_subkeylen) {
_mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_max_subkeysize));
if (_ptr_max_subkeysize) {
_mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
} else {
r->out.max_subkeysize = NULL;
}
if (r->out.max_subkeysize) {
_mem_save_max_subkeysize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeysize, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeysize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeysize_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_num_values));
if (_ptr_num_values) {
_mem_save_max_subkeysize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeysize, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeysize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeysize_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.num_values);
} else {
r->out.num_values = NULL;
}
if (r->out.num_values) {
_mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_max_valnamelen));
if (_ptr_max_valnamelen) {
_mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
} else {
r->out.max_valnamelen = NULL;
}
if (r->out.max_valnamelen) {
_mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_max_valbufsize));
if (_ptr_max_valbufsize) {
_mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
} else {
r->out.max_valbufsize = NULL;
}
if (r->out.max_valbufsize) {
_mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdescsize));
if (_ptr_secdescsize) {
_mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.secdescsize);
} else {
r->out.secdescsize = NULL;
}
if (r->out.secdescsize) {
_mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, 0);
}
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
if (_ptr_last_changed_time) {
_mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
} else {
r->out.last_changed_time = NULL;
}
if (r->out.last_changed_time) {
_mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, 0);
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
}
_mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
}
return NT_STATUS_OK;
@ -2282,51 +2234,35 @@ _PUBLIC_ void ndr_print_winreg_QueryInfoKey(struct ndr_print *ndr, const char *n
ndr->depth--;
ndr_print_ptr(ndr, "num_subkeys", r->out.num_subkeys);
ndr->depth++;
if (r->out.num_subkeys) {
ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);
}
ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);
ndr->depth--;
ndr_print_ptr(ndr, "max_subkeylen", r->out.max_subkeylen);
ndr->depth++;
if (r->out.max_subkeylen) {
ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
}
ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
ndr->depth--;
ndr_print_ptr(ndr, "max_subkeysize", r->out.max_subkeysize);
ndr->depth++;
if (r->out.max_subkeysize) {
ndr_print_uint32(ndr, "max_subkeysize", *r->out.max_subkeysize);
}
ndr_print_uint32(ndr, "max_subkeysize", *r->out.max_subkeysize);
ndr->depth--;
ndr_print_ptr(ndr, "num_values", r->out.num_values);
ndr->depth++;
if (r->out.num_values) {
ndr_print_uint32(ndr, "num_values", *r->out.num_values);
}
ndr_print_uint32(ndr, "num_values", *r->out.num_values);
ndr->depth--;
ndr_print_ptr(ndr, "max_valnamelen", r->out.max_valnamelen);
ndr->depth++;
if (r->out.max_valnamelen) {
ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);
}
ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);
ndr->depth--;
ndr_print_ptr(ndr, "max_valbufsize", r->out.max_valbufsize);
ndr->depth++;
if (r->out.max_valbufsize) {
ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);
}
ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);
ndr->depth--;
ndr_print_ptr(ndr, "secdescsize", r->out.secdescsize);
ndr->depth++;
if (r->out.secdescsize) {
ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);
}
ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);
ndr->depth--;
ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
ndr->depth++;
if (r->out.last_changed_time) {
ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
}
ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
ndr->depth--;
ndr_print_WERROR(ndr, "result", r->out.result);
ndr->depth--;
@ -3114,10 +3050,8 @@ NTSTATUS ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struc
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
}
if (flags & NDR_OUT) {
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.version));
if (r->out.version) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));
}
if (r->out.version == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
}
return NT_STATUS_OK;
@ -3125,7 +3059,6 @@ NTSTATUS ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struc
NTSTATUS ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winreg_GetVersion *r)
{
uint32_t _ptr_version;
TALLOC_CTX *_mem_save_handle_0;
TALLOC_CTX *_mem_save_version_0;
if (flags & NDR_IN) {
@ -3138,20 +3071,17 @@ NTSTATUS ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winr
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
NDR_PULL_ALLOC(ndr, r->out.version);
ZERO_STRUCTP(r->out.version);
}
if (flags & NDR_OUT) {
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_version));
if (_ptr_version) {
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.version);
} else {
r->out.version = NULL;
}
if (r->out.version) {
_mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.version, 0);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, 0);
}
_mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
}
return NT_STATUS_OK;
@ -3178,9 +3108,7 @@ _PUBLIC_ void ndr_print_winreg_GetVersion(struct ndr_print *ndr, const char *nam
ndr->depth++;
ndr_print_ptr(ndr, "version", r->out.version);
ndr->depth++;
if (r->out.version) {
ndr_print_uint32(ndr, "version", *r->out.version);
}
ndr_print_uint32(ndr, "version", *r->out.version);
ndr->depth--;
ndr_print_WERROR(ndr, "result", r->out.result);
ndr->depth--;

18
source/librpc/gen_ndr/winreg.h
View File

@ -315,14 +315,14 @@ struct winreg_QueryInfoKey {
struct {
struct winreg_String *class_out;/* [unique,keepref] */
uint32_t *num_subkeys;/* [unique,keepref] */
uint32_t *max_subkeylen;/* [unique,keepref] */
uint32_t *max_subkeysize;/* [unique,keepref] */
uint32_t *num_values;/* [unique,keepref] */
uint32_t *max_valnamelen;/* [unique,keepref] */
uint32_t *max_valbufsize;/* [unique,keepref] */
uint32_t *secdescsize;/* [unique,keepref] */
NTTIME *last_changed_time;/* [unique,keepref] */
uint32_t *num_subkeys;/* [keepref,ref] */
uint32_t *max_subkeylen;/* [keepref,ref] */
uint32_t *max_subkeysize;/* [keepref,ref] */
uint32_t *num_values;/* [keepref,ref] */
uint32_t *max_valnamelen;/* [keepref,ref] */
uint32_t *max_valbufsize;/* [keepref,ref] */
uint32_t *secdescsize;/* [keepref,ref] */
NTTIME *last_changed_time;/* [keepref,ref] */
WERROR result;
} out;
@ -447,7 +447,7 @@ struct winreg_GetVersion {
} in;
struct {
uint32_t *version;/* [unique,keepref] */
uint32_t *version;/* [keepref,ref] */
WERROR result;
} out;

234
source/librpc/idl/dfs.idl Normal file
View File

@ -0,0 +1,234 @@
/*
dfs interface definition
*/
[ uuid("4fc742e0-4a10-11cf-8273-00aa004ae673"),
version(3.0),
pointer_default(unique),
helpstring("Settings for Microsoft Distributed File System"),
keepref
] interface netdfs
{
/******************/
/* Function: 0x00 */
void dfs_GetManagerVersion(
[out] uint32 *exist_flag
);
/******************/
/* Function: 0x01 */
WERROR dfs_Add (
[in,string,charset(UTF16)] uint16 *path,
[in,string,charset(UTF16)] uint16 *server,
[in,unique,string,charset(UTF16)] uint16 *share,
[in,unique,string,charset(UTF16)] uint16 *comment,
[in] uint32 flags
);
/******************/
/* Function: 0x02 */
WERROR dfs_Remove (
[in,string,charset(UTF16)] uint16 *path,
[in,unique,string,charset(UTF16)] uint16 *server,
[in,unique,string,charset(UTF16)] uint16 *share
);
/******************/
/* Function: 0x03 */
WERROR dfs_SetInfo ();
/******************/
/* Function: 0x04 */
typedef struct {
} dfs_Info0;
typedef struct {
[string,charset(UTF16)] uint16 *path;
} dfs_Info1;
typedef struct {
[string,charset(UTF16)] uint16 *path;
[string,charset(UTF16)] uint16 *comment;
uint32 state;
uint32 num_stores;
} dfs_Info2;
typedef struct {
uint32 state;
[string,charset(UTF16)] uint16 *server;
[string,charset(UTF16)] uint16 *share;
} dfs_StorageInfo;
typedef struct {
[string,charset(UTF16)] uint16 *path;
[string,charset(UTF16)] uint16 *comment;
uint32 state;
uint32 num_stores;
[size_is(num_stores)] dfs_StorageInfo *stores;
} dfs_Info3;
typedef struct {
[string,charset(UTF16)] uint16 *path;
[string,charset(UTF16)] uint16 *comment;
uint32 state;
uint32 timeout;
GUID guid;
uint32 num_stores;
[size_is(num_stores)] dfs_StorageInfo *stores;
} dfs_Info4;
typedef struct {
[string,charset(UTF16)] uint16 *comment;
} dfs_Info100;
typedef struct {
uint32 state;
} dfs_Info101;
typedef struct {
uint32 timeout;
} dfs_Info102;
typedef struct {
[string,charset(UTF16)] uint16 *dom_root;
} dfs_Info200;
typedef struct {
uint32 flags;
[string,charset(UTF16)] uint16 *dom_root;
} dfs_Info300;
typedef union {
[case(0)] dfs_Info0 *info0;
[case(1)] dfs_Info1 *info1;
[case(2)] dfs_Info2 *info2;
[case(3)] dfs_Info3 *info3;
[case(4)] dfs_Info4 *info4;
[case(100)] dfs_Info100 *info100;
[case(101)] dfs_Info101 *info101;
[case(102)] dfs_Info102 *info102;
} dfs_Info;
WERROR dfs_GetInfo (
[in,string,charset(UTF16)] uint16 *path,
[in,unique,string,charset(UTF16)] uint16 *server,
[in,unique,string,charset(UTF16)] uint16 *share,
[in] uint32 level,
[out,switch_is(level)] dfs_Info *info
);
/******************/
/* Function: 0x05 */
typedef struct {
uint32 count;
[size_is(count)] dfs_Info1 *s;
} dfs_EnumArray1;
typedef struct {
uint32 count;
[size_is(count)] dfs_Info2 *s;
} dfs_EnumArray2;
typedef struct {
uint32 count;
[size_is(count)] dfs_Info3 *s;
} dfs_EnumArray3;
typedef struct {
uint32 count;
[size_is(count)] dfs_Info4 *s;
} dfs_EnumArray4;
typedef struct {
uint32 count;
[size_is(count)] dfs_Info200 *s;
} dfs_EnumArray200;
typedef struct {
uint32 count;
[size_is(count)] dfs_Info300 *s;
} dfs_EnumArray300;
typedef union {
[case(1)] dfs_EnumArray1 *info1;
[case(2)] dfs_EnumArray2 *info2;
[case(3)] dfs_EnumArray3 *info3;
[case(4)] dfs_EnumArray4 *info4;
[case(200)] dfs_EnumArray200 *info200;
[case(300)] dfs_EnumArray300 *info300;
} dfs_EnumInfo;
typedef struct {
uint32 level;
[switch_is(level)] dfs_EnumInfo e;
} dfs_EnumStruct;
WERROR dfs_Enum (
[in] uint32 level,
[in] uint32 bufsize,
[in,out,unique] dfs_EnumStruct *info,
[in,unique] uint32 *unknown,
[in,out,unique] uint32 *total
);
/* Function 0x06 */
WERROR dfs_Rename();
/* Function 0x07 */
WERROR dfs_Move();
/* Function 0x08 */
WERROR dfs_ManagerGetConfigInfo();
/* Function 0x09 */
WERROR dfs_ManagerSendSiteInfo();
/* Function 0x0a */
WERROR dfs_AddFtRoot();
/* Function 0x0b */
WERROR dfs_RemoveFtRoot();
/* Function 0x0c */
WERROR dfs_AddStdRoot();
/* Function 0x0d */
WERROR dfs_RemoveStdRoot();
/* Function 0x0e */
WERROR dfs_ManagerInitialize();
/* Function 0x0f */
WERROR dfs_AddStdRootForced();
/* Function 0x10 */
WERROR dfs_GetDcAddress();
/* Function 0x11 */
WERROR dfs_SetDcAddress();
/* Function 0x12 */
WERROR dfs_FlushFtTable();
/* Function 0x13 */
WERROR dfs_Add2();
/* Function 0x14 */
WERROR dfs_Remove2();
/* Function 0x15 */
WERROR dfs_EnumEx(
[in,string,charset(UTF16)] uint16 *name,
[in] uint32 level,
[in] uint32 bufsize,
[in,out,unique] dfs_EnumStruct *info,
[in,out,unique] uint32 *total
);
/* Function 0x16 */
WERROR dfs_SetInfo2();
}

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
);
}

86
source/librpc/idl/idl_types.h Normal file
View File

@ -0,0 +1,86 @@
#define STR_ASCII LIBNDR_FLAG_STR_ASCII
#define STR_LEN4 LIBNDR_FLAG_STR_LEN4
#define STR_SIZE4 LIBNDR_FLAG_STR_SIZE4
#define STR_SIZE2 LIBNDR_FLAG_STR_SIZE2
#define STR_NOTERM LIBNDR_FLAG_STR_NOTERM
#define STR_NULLTERM LIBNDR_FLAG_STR_NULLTERM
#define STR_BYTESIZE LIBNDR_FLAG_STR_BYTESIZE
#define STR_FIXLEN32 LIBNDR_FLAG_STR_FIXLEN32
#define STR_FIXLEN15 LIBNDR_FLAG_STR_FIXLEN15
#define STR_CONFORMANT LIBNDR_FLAG_STR_CONFORMANT
#define STR_CHARLEN LIBNDR_FLAG_STR_CHARLEN
#define STR_UTF8 LIBNDR_FLAG_STR_UTF8
/*
a UCS2 string prefixed with [size], 32 bits
*/
#define lstring [flag(STR_SIZE4)] string
/*
a null terminated UCS2 string
*/
#define nstring [flag(STR_NULLTERM)] string
/*
fixed length 32 character UCS-2 string
*/
#define string32 [flag(STR_FIXLEN32)] string
/*
fixed length 16 character ascii string
*/
#define astring15 [flag(STR_ASCII|STR_FIXLEN15)] string
/*
an ascii string prefixed with [offset] [length], both 32 bits
null terminated
*/
#define ascstr2 [flag(STR_ASCII|STR_LEN4)] string
/*
an ascii string prefixed with [size], 32 bits
*/
#define asclstr [flag(STR_ASCII|STR_SIZE4)] string
/*
an ascii string prefixed with [size], 16 bits
null terminated
*/
#define ascstr3 [flag(STR_ASCII|STR_SIZE2)] string
/*
an ascii string prefixed with [size] [offset] [length], all 32 bits
not null terminated
*/
#define ascstr_noterm [flag(STR_NOTERM|STR_ASCII|STR_SIZE4|STR_LEN4)] string
/*
a null terminated ascii string
*/
#define astring [flag(STR_ASCII|STR_NULLTERM)] string
/*
a null terminated UTF8 string
*/
#define utf8string [flag(STR_UTF8|STR_NULLTERM)] string
/*
a null terminated UCS2 string
*/
#define nstring_array [flag(STR_NULLTERM)] string_array
#define NDR_NOALIGN LIBNDR_FLAG_NOALIGN
#define NDR_REMAINING LIBNDR_FLAG_REMAINING
#define NDR_ALIGN2 LIBNDR_FLAG_ALIGN2
#define NDR_ALIGN4 LIBNDR_FLAG_ALIGN4
#define NDR_ALIGN8 LIBNDR_FLAG_ALIGN8
/* this flag is used to force a section of IDL as little endian. It is
needed for the epmapper IDL, which is defined as always being LE */
#define NDR_LITTLE_ENDIAN LIBNDR_FLAG_LITTLE_ENDIAN
#define NDR_BIG_ENDIAN LIBNDR_FLAG_BIGENDIAN
/*
this is used to control formatting of uint8 arrays
*/
#define NDR_PAHEX LIBNDR_PRINT_ARRAY_HEX

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
);
}

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

@ -0,0 +1,976 @@
#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. */
SID_NAME_COMPUTER = 9 /* machine */
} 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();
}

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

@ -0,0 +1,56 @@
#include "idl_types.h"
/*
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,unique] 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,unique] dom_sid *sid
);
typedef struct {
NTSTATUS status;
utf8string homedir;
utf8string 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[*]
);
}

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

@ -0,0 +1,365 @@
/*
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 [bitmap32bit] bitmap {
} winreg_AccessMask;
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] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x01 */
WERROR winreg_OpenHKCU(
[in] uint16 *system_name,
[in] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x02 */
WERROR winreg_OpenHKLM(
[in] uint16 *system_name,
[in] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x03 */
WERROR winreg_OpenHKPD(
[in] uint16 *system_name,
[in] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x04 */
WERROR winreg_OpenHKU(
[in] uint16 *system_name,
[in] winreg_AccessMask 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 keyclass,
[in] uint32 options,
[in] winreg_AccessMask 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 *keyclass,
[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 *parent_handle,
[in] winreg_String keyname,
[in] uint32 unknown,
[in] winreg_AccessMask 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,ref] uint32 *num_subkeys,
[out,ref] uint32 *max_subkeylen,
[out,ref] uint32 *max_subkeysize,
[out,ref] uint32 *num_values,
[out,ref] uint32 *max_valnamelen,
[out,ref] uint32 *max_valbufsize,
[out,ref] uint32 *secdescsize,
[out,ref] 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] winreg_AccessMask access_mask,
[in,out,ref] KeySecurityData *sd
);
/******************/
/* 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,ref] uint32 *version
);
/******************/
/* Function: 0x1b */
WERROR winreg_OpenHKCC(
[in] uint16 *system_name,
[in] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x1c */
WERROR winreg_OpenHKDD(
[in] uint16 *system_name,
[in] winreg_AccessMask 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] winreg_AccessMask access_mask,
[out,ref] policy_handle *handle
);
/******************/
/* Function: 0x21 */
WERROR winreg_OpenHKPN(
[in] uint16 *system_name,
[in] winreg_AccessMask 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 ();
}

2
source/script/build_idl.sh
View File

@ -8,7 +8,7 @@ cd ${srcdir}
[ -d librpc/gen_ndr ] || mkdir -p librpc/gen_ndr || exit 1
PIDL="$PERL pidl/pidl ${PIDL_ARGS} ${PIDL_EXTRA_ARGS}"
PIDL="pidl ${PIDL_ARGS} ${PIDL_EXTRA_ARGS}"
##
## Find newer files rather than rebuild all of them