static NTSTATUS w32time__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct w32time_SyncTime *r2 = (struct w32time_SyncTime *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function w32time_SyncTime replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(w32time_SyncTime, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in w32time_SyncTime\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct w32time_GetNetLogonServiceBits *r2 = (struct w32time_GetNetLogonServiceBits *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function w32time_GetNetLogonServiceBits replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(w32time_GetNetLogonServiceBits, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in w32time_GetNetLogonServiceBits\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct w32time_QueryProviderStatus *r2 = (struct w32time_QueryProviderStatus *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function w32time_QueryProviderStatus replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(w32time_QueryProviderStatus, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in w32time_QueryProviderStatus\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_w32time, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static NTSTATUS initshutdown__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct initshutdown_Init *r2 = (struct initshutdown_Init *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function initshutdown_Init replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(initshutdown_Init, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in initshutdown_Init\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct initshutdown_Abort *r2 = (struct initshutdown_Abort *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function initshutdown_Abort replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(initshutdown_Abort, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in initshutdown_Abort\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct initshutdown_InitEx *r2 = (struct initshutdown_InitEx *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function initshutdown_InitEx replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(initshutdown_InitEx, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in initshutdown_InitEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_initshutdown, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
BOOL test_DsRoleGetPrimaryDomainInformation(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
{
struct dssetup_DsRoleGetPrimaryDomainInformation r;
NTSTATUS status;
BOOL ret = True;
int i;
printf("\ntesting DsRoleGetPrimaryDomainInformation\n");
for (i=DS_ROLE_BASIC_INFORMATION; i <= DS_ROLE_OP_STATUS; i++) {
r.in.level = i;
status = dcerpc_dssetup_DsRoleGetPrimaryDomainInformation(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
printf("dcerpc_dssetup_DsRoleGetPrimaryDomainInformation level %d failed - %s\n",
i, errstr);
ret = False;
} else if (!W_ERROR_IS_OK(r.out.result)) {
printf("DsRoleGetPrimaryDomainInformation level %d failed - %s\n",
i, win_errstr(r.out.result));
ret = False;
}
}
return ret;
}
bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
{
char *q = prs_mem_get(ps, sizeof(uint32));
if (q == NULL)
return False;
if (UNMARSHALLING(ps)) {
if (ps->bigendian_data)
*status = NT_STATUS(RIVAL(q,0));
else
*status = NT_STATUS(IVAL(q,0));
} else {
if (ps->bigendian_data)
RSIVAL(q,0,NT_STATUS_V(*status));
else
SIVAL(q,0,NT_STATUS_V(*status));
}
DEBUGADD(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name,
dcerpc_errstr(talloc_tos(), NT_STATUS_V(*status))));
ps->data_offset += sizeof(uint32);
return True;
}
static NTSTATUS dnsp__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct decode_DnssrvRpcRecord *r2 = (struct decode_DnssrvRpcRecord *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_DnssrvRpcRecord replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_DnssrvRpcRecord, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_DnssrvRpcRecord\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct decode_DnsProperty *r2 = (struct decode_DnsProperty *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_DnsProperty replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_DnsProperty, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_DnsProperty\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_dnsp, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static void test_scan_call(struct torture_context *tctx, const struct ndr_interface_table *iface, int opnum)
{
DATA_BLOB stub_in, stub_out;
int i;
NTSTATUS status;
struct dcerpc_pipe *p = NULL;
struct policy_handle handle;
reopen(tctx, &p, iface);
get_policy_handle(p, tctx, &handle);
/* work out the minimum amount of input data */
for (i=0;i<2000;i++) {
stub_in = data_blob(NULL, i);
data_blob_clear(&stub_in);
status = dcerpc_request(p, NULL, opnum, tctx, &stub_in, &stub_out);
if (NT_STATUS_IS_OK(status)) {
printf("opnum %d min_input %d - output %d\n",
opnum, (int)stub_in.length, (int)stub_out.length);
dump_data(0, stub_out.data, stub_out.length);
talloc_free(p);
test_ptr_scan(tctx, iface, opnum, &stub_in, 0, stub_in.length, 0);
return;
}
fill_blob_handle(&stub_in, tctx, &handle);
status = dcerpc_request(p, NULL, opnum, tctx, &stub_in, &stub_out);
if (NT_STATUS_IS_OK(status)) {
printf("opnum %d min_input %d - output %d (with handle)\n",
opnum, (int)stub_in.length, (int)stub_out.length);
dump_data(0, stub_out.data, stub_out.length);
talloc_free(p);
test_ptr_scan(tctx, iface, opnum, &stub_in, 0, stub_in.length, 0);
return;
}
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
printf("opnum %d size %d fault %s\n", opnum, i, dcerpc_errstr(tctx, p->last_fault_code));
if (p->last_fault_code == 5) {
reopen(tctx, &p, iface);
}
continue;
}
printf("opnum %d size %d error %s\n", opnum, i, nt_errstr(status));
}
printf("opnum %d minimum not found!?\n", opnum);
talloc_free(p);
}
static void try_expand(struct torture_context *tctx, const struct ndr_interface_table *iface,
int opnum, DATA_BLOB *base_in, int insert_ofs, int depth)
{
DATA_BLOB stub_in, stub_out;
int n;
NTSTATUS status;
struct dcerpc_pipe *p = NULL;
reopen(tctx, &p, iface);
/* work out how much to expand to get a non fault */
for (n=0;n<2000;n++) {
stub_in = data_blob(NULL, base_in->length + n);
data_blob_clear(&stub_in);
memcpy(stub_in.data, base_in->data, insert_ofs);
memcpy(stub_in.data+insert_ofs+n, base_in->data+insert_ofs, base_in->length-insert_ofs);
status = dcerpc_request(p, NULL, opnum, tctx, &stub_in, &stub_out);
if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
print_depth(depth);
printf("expand by %d gives %s\n", n, nt_errstr(status));
if (n >= 4) {
test_ptr_scan(tctx, iface, opnum, &stub_in,
insert_ofs, insert_ofs+n, depth+1);
}
return;
} else {
#if 0
print_depth(depth);
printf("expand by %d gives fault %s\n", n, dcerpc_errstr(tctx, p->last_fault_code));
#endif
}
if (p->last_fault_code == 5) {
reopen(tctx, &p, iface);
}
}
talloc_free(p);
}
static void remote_op_dispatch_done(struct tevent_req *subreq)
{
struct dcesrv_call_state *dce_call = tevent_req_callback_data(subreq,
struct dcesrv_call_state);
struct dcesrv_remote_private *priv = talloc_get_type_abort(dce_call->context->private_data,
struct dcesrv_remote_private);
uint16_t opnum = dce_call->pkt.u.request.opnum;
const struct ndr_interface_table *table = dce_call->context->iface->private_data;
const struct ndr_interface_call *call;
const char *name;
NTSTATUS status;
name = table->calls[opnum].name;
call = &table->calls[opnum];
/* we didn't use the return code of this function as we only check the last_fault_code */
status = dcerpc_binding_handle_call_recv(subreq);
TALLOC_FREE(subreq);
dce_call->fault_code = priv->c_pipe->last_fault_code;
if (dce_call->fault_code != 0) {
DEBUG(0,("dcesrv_remote: call[%s] failed with: %s!\n",
name, dcerpc_errstr(dce_call, dce_call->fault_code)));
goto reply;
}
if (NT_STATUS_IS_OK(status) &&
(priv->c_pipe->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
ndr_print_function_debug(call->ndr_print, name, NDR_OUT, dce_call->r);
}
reply:
status = dcesrv_reply(dce_call);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("dcesrv_remote: call[%s]: dcesrv_reply() failed - %s\n",
name, nt_errstr(status)));
}
}
static void test_ptr_scan(struct torture_context *tctx, const struct ndr_interface_table *iface,
int opnum, DATA_BLOB *base_in, int min_ofs, int max_ofs, int depth)
{
DATA_BLOB stub_in, stub_out;
int ofs;
NTSTATUS status;
struct dcerpc_pipe *p = NULL;
reopen(tctx, &p, iface);
stub_in = data_blob(NULL, base_in->length);
memcpy(stub_in.data, base_in->data, base_in->length);
/* work out which elements are pointers */
for (ofs=min_ofs;ofs<=max_ofs-4;ofs+=4) {
SIVAL(stub_in.data, ofs, 1);
status = dcerpc_request(p, NULL, opnum, tctx, &stub_in, &stub_out);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
print_depth(depth);
printf("possible ptr at ofs %d - fault %s\n",
ofs-min_ofs, dcerpc_errstr(tctx, p->last_fault_code));
if (p->last_fault_code == 5) {
reopen(tctx, &p, iface);
}
if (depth == 0) {
try_expand(tctx, iface, opnum, &stub_in, ofs+4, depth+1);
} else {
try_expand(tctx, iface, opnum, &stub_in, max_ofs, depth+1);
}
SIVAL(stub_in.data, ofs, 0);
continue;
}
SIVAL(stub_in.data, ofs, 0);
}
talloc_free(p);
}
static NTSTATUS ntlmssp__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct decode_NEGOTIATE_MESSAGE *r2 = (struct decode_NEGOTIATE_MESSAGE *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_NEGOTIATE_MESSAGE replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_NEGOTIATE_MESSAGE, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_NEGOTIATE_MESSAGE\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct decode_CHALLENGE_MESSAGE *r2 = (struct decode_CHALLENGE_MESSAGE *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_CHALLENGE_MESSAGE replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_CHALLENGE_MESSAGE, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_CHALLENGE_MESSAGE\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct decode_AUTHENTICATE_MESSAGE *r2 = (struct decode_AUTHENTICATE_MESSAGE *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_AUTHENTICATE_MESSAGE replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_AUTHENTICATE_MESSAGE, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_AUTHENTICATE_MESSAGE\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct decode_NTLMv2_CLIENT_CHALLENGE *r2 = (struct decode_NTLMv2_CLIENT_CHALLENGE *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_NTLMv2_CLIENT_CHALLENGE replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_NTLMv2_CLIENT_CHALLENGE, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_NTLMv2_CLIENT_CHALLENGE\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct decode_NTLMv2_RESPONSE *r2 = (struct decode_NTLMv2_RESPONSE *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function decode_NTLMv2_RESPONSE replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(decode_NTLMv2_RESPONSE, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in decode_NTLMv2_RESPONSE\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_ntlmssp, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static NTSTATUS rpcecho__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct echo_AddOne *r2 = (struct echo_AddOne *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_AddOne replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_AddOne\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct echo_EchoData *r2 = (struct echo_EchoData *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_EchoData replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_EchoData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct echo_SinkData *r2 = (struct echo_SinkData *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_SinkData replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_SinkData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct echo_SourceData *r2 = (struct echo_SourceData *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_SourceData replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_SourceData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct echo_TestCall *r2 = (struct echo_TestCall *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestCall replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestCall\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct echo_TestCall2 *r2 = (struct echo_TestCall2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestCall2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestCall2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct echo_TestSleep *r2 = (struct echo_TestSleep *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestSleep replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestSleep\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct echo_TestEnum *r2 = (struct echo_TestEnum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestEnum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 8: {
struct echo_TestSurrounding *r2 = (struct echo_TestSurrounding *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestSurrounding replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestSurrounding\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 9: {
struct echo_TestDoublePointer *r2 = (struct echo_TestDoublePointer *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestDoublePointer replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in echo_TestDoublePointer\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_rpcecho, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
struct test_join *torture_create_testuser(struct torture_context *torture,
const char *username,
const char *domain,
uint16_t acct_type,
const char **random_password)
{
NTSTATUS status;
struct samr_Connect c;
struct samr_CreateUser2 r;
struct samr_OpenDomain o;
struct samr_LookupDomain l;
struct dom_sid2 *sid = NULL;
struct samr_GetUserPwInfo pwp;
struct samr_PwInfo info;
struct samr_SetUserInfo s;
union samr_UserInfo u;
struct policy_handle handle;
struct policy_handle domain_handle;
uint32_t access_granted;
uint32_t rid;
DATA_BLOB session_key;
struct lsa_String name;
int policy_min_pw_len = 0;
struct test_join *join;
char *random_pw;
const char *dc_binding = torture_setting_string(torture, "dc_binding", NULL);
join = talloc(NULL, struct test_join);
if (join == NULL) {
return NULL;
}
ZERO_STRUCTP(join);
printf("Connecting to SAMR\n");
if (dc_binding) {
status = dcerpc_pipe_connect(join,
&join->p,
dc_binding,
&ndr_table_samr,
cmdline_credentials, NULL, torture->lp_ctx);
} else {
status = torture_rpc_connection(torture,
&join->p,
&ndr_table_samr);
}
if (!NT_STATUS_IS_OK(status)) {
return NULL;
}
c.in.system_name = NULL;
c.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
c.out.connect_handle = &handle;
status = dcerpc_samr_Connect(join->p, join, &c);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(join, join->p->last_fault_code);
}
printf("samr_Connect failed - %s\n", errstr);
return NULL;
}
printf("Opening domain %s\n", domain);
name.string = domain;
l.in.connect_handle = &handle;
l.in.domain_name = &name;
l.out.sid = &sid;
status = dcerpc_samr_LookupDomain(join->p, join, &l);
if (!NT_STATUS_IS_OK(status)) {
printf("LookupDomain failed - %s\n", nt_errstr(status));
goto failed;
}
talloc_steal(join, *l.out.sid);
join->dom_sid = *l.out.sid;
join->dom_netbios_name = talloc_strdup(join, domain);
if (!join->dom_netbios_name) goto failed;
o.in.connect_handle = &handle;
o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
o.in.sid = *l.out.sid;
o.out.domain_handle = &domain_handle;
status = dcerpc_samr_OpenDomain(join->p, join, &o);
if (!NT_STATUS_IS_OK(status)) {
printf("OpenDomain failed - %s\n", nt_errstr(status));
goto failed;
}
printf("Creating account %s\n", username);
again:
name.string = username;
r.in.domain_handle = &domain_handle;
r.in.account_name = &name;
r.in.acct_flags = acct_type;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.out.user_handle = &join->user_handle;
r.out.access_granted = &access_granted;
r.out.rid = &rid;
status = dcerpc_samr_CreateUser2(join->p, join, &r);
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
status = DeleteUser_byname(join->p, join, &domain_handle, name.string);
if (NT_STATUS_IS_OK(status)) {
goto again;
}
}
if (!NT_STATUS_IS_OK(status)) {
printf("CreateUser2 failed - %s\n", nt_errstr(status));
goto failed;
}
join->user_sid = dom_sid_add_rid(join, join->dom_sid, rid);
pwp.in.user_handle = &join->user_handle;
pwp.out.info = &info;
status = dcerpc_samr_GetUserPwInfo(join->p, join, &pwp);
if (NT_STATUS_IS_OK(status)) {
policy_min_pw_len = pwp.out.info->min_password_length;
}
random_pw = generate_random_str(join, MAX(8, policy_min_pw_len));
printf("Setting account password '%s'\n", random_pw);
ZERO_STRUCT(u);
s.in.user_handle = &join->user_handle;
s.in.info = &u;
s.in.level = 24;
encode_pw_buffer(u.info24.password.data, random_pw, STR_UNICODE);
u.info24.password_expired = 0;
status = dcerpc_fetch_session_key(join->p, &session_key);
if (!NT_STATUS_IS_OK(status)) {
printf("SetUserInfo level %u - no session key - %s\n",
s.in.level, nt_errstr(status));
torture_leave_domain(torture, join);
goto failed;
}
arcfour_crypt_blob(u.info24.password.data, 516, &session_key);
status = dcerpc_samr_SetUserInfo(join->p, join, &s);
if (!NT_STATUS_IS_OK(status)) {
printf("SetUserInfo failed - %s\n", nt_errstr(status));
goto failed;
}
ZERO_STRUCT(u);
s.in.user_handle = &join->user_handle;
s.in.info = &u;
s.in.level = 21;
u.info21.acct_flags = acct_type | ACB_PWNOEXP;
u.info21.fields_present = SAMR_FIELD_ACCT_FLAGS | SAMR_FIELD_DESCRIPTION | SAMR_FIELD_COMMENT | SAMR_FIELD_FULL_NAME;
u.info21.comment.string = talloc_asprintf(join,
"Tortured by Samba4: %s",
timestring(join, time(NULL)));
u.info21.full_name.string = talloc_asprintf(join,
"Torture account for Samba4: %s",
timestring(join, time(NULL)));
u.info21.description.string = talloc_asprintf(join,
"Samba4 torture account created by host %s: %s",
lp_netbios_name(torture->lp_ctx),
timestring(join, time(NULL)));
printf("Resetting ACB flags, force pw change time\n");
status = dcerpc_samr_SetUserInfo(join->p, join, &s);
if (!NT_STATUS_IS_OK(status)) {
printf("SetUserInfo failed - %s\n", nt_errstr(status));
goto failed;
}
if (random_password) {
*random_password = random_pw;
}
return join;
failed:
torture_leave_domain(torture, join);
return NULL;
}
static NTSTATUS FileServerVssAgent__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct fss_GetSupportedVersion *r2 = (struct fss_GetSupportedVersion *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_GetSupportedVersion replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_GetSupportedVersion, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_GetSupportedVersion\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct fss_SetContext *r2 = (struct fss_SetContext *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_SetContext replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_SetContext, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_SetContext\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct fss_StartShadowCopySet *r2 = (struct fss_StartShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_StartShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_StartShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_StartShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct fss_AddToShadowCopySet *r2 = (struct fss_AddToShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_AddToShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_AddToShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_AddToShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct fss_CommitShadowCopySet *r2 = (struct fss_CommitShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_CommitShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_CommitShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_CommitShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct fss_ExposeShadowCopySet *r2 = (struct fss_ExposeShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_ExposeShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_ExposeShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_ExposeShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct fss_RecoveryCompleteShadowCopySet *r2 = (struct fss_RecoveryCompleteShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_RecoveryCompleteShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_RecoveryCompleteShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_RecoveryCompleteShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct fss_AbortShadowCopySet *r2 = (struct fss_AbortShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_AbortShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_AbortShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_AbortShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 8: {
struct fss_IsPathSupported *r2 = (struct fss_IsPathSupported *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_IsPathSupported replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_IsPathSupported, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_IsPathSupported\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 9: {
struct fss_IsPathShadowCopied *r2 = (struct fss_IsPathShadowCopied *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_IsPathShadowCopied replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_IsPathShadowCopied, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_IsPathShadowCopied\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 10: {
struct fss_GetShareMapping *r2 = (struct fss_GetShareMapping *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_GetShareMapping replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_GetShareMapping, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_GetShareMapping\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 11: {
struct fss_DeleteShareMapping *r2 = (struct fss_DeleteShareMapping *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_DeleteShareMapping replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_DeleteShareMapping, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_DeleteShareMapping\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 12: {
struct fss_PrepareShadowCopySet *r2 = (struct fss_PrepareShadowCopySet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function fss_PrepareShadowCopySet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(fss_PrepareShadowCopySet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in fss_PrepareShadowCopySet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_FileServerVssAgent, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static NTSTATUS mgmt__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct mgmt_inq_if_ids *r2 = (struct mgmt_inq_if_ids *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function mgmt_inq_if_ids replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_inq_if_ids, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in mgmt_inq_if_ids\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct mgmt_inq_stats *r2 = (struct mgmt_inq_stats *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function mgmt_inq_stats replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_inq_stats, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in mgmt_inq_stats\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct mgmt_is_server_listening *r2 = (struct mgmt_is_server_listening *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function mgmt_is_server_listening replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_is_server_listening, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in mgmt_is_server_listening\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct mgmt_stop_server_listening *r2 = (struct mgmt_stop_server_listening *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function mgmt_stop_server_listening replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_stop_server_listening, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in mgmt_stop_server_listening\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct mgmt_inq_princ_name *r2 = (struct mgmt_inq_princ_name *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function mgmt_inq_princ_name replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_inq_princ_name, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in mgmt_inq_princ_name\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_mgmt, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static NTSTATUS eventlog6__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct eventlog6_EvtRpcRegisterRemoteSubscription *r2 = (struct eventlog6_EvtRpcRegisterRemoteSubscription *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterRemoteSubscription replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterRemoteSubscription, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRegisterRemoteSubscription\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionNextAsync replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionNextAsync, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRemoteSubscriptionNextAsync\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct eventlog6_EvtRpcRemoteSubscriptionNext *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionNext *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionNext replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionNext, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRemoteSubscriptionNext\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionWaitAsync replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionWaitAsync, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRemoteSubscriptionWaitAsync\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct eventlog6_EvtRpcRegisterControllableOperation *r2 = (struct eventlog6_EvtRpcRegisterControllableOperation *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterControllableOperation replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterControllableOperation, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRegisterControllableOperation\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct eventlog6_EvtRpcRegisterLogQuery *r2 = (struct eventlog6_EvtRpcRegisterLogQuery *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterLogQuery replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterLogQuery, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRegisterLogQuery\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct eventlog6_EvtRpcClearLog *r2 = (struct eventlog6_EvtRpcClearLog *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcClearLog replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcClearLog, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcClearLog\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct eventlog6_EvtRpcExportLog *r2 = (struct eventlog6_EvtRpcExportLog *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcExportLog replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcExportLog, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcExportLog\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 8: {
struct eventlog6_EvtRpcLocalizeExportLog *r2 = (struct eventlog6_EvtRpcLocalizeExportLog *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcLocalizeExportLog replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcLocalizeExportLog, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcLocalizeExportLog\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 9: {
struct eventlog6_EvtRpcMessageRender *r2 = (struct eventlog6_EvtRpcMessageRender *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcMessageRender replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcMessageRender, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcMessageRender\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 10: {
struct eventlog6_EvtRpcMessageRenderDefault *r2 = (struct eventlog6_EvtRpcMessageRenderDefault *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcMessageRenderDefault replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcMessageRenderDefault, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcMessageRenderDefault\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 11: {
struct eventlog6_EvtRpcQueryNext *r2 = (struct eventlog6_EvtRpcQueryNext *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcQueryNext replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcQueryNext, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcQueryNext\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 12: {
struct eventlog6_EvtRpcQuerySeek *r2 = (struct eventlog6_EvtRpcQuerySeek *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcQuerySeek replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcQuerySeek, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcQuerySeek\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 13: {
struct eventlog6_EvtRpcClose *r2 = (struct eventlog6_EvtRpcClose *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcClose replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcClose, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcClose\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 14: {
struct eventlog6_EvtRpcCancel *r2 = (struct eventlog6_EvtRpcCancel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcCancel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcCancel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcCancel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 15: {
struct eventlog6_EvtRpcAssertConfig *r2 = (struct eventlog6_EvtRpcAssertConfig *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcAssertConfig replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcAssertConfig, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcAssertConfig\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 16: {
struct eventlog6_EvtRpcRetractConfig *r2 = (struct eventlog6_EvtRpcRetractConfig *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRetractConfig replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRetractConfig, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcRetractConfig\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 17: {
struct eventlog6_EvtRpcOpenLogHandle *r2 = (struct eventlog6_EvtRpcOpenLogHandle *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcOpenLogHandle replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcOpenLogHandle, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcOpenLogHandle\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 18: {
struct eventlog6_EvtRpcGetLogFileInfo *r2 = (struct eventlog6_EvtRpcGetLogFileInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetLogFileInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetLogFileInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetLogFileInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 19: {
struct eventlog6_EvtRpcGetChannelList *r2 = (struct eventlog6_EvtRpcGetChannelList *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetChannelList replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetChannelList, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetChannelList\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 20: {
struct eventlog6_EvtRpcGetChannelConfig *r2 = (struct eventlog6_EvtRpcGetChannelConfig *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetChannelConfig replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetChannelConfig, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetChannelConfig\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 21: {
struct eventlog6_EvtRpcPutChannelConfig *r2 = (struct eventlog6_EvtRpcPutChannelConfig *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcPutChannelConfig replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcPutChannelConfig, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcPutChannelConfig\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 22: {
struct eventlog6_EvtRpcGetPublisherList *r2 = (struct eventlog6_EvtRpcGetPublisherList *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherList replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherList, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetPublisherList\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 23: {
struct eventlog6_EvtRpcGetPublisherListForChannel *r2 = (struct eventlog6_EvtRpcGetPublisherListForChannel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherListForChannel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherListForChannel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetPublisherListForChannel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 24: {
struct eventlog6_EvtRpcGetPublisherMetadata *r2 = (struct eventlog6_EvtRpcGetPublisherMetadata *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherMetadata replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherMetadata, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetPublisherMetadata\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 25: {
struct eventlog6_EvtRpcGetPublisherResourceMetadata *r2 = (struct eventlog6_EvtRpcGetPublisherResourceMetadata *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherResourceMetadata replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherResourceMetadata, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetPublisherResourceMetadata\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 26: {
struct eventlog6_EvtRpcGetEventMetadataEnum *r2 = (struct eventlog6_EvtRpcGetEventMetadataEnum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetEventMetadataEnum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetEventMetadataEnum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetEventMetadataEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 27: {
struct eventlog6_EvtRpcGetNextEventMetadata *r2 = (struct eventlog6_EvtRpcGetNextEventMetadata *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetNextEventMetadata replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetNextEventMetadata, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetNextEventMetadata\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 28: {
struct eventlog6_EvtRpcGetClassicLogDisplayName *r2 = (struct eventlog6_EvtRpcGetClassicLogDisplayName *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetClassicLogDisplayName replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetClassicLogDisplayName, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in eventlog6_EvtRpcGetClassicLogDisplayName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_eventlog6, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
/**
* open connection so SAMR + Join Domain
* common code needed when adding or removing users
*/
static enum MAPISTATUS mapiadmin_samr_connect(struct mapiadmin_ctx *mapiadmin_ctx,
TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
struct tevent_context *ev;
struct mapi_context *mapi_ctx;
struct mapi_profile *profile;
struct samr_Connect c;
struct samr_OpenDomain o;
struct samr_LookupDomain l;
struct policy_handle handle;
struct policy_handle domain_handle;
struct lsa_String name;
MAPI_RETVAL_IF(!mapiadmin_ctx, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session->profile, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session->profile->credentials, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->username, MAPI_E_NOT_INITIALIZED, NULL);
mapi_ctx = mapiadmin_ctx->session->mapi_ctx;
MAPI_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
profile = mapiadmin_ctx->session->profile;
mapiadmin_ctx->user_ctx = talloc_zero(mem_ctx, struct test_join);
MAPI_RETVAL_IF(!mapiadmin_ctx->user_ctx, MAPI_E_NOT_ENOUGH_RESOURCES ,NULL);
OC_DEBUG(3, "Connecting to SAMR");
ev = tevent_context_init(mem_ctx);
status = dcerpc_pipe_connect(mapiadmin_ctx->user_ctx,
&mapiadmin_ctx->user_ctx->p,
mapiadmin_ctx->dc_binding ?
mapiadmin_ctx->dc_binding :
mapiadmin_ctx->binding,
&ndr_table_samr,
profile->credentials, ev, mapi_ctx->lp_ctx);
MAPI_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, NULL);
profile = mapiadmin_ctx->session->profile;
c.in.system_name = NULL;
c.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
c.out.connect_handle = &handle;
status = dcerpc_samr_Connect_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &c);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mapiadmin_ctx->user_ctx, mapiadmin_ctx->user_ctx->p->last_fault_code);
}
OC_DEBUG(3, "samr_Connect failed - %s", errstr);
return MAPI_E_CALL_FAILED;
}
OC_DEBUG(3, "Opening domain %s", profile->domain);
name.string = profile->domain;
l.in.connect_handle = &handle;
l.in.domain_name = &name;
l.out.sid = talloc(mem_ctx, struct dom_sid2 *);
talloc_steal(mapiadmin_ctx->user_ctx, l.out.sid);
status = dcerpc_samr_LookupDomain_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &l);
if (!NT_STATUS_IS_OK(status)) {
OC_DEBUG(3, "LookupDomain failed - %s", nt_errstr(status));
return MAPI_E_CALL_FAILED;
}
mapiadmin_ctx->user_ctx->dom_sid = *l.out.sid;
mapiadmin_ctx->user_ctx->dom_netbios_name = talloc_strdup(mapiadmin_ctx->user_ctx, profile->domain);
if (!mapiadmin_ctx->user_ctx->dom_netbios_name) return MAPI_E_CALL_FAILED;
o.in.connect_handle = &handle;
o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
o.in.sid = *l.out.sid;
o.out.domain_handle = &domain_handle;
status = dcerpc_samr_OpenDomain_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &o);
if (!NT_STATUS_IS_OK(status)) {
OC_DEBUG(3, "OpenDomain failed - %s", nt_errstr(status));
return MAPI_E_CALL_FAILED;
}
mapiadmin_ctx->handle = talloc_memdup(mem_ctx, &domain_handle, sizeof (struct policy_handle));
errno = 0;
return MAPI_E_SUCCESS;
}
static NTSTATUS rot__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct rot_add *r2 = (struct rot_add *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_add replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_add, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_add\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct rot_remove *r2 = (struct rot_remove *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_remove replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_remove, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_remove\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct rot_is_listed *r2 = (struct rot_is_listed *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_is_listed replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_is_listed, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_is_listed\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct rot_get_interface_pointer *r2 = (struct rot_get_interface_pointer *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_get_interface_pointer replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_get_interface_pointer, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_get_interface_pointer\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct rot_set_modification_time *r2 = (struct rot_set_modification_time *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_set_modification_time replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_set_modification_time, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_set_modification_time\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct rot_get_modification_time *r2 = (struct rot_get_modification_time *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_get_modification_time replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_get_modification_time, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_get_modification_time\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct rot_enum *r2 = (struct rot_enum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function rot_enum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(rot_enum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in rot_enum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_rot, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static bool test_DsCrackNamesMatrix(struct torture_context *tctx,
struct DsPrivate *priv, const char *dn,
const char *user_principal_name, const char *service_principal_name)
{
NTSTATUS status;
const char *err_msg;
struct drsuapi_DsCrackNames r;
union drsuapi_DsNameRequest req;
int32_t level_out;
union drsuapi_DsNameCtr ctr;
struct dcerpc_pipe *p = priv->drs_pipe;
TALLOC_CTX *mem_ctx = priv;
enum drsuapi_DsNameFormat formats[] = {
DRSUAPI_DS_NAME_FORMAT_UNKNOWN,
DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT,
DRSUAPI_DS_NAME_FORMAT_DISPLAY,
DRSUAPI_DS_NAME_FORMAT_GUID,
DRSUAPI_DS_NAME_FORMAT_CANONICAL,
DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX,
DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY,
DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN
};
struct drsuapi_DsNameString names[ARRAY_SIZE(formats)];
int i, j;
const char *n_matrix[ARRAY_SIZE(formats)][ARRAY_SIZE(formats)];
const char *n_from[ARRAY_SIZE(formats)];
ZERO_STRUCT(r);
r.in.bind_handle = &priv->bind_handle;
r.in.level = 1;
r.in.req = &req;
r.in.req->req1.codepage = 1252; /* german */
r.in.req->req1.language = 0x00000407; /* german */
r.in.req->req1.count = 1;
r.in.req->req1.names = names;
r.in.req->req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
r.out.level_out = &level_out;
r.out.ctr = &ctr;
n_matrix[0][0] = dn;
for (i = 0; i < ARRAY_SIZE(formats); i++) {
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
r.in.req->req1.format_desired = formats[i];
names[0].str = dn;
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx,
"testing DsCrackNames (matrix prep) with name '%s' from format: %d desired format:%d failed - %s",
names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx,
"testing DsCrackNames (matrix prep) with name '%s' from format: %d desired format:%d failed - %s",
names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, win_errstr(r.out.result));
torture_fail(tctx, err_msg);
}
switch (formats[i]) {
case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:
if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE) {
err_msg = talloc_asprintf(mem_ctx,
"Unexpected error (%d): This name lookup should fail",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
torture_comment(tctx, __location__ ": (expected) error\n");
break;
case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_NO_MAPPING) {
err_msg = talloc_asprintf(mem_ctx,
"Unexpected error (%d): This name lookup should fail",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
torture_comment(tctx, __location__ ": (expected) error\n");
break;
case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: /* should fail as we ask server to convert to Unknown format */
case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN:
case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY:
if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR) {
err_msg = talloc_asprintf(mem_ctx,
"Unexpected error (%d): This name lookup should fail",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
torture_comment(tctx, __location__ ": (expected) error\n");
break;
default:
if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx,
"DsCrackNames error: %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
break;
}
switch (formats[i]) {
case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
n_from[i] = user_principal_name;
break;
case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:
n_from[i] = service_principal_name;
break;
case DRSUAPI_DS_NAME_FORMAT_UNKNOWN:
case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY:
case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN:
n_from[i] = NULL;
break;
default:
n_from[i] = r.out.ctr->ctr1->array[0].result_name;
printf("%s\n", n_from[i]);
break;
}
}
for (i = 0; i < ARRAY_SIZE(formats); i++) {
for (j = 0; j < ARRAY_SIZE(formats); j++) {
r.in.req->req1.format_offered = formats[i];
r.in.req->req1.format_desired = formats[j];
if (!n_from[i]) {
n_matrix[i][j] = NULL;
continue;
}
names[0].str = n_from[i];
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx,
"testing DsCrackNames (matrix) with name '%s' from format: %d desired format:%d failed - %s",
names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired, errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx,
"testing DsCrackNames (matrix) with name '%s' from format: %d desired format:%d failed - %s",
names[0].str, r.in.req->req1.format_offered, r.in.req->req1.format_desired,
win_errstr(r.out.result));
torture_fail(tctx, err_msg);
}
if (r.out.ctr->ctr1->array[0].status == DRSUAPI_DS_NAME_STATUS_OK) {
n_matrix[i][j] = r.out.ctr->ctr1->array[0].result_name;
} else {
n_matrix[i][j] = NULL;
}
}
}
for (i = 0; i < ARRAY_SIZE(formats); i++) {
for (j = 0; j < ARRAY_SIZE(formats); j++) {
if (n_matrix[i][j] == n_from[j]) {
/* We don't have a from name for these yet (and we can't map to them to find it out) */
} else if (n_matrix[i][j] == NULL && n_from[i] == NULL) {
/* we can't map to these two */
} else if (n_matrix[i][j] == NULL && formats[j] == DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL) {
} else if (n_matrix[i][j] == NULL && formats[j] == DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL) {
} else if (n_matrix[i][j] == NULL && n_from[j] != NULL) {
err_msg = talloc_asprintf(mem_ctx,
"dcerpc_drsuapi_DsCrackNames mismatch - from %d to %d: %s should be %s",
formats[i], formats[j], n_matrix[i][j], n_from[j]);
torture_fail(tctx, err_msg);
} else if (n_matrix[i][j] != NULL && n_from[j] == NULL) {
err_msg = talloc_asprintf(mem_ctx,
"dcerpc_drsuapi_DsCrackNames mismatch - from %d to %d: %s should be %s",
formats[i], formats[j], n_matrix[i][j], n_from[j]);
torture_fail(tctx, err_msg);
} else if (strcmp(n_matrix[i][j], n_from[j]) != 0) {
err_msg = talloc_asprintf(mem_ctx,
"dcerpc_drsuapi_DsCrackNames mismatch - from %d to %d: %s should be %s",
formats[i], formats[j], n_matrix[i][j], n_from[j]);
torture_fail(tctx, err_msg);
}
}
}
return true;
}
bool test_DsCrackNames(struct torture_context *tctx,
struct DsPrivate *priv)
{
NTSTATUS status;
const char *err_msg;
struct drsuapi_DsCrackNames r;
union drsuapi_DsNameRequest req;
int32_t level_out;
union drsuapi_DsNameCtr ctr;
struct drsuapi_DsNameString names[1];
const char *dns_domain;
const char *nt4_domain;
const char *FQDN_1779_name;
struct ldb_context *ldb;
struct ldb_dn *FQDN_1779_dn;
struct ldb_dn *realm_dn;
const char *realm_dn_str;
const char *realm_canonical;
const char *realm_canonical_ex;
const char *user_principal_name;
char *user_principal_name_short;
const char *service_principal_name;
const char *canonical_name;
const char *canonical_ex_name;
const char *dom_sid;
const char *test_dc = torture_join_netbios_name(priv->join);
struct dcerpc_pipe *p = priv->drs_pipe;
TALLOC_CTX *mem_ctx = priv;
ZERO_STRUCT(r);
r.in.bind_handle = &priv->bind_handle;
r.in.level = 1;
r.in.req = &req;
r.in.req->req1.codepage = 1252; /* german */
r.in.req->req1.language = 0x00000407; /* german */
r.in.req->req1.count = 1;
r.in.req->req1.names = names;
r.in.req->req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
r.out.level_out = &level_out;
r.out.ctr = &ctr;
dom_sid = dom_sid_string(mem_ctx, torture_join_sid(priv->join));
names[0].str = dom_sid;
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
dns_domain = r.out.ctr->ctr1->array[0].dns_domain_name;
nt4_domain = r.out.ctr->ctr1->array[0].result_name;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_GUID;
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
priv->domain_dns_name = r.out.ctr->ctr1->array[0].dns_domain_name;
priv->domain_guid_str = r.out.ctr->ctr1->array[0].result_name;
GUID_from_string(priv->domain_guid_str, &priv->domain_guid);
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
ldb = ldb_init(mem_ctx, tctx->ev);
realm_dn_str = r.out.ctr->ctr1->array[0].result_name;
realm_dn = ldb_dn_new(mem_ctx, ldb, realm_dn_str);
realm_canonical = ldb_dn_canonical_string(mem_ctx, realm_dn);
if (strcmp(realm_canonical,
talloc_asprintf(mem_ctx, "%s/", dns_domain))!= 0) {
err_msg = talloc_asprintf(mem_ctx, "local Round trip on canonical name failed: %s != %s!",
realm_canonical,
talloc_asprintf(mem_ctx, "%s/", dns_domain));
torture_fail(tctx, err_msg);
};
realm_canonical_ex = ldb_dn_canonical_ex_string(mem_ctx, realm_dn);
if (strcmp(realm_canonical_ex,
talloc_asprintf(mem_ctx, "%s\n", dns_domain))!= 0) {
err_msg = talloc_asprintf(mem_ctx, "local Round trip on canonical ex name failed: %s != %s!",
realm_canonical,
talloc_asprintf(mem_ctx, "%s\n", dns_domain));
torture_fail(tctx, err_msg);
};
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
names[0].str = nt4_domain;
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
priv->domain_obj_dn = r.out.ctr->ctr1->array[0].result_name;
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
names[0].str = talloc_asprintf(mem_ctx, "%s%s$", nt4_domain, test_dc);
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
FQDN_1779_name = r.out.ctr->ctr1->array[0].result_name;
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_GUID;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
names[0].str = priv->domain_guid_str;
torture_comment(tctx, "testing DsCrackNames with name '%s' desired format:%d\n",
names[0].str, r.in.req->req1.format_desired);
status = dcerpc_drsuapi_DsCrackNames(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mem_ctx, p->last_fault_code);
}
err_msg = talloc_asprintf(mem_ctx, "dcerpc_drsuapi_DsCrackNames failed - %s", errstr);
torture_fail(tctx, err_msg);
} else if (!W_ERROR_IS_OK(r.out.result)) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed - %s", win_errstr(r.out.result));
torture_fail(tctx, err_msg);
} else if (r.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
err_msg = talloc_asprintf(mem_ctx, "DsCrackNames failed on name - %d",
r.out.ctr->ctr1->array[0].status);
torture_fail(tctx, err_msg);
}
if (strcmp(priv->domain_dns_name, r.out.ctr->ctr1->array[0].dns_domain_name) != 0) {
err_msg = talloc_asprintf(mem_ctx,
"DsCrackNames failed to return same DNS name - expected %s got %s",
priv->domain_dns_name, r.out.ctr->ctr1->array[0].dns_domain_name);
torture_fail(tctx, err_msg);
}
FQDN_1779_dn = ldb_dn_new(mem_ctx, ldb, FQDN_1779_name);
canonical_name = ldb_dn_canonical_string(mem_ctx, FQDN_1779_dn);
canonical_ex_name = ldb_dn_canonical_ex_string(mem_ctx, FQDN_1779_dn);
user_principal_name = talloc_asprintf(mem_ctx, "%s$@%s", test_dc, dns_domain);
/* form up a user@DOMAIN */
user_principal_name_short = talloc_asprintf(mem_ctx, "%s$@%s", test_dc, nt4_domain);
/* variable nt4_domain includs a trailing \ */
user_principal_name_short[strlen(user_principal_name_short) - 1] = '\0';
service_principal_name = talloc_asprintf(mem_ctx, "HOST/%s", test_dc);
{
struct {
enum drsuapi_DsNameFormat format_offered;
enum drsuapi_DsNameFormat format_desired;
const char *comment;
const char *str;
const char *expected_str;
const char *expected_dns;
enum drsuapi_DsNameStatus status;
enum drsuapi_DsNameStatus alternate_status;
enum drsuapi_DsNameFlags flags;
bool skip;
} crack[] = {
{
.format_offered = DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
.str = user_principal_name,
.expected_str = FQDN_1779_name,
.status = DRSUAPI_DS_NAME_STATUS_OK
},
{
.format_offered = DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
.str = user_principal_name_short,
.expected_str = FQDN_1779_name,
.status = DRSUAPI_DS_NAME_STATUS_OK
},
{
.format_offered = DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
static NTSTATUS epmapper__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct epm_Insert *r2 = (struct epm_Insert *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Insert replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_Insert, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_Insert\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct epm_Delete *r2 = (struct epm_Delete *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Delete replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_Delete, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_Delete\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct epm_Lookup *r2 = (struct epm_Lookup *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Lookup replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_Lookup, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_Lookup\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct epm_Map *r2 = (struct epm_Map *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Map replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_Map, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_Map\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct epm_LookupHandleFree *r2 = (struct epm_LookupHandleFree *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_LookupHandleFree replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_LookupHandleFree, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_LookupHandleFree\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct epm_InqObject *r2 = (struct epm_InqObject *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_InqObject replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_InqObject, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_InqObject\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct epm_MgmtDelete *r2 = (struct epm_MgmtDelete *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_MgmtDelete replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_MgmtDelete, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_MgmtDelete\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct epm_MapAuth *r2 = (struct epm_MapAuth *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_MapAuth replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(epm_MapAuth, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in epm_MapAuth\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_epmapper, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
static NTSTATUS dssetup__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct dssetup_DsRoleGetPrimaryDomainInformation *r2 = (struct dssetup_DsRoleGetPrimaryDomainInformation *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetPrimaryDomainInformation replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleGetPrimaryDomainInformation\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct dssetup_DsRoleDnsNameToFlatName *r2 = (struct dssetup_DsRoleDnsNameToFlatName *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDnsNameToFlatName replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDnsNameToFlatName, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleDnsNameToFlatName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct dssetup_DsRoleDcAsDc *r2 = (struct dssetup_DsRoleDcAsDc *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDcAsDc replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDcAsDc, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleDcAsDc\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct dssetup_DsRoleDcAsReplica *r2 = (struct dssetup_DsRoleDcAsReplica *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDcAsReplica replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDcAsReplica, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleDcAsReplica\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct dssetup_DsRoleDemoteDc *r2 = (struct dssetup_DsRoleDemoteDc *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDemoteDc replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDemoteDc, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleDemoteDc\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct dssetup_DsRoleGetDcOperationProgress *r2 = (struct dssetup_DsRoleGetDcOperationProgress *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetDcOperationProgress replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetDcOperationProgress, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleGetDcOperationProgress\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct dssetup_DsRoleGetDcOperationResults *r2 = (struct dssetup_DsRoleGetDcOperationResults *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetDcOperationResults replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetDcOperationResults, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleGetDcOperationResults\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct dssetup_DsRoleCancel *r2 = (struct dssetup_DsRoleCancel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleCancel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleCancel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleCancel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 8: {
struct dssetup_DsRoleServerSaveStateForUpgrade *r2 = (struct dssetup_DsRoleServerSaveStateForUpgrade *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleServerSaveStateForUpgrade replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleServerSaveStateForUpgrade\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 9: {
struct dssetup_DsRoleUpgradeDownlevelServer *r2 = (struct dssetup_DsRoleUpgradeDownlevelServer *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleUpgradeDownlevelServer replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleUpgradeDownlevelServer\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 10: {
struct dssetup_DsRoleAbortDownlevelServerUpgrade *r2 = (struct dssetup_DsRoleAbortDownlevelServerUpgrade *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleAbortDownlevelServerUpgrade replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in dssetup_DsRoleAbortDownlevelServerUpgrade\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_dssetup, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
/*
* complete a domain join, when joining to a AD domain:
* 1.) connect and bind to the DRSUAPI pipe
* 2.) do a DsCrackNames() to find the machine account dn
* 3.) connect to LDAP
* 4.) do an ldap search to find the "msDS-KeyVersionNumber" of the machine account
* 5.) set the servicePrincipalName's of the machine account via LDAP, (maybe we should use DsWriteAccountSpn()...)
* 6.) do a DsCrackNames() to find the domain dn
* 7.) find out Site specific stuff, look at libnet_JoinSite() for details
*/
static NTSTATUS libnet_JoinADSDomain(struct libnet_context *ctx, struct libnet_JoinDomain *r)
{
NTSTATUS status;
TALLOC_CTX *tmp_ctx;
const char *realm = r->out.realm;
struct dcerpc_binding *samr_binding = r->out.samr_binding;
struct dcerpc_pipe *drsuapi_pipe;
struct dcerpc_binding *drsuapi_binding;
struct drsuapi_DsBind r_drsuapi_bind;
struct drsuapi_DsCrackNames r_crack_names;
struct drsuapi_DsNameString names[1];
struct policy_handle drsuapi_bind_handle;
struct GUID drsuapi_bind_guid;
struct ldb_context *remote_ldb;
struct ldb_dn *account_dn;
const char *account_dn_str;
const char *remote_ldb_url;
struct ldb_result *res;
struct ldb_message *msg;
int ret, rtn;
const char * const attrs[] = {
"msDS-KeyVersionNumber",
"servicePrincipalName",
"dNSHostName",
"objectGUID",
NULL,
};
r->out.error_string = NULL;
/* We need to convert between a samAccountName and domain to a
* DN in the directory. The correct way to do this is with
* DRSUAPI CrackNames */
/* Fiddle with the bindings, so get to DRSUAPI on
* NCACN_IP_TCP, sealed */
tmp_ctx = talloc_named(r, 0, "libnet_JoinADSDomain temp context");
if (!tmp_ctx) {
r->out.error_string = NULL;
return NT_STATUS_NO_MEMORY;
}
drsuapi_binding = talloc(tmp_ctx, struct dcerpc_binding);
if (!drsuapi_binding) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
*drsuapi_binding = *samr_binding;
/* DRSUAPI is only available on IP_TCP, and locally on NCALRPC */
if (drsuapi_binding->transport != NCALRPC) {
drsuapi_binding->transport = NCACN_IP_TCP;
}
drsuapi_binding->endpoint = NULL;
drsuapi_binding->flags |= DCERPC_SEAL;
status = dcerpc_pipe_connect_b(tmp_ctx,
&drsuapi_pipe,
drsuapi_binding,
&ndr_table_drsuapi,
ctx->cred,
ctx->event_ctx,
ctx->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
r->out.error_string = talloc_asprintf(r,
"Connection to DRSUAPI pipe of PDC of domain '%s' failed: %s",
r->out.domain_name,
nt_errstr(status));
talloc_free(tmp_ctx);
return status;
}
/* get a DRSUAPI pipe handle */
GUID_from_string(DRSUAPI_DS_BIND_GUID, &drsuapi_bind_guid);
r_drsuapi_bind.in.bind_guid = &drsuapi_bind_guid;
r_drsuapi_bind.in.bind_info = NULL;
r_drsuapi_bind.out.bind_handle = &drsuapi_bind_handle;
status = dcerpc_drsuapi_DsBind(drsuapi_pipe, tmp_ctx, &r_drsuapi_bind);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsBind failed - %s",
dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
talloc_free(tmp_ctx);
return status;
} else {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsBind failed - %s",
nt_errstr(status));
talloc_free(tmp_ctx);
return status;
}
} else if (!W_ERROR_IS_OK(r_drsuapi_bind.out.result)) {
r->out.error_string
= talloc_asprintf(r,
"DsBind failed - %s",
win_errstr(r_drsuapi_bind.out.result));
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
/* Actually 'crack' the names */
ZERO_STRUCT(r_crack_names);
r_crack_names.in.bind_handle = &drsuapi_bind_handle;
r_crack_names.in.level = 1;
r_crack_names.in.req = talloc(r, union drsuapi_DsNameRequest);
if (!r_crack_names.in.req) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
r_crack_names.in.req->req1.codepage = 1252; /* western european */
r_crack_names.in.req->req1.language = 0x00000407; /* german */
r_crack_names.in.req->req1.count = 1;
r_crack_names.in.req->req1.names = names;
r_crack_names.in.req->req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
r_crack_names.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
r_crack_names.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
names[0].str = dom_sid_string(tmp_ctx, r->out.account_sid);
if (!names[0].str) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
r_crack_names.out.ctr = talloc(r, union drsuapi_DsNameCtr);
r_crack_names.out.level_out = talloc(r, int32_t);
if (!r_crack_names.out.ctr || !r_crack_names.out.level_out) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
status = dcerpc_drsuapi_DsCrackNames(drsuapi_pipe, tmp_ctx, &r_crack_names);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
names[0].str,
dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
talloc_free(tmp_ctx);
return status;
} else {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
names[0].str,
nt_errstr(status));
talloc_free(tmp_ctx);
return status;
}
} else if (!W_ERROR_IS_OK(r_crack_names.out.result)) {
r->out.error_string
= talloc_asprintf(r,
"DsCrackNames failed - %s", win_errstr(r_crack_names.out.result));
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
} else if (*r_crack_names.out.level_out != 1
|| !r_crack_names.out.ctr->ctr1
|| r_crack_names.out.ctr->ctr1->count != 1) {
r->out.error_string = talloc_asprintf(r, "DsCrackNames failed");
talloc_free(tmp_ctx);
return NT_STATUS_INVALID_PARAMETER;
} else if (r_crack_names.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
r->out.error_string = talloc_asprintf(r, "DsCrackNames failed: %d", r_crack_names.out.ctr->ctr1->array[0].status);
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
} else if (r_crack_names.out.ctr->ctr1->array[0].result_name == NULL) {
r->out.error_string = talloc_asprintf(r, "DsCrackNames failed: no result name");
talloc_free(tmp_ctx);
return NT_STATUS_INVALID_PARAMETER;
}
/* Store the DN of our machine account. */
account_dn_str = r_crack_names.out.ctr->ctr1->array[0].result_name;
/* Now we know the user's DN, open with LDAP, read and modify a few things */
remote_ldb_url = talloc_asprintf(tmp_ctx, "ldap://%s",
drsuapi_binding->target_hostname);
if (!remote_ldb_url) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
remote_ldb = ldb_wrap_connect(tmp_ctx, ctx->event_ctx, ctx->lp_ctx,
remote_ldb_url,
NULL, ctx->cred, 0, NULL);
if (!remote_ldb) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
account_dn = ldb_dn_new(tmp_ctx, remote_ldb, account_dn_str);
if (! ldb_dn_validate(account_dn)) {
r->out.error_string = talloc_asprintf(r, "Invalid account dn: %s",
account_dn_str);
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
/* search for the user's record */
ret = ldb_search(remote_ldb, tmp_ctx, &res,
account_dn, LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
r->out.error_string = talloc_asprintf(r, "ldb_search for %s failed - %s",
account_dn_str, ldb_errstring(remote_ldb));
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
if (res->count != 1) {
r->out.error_string = talloc_asprintf(r, "ldb_search for %s failed - found %d entries",
account_dn_str, res->count);
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
/* Prepare a new message, for the modify */
msg = ldb_msg_new(tmp_ctx);
if (!msg) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
msg->dn = res->msgs[0]->dn;
{
int i;
const char *service_principal_name[6];
const char *dns_host_name = strlower_talloc(tmp_ctx,
talloc_asprintf(tmp_ctx,
"%s.%s",
r->in.netbios_name,
realm));
if (!dns_host_name) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
service_principal_name[0] = talloc_asprintf(tmp_ctx, "host/%s", dns_host_name);
service_principal_name[1] = talloc_asprintf(tmp_ctx, "host/%s", strlower_talloc(tmp_ctx, r->in.netbios_name));
service_principal_name[2] = talloc_asprintf(tmp_ctx, "host/%s/%s", dns_host_name, realm);
service_principal_name[3] = talloc_asprintf(tmp_ctx, "host/%s/%s", strlower_talloc(tmp_ctx, r->in.netbios_name), realm);
service_principal_name[4] = talloc_asprintf(tmp_ctx, "host/%s/%s", dns_host_name, r->out.domain_name);
service_principal_name[5] = talloc_asprintf(tmp_ctx, "host/%s/%s", strlower_talloc(tmp_ctx, r->in.netbios_name), r->out.domain_name);
for (i=0; i < ARRAY_SIZE(service_principal_name); i++) {
if (!service_principal_name[i]) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
rtn = samdb_msg_add_string(remote_ldb, tmp_ctx, msg, "servicePrincipalName", service_principal_name[i]);
if (rtn == -1) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
}
rtn = samdb_msg_add_string(remote_ldb, tmp_ctx, msg, "dNSHostName", dns_host_name);
if (rtn == -1) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
rtn = samdb_replace(remote_ldb, tmp_ctx, msg);
if (rtn != 0) {
r->out.error_string
= talloc_asprintf(r,
"Failed to replace entries on %s",
ldb_dn_get_linearized(msg->dn));
talloc_free(tmp_ctx);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
}
/* DsCrackNames to find out the DN of the domain. */
r_crack_names.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
r_crack_names.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
names[0].str = talloc_asprintf(tmp_ctx, "%s\\", r->out.domain_name);
if (!names[0].str) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
status = dcerpc_drsuapi_DsCrackNames(drsuapi_pipe, tmp_ctx, &r_crack_names);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
r->in.domain_name,
dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
talloc_free(tmp_ctx);
return status;
} else {
r->out.error_string
= talloc_asprintf(r,
"dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
r->in.domain_name,
nt_errstr(status));
talloc_free(tmp_ctx);
return status;
}
} else if (!W_ERROR_IS_OK(r_crack_names.out.result)) {
r->out.error_string
= talloc_asprintf(r,
"DsCrackNames failed - %s", win_errstr(r_crack_names.out.result));
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
} else if (*r_crack_names.out.level_out != 1
|| !r_crack_names.out.ctr->ctr1
|| r_crack_names.out.ctr->ctr1->count != 1
|| !r_crack_names.out.ctr->ctr1->array[0].result_name
|| r_crack_names.out.ctr->ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {
r->out.error_string = talloc_asprintf(r, "DsCrackNames failed");
talloc_free(tmp_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
/* Store the account DN. */
r->out.account_dn_str = account_dn_str;
talloc_steal(r, account_dn_str);
/* Store the domain DN. */
r->out.domain_dn_str = r_crack_names.out.ctr->ctr1->array[0].result_name;
talloc_steal(r, r_crack_names.out.ctr->ctr1->array[0].result_name);
/* Store the KVNO of the account, critical for some kerberos
* operations */
r->out.kvno = ldb_msg_find_attr_as_uint(res->msgs[0], "msDS-KeyVersionNumber", 0);
/* Store the account GUID. */
r->out.account_guid = samdb_result_guid(res->msgs[0], "objectGUID");
if (r->in.acct_type == ACB_SVRTRUST) {
status = libnet_JoinSite(ctx, remote_ldb, r);
}
talloc_free(tmp_ctx);
return status;
}
static NTSTATUS atsvc__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct atsvc_JobAdd *r2 = (struct atsvc_JobAdd *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function atsvc_JobAdd replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(atsvc_JobAdd, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in atsvc_JobAdd\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct atsvc_JobDel *r2 = (struct atsvc_JobDel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function atsvc_JobDel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(atsvc_JobDel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in atsvc_JobDel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct atsvc_JobEnum *r2 = (struct atsvc_JobEnum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function atsvc_JobEnum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(atsvc_JobEnum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in atsvc_JobEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct atsvc_JobGetInfo *r2 = (struct atsvc_JobGetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function atsvc_JobGetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(atsvc_JobGetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in atsvc_JobGetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_atsvc, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
/*
process a fragment received from the transport layer during a
request
This function frees the data
*/
static void dcerpc_request_recv_data(struct dcerpc_connection *c,
DATA_BLOB *raw_packet, struct ncacn_packet *pkt)
{
struct rpc_request *req;
unsigned int length;
NTSTATUS status = NT_STATUS_OK;
/*
if this is an authenticated connection then parse and check
the auth info. We have to do this before finding the
matching packet, as the request structure might have been
removed due to a timeout, but if it has been we still need
to run the auth routines so that we don't get the sign/seal
info out of step with the server
*/
if (c->security_state.auth_info && c->security_state.generic_state &&
pkt->ptype == DCERPC_PKT_RESPONSE) {
status = ncacn_pull_request_auth(c, raw_packet->data, raw_packet, pkt);
}
/* find the matching request */
for (req=c->pending;req;req=req->next) {
if (pkt->call_id == req->call_id) break;
}
#if 0
/* useful for testing certain vendors RPC servers */
if (req == NULL && c->pending && pkt->call_id == 0) {
DEBUG(0,("HACK FOR INCORRECT CALL ID\n"));
req = c->pending;
}
#endif
if (req == NULL) {
DEBUG(2,("dcerpc_request: unmatched call_id %u in response packet\n", pkt->call_id));
data_blob_free(raw_packet);
return;
}
talloc_steal(req, raw_packet->data);
if (req->recv_handler != NULL) {
dcerpc_req_dequeue(req);
req->state = RPC_REQUEST_DONE;
req->recv_handler(req, raw_packet, pkt);
return;
}
if (pkt->ptype == DCERPC_PKT_FAULT) {
DEBUG(5,("rpc fault: %s\n", dcerpc_errstr(c, pkt->u.fault.status)));
req->fault_code = pkt->u.fault.status;
req->status = NT_STATUS_NET_WRITE_FAULT;
goto req_done;
}
if (pkt->ptype != DCERPC_PKT_RESPONSE) {
DEBUG(2,("Unexpected packet type %d in dcerpc response\n",
(int)pkt->ptype));
req->fault_code = DCERPC_FAULT_OTHER;
req->status = NT_STATUS_NET_WRITE_FAULT;
goto req_done;
}
/* now check the status from the auth routines, and if it failed then fail
this request accordingly */
if (!NT_STATUS_IS_OK(status)) {
req->status = status;
goto req_done;
}
length = pkt->u.response.stub_and_verifier.length;
if (length > 0) {
req->payload.data = talloc_realloc(req,
req->payload.data,
uint8_t,
req->payload.length + length);
if (!req->payload.data) {
req->status = NT_STATUS_NO_MEMORY;
goto req_done;
}
memcpy(req->payload.data+req->payload.length,
pkt->u.response.stub_and_verifier.data, length);
req->payload.length += length;
}
if (!(pkt->pfc_flags & DCERPC_PFC_FLAG_LAST)) {
c->transport.send_read(c);
return;
}
if (!(pkt->drep[0] & DCERPC_DREP_LE)) {
req->flags |= DCERPC_PULL_BIGENDIAN;
} else {
req->flags &= ~DCERPC_PULL_BIGENDIAN;
}
req_done:
/* we've got the full payload */
req->state = RPC_REQUEST_DONE;
DLIST_REMOVE(c->pending, req);
if (c->request_queue != NULL) {
/* We have to look at shipping further requests before calling
* the async function, that one might close the pipe */
dcerpc_ship_next_request(c);
}
if (req->async.callback) {
req->async.callback(req);
}
}
static NTSTATUS wkssvc__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
{
uint16_t opnum = dce_call->pkt.u.request.opnum;
switch (opnum) {
case 0: {
struct wkssvc_NetWkstaGetInfo *r2 = (struct wkssvc_NetWkstaGetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaGetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaGetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetWkstaGetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 1: {
struct wkssvc_NetWkstaSetInfo *r2 = (struct wkssvc_NetWkstaSetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaSetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaSetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetWkstaSetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 2: {
struct wkssvc_NetWkstaEnumUsers *r2 = (struct wkssvc_NetWkstaEnumUsers *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaEnumUsers replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaEnumUsers, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetWkstaEnumUsers\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 3: {
struct wkssvc_NetrWkstaUserGetInfo *r2 = (struct wkssvc_NetrWkstaUserGetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaUserGetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaUserGetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrWkstaUserGetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 4: {
struct wkssvc_NetrWkstaUserSetInfo *r2 = (struct wkssvc_NetrWkstaUserSetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaUserSetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaUserSetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrWkstaUserSetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 5: {
struct wkssvc_NetWkstaTransportEnum *r2 = (struct wkssvc_NetWkstaTransportEnum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaTransportEnum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaTransportEnum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetWkstaTransportEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 6: {
struct wkssvc_NetrWkstaTransportAdd *r2 = (struct wkssvc_NetrWkstaTransportAdd *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaTransportAdd replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaTransportAdd, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrWkstaTransportAdd\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 7: {
struct wkssvc_NetrWkstaTransportDel *r2 = (struct wkssvc_NetrWkstaTransportDel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaTransportDel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaTransportDel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrWkstaTransportDel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 8: {
struct wkssvc_NetrUseAdd *r2 = (struct wkssvc_NetrUseAdd *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseAdd replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseAdd, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUseAdd\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 9: {
struct wkssvc_NetrUseGetInfo *r2 = (struct wkssvc_NetrUseGetInfo *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseGetInfo replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseGetInfo, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUseGetInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 10: {
struct wkssvc_NetrUseDel *r2 = (struct wkssvc_NetrUseDel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseDel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseDel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUseDel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 11: {
struct wkssvc_NetrUseEnum *r2 = (struct wkssvc_NetrUseEnum *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseEnum replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseEnum, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUseEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 12: {
struct wkssvc_NetrMessageBufferSend *r2 = (struct wkssvc_NetrMessageBufferSend *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrMessageBufferSend replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrMessageBufferSend, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrMessageBufferSend\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 13: {
struct wkssvc_NetrWorkstationStatisticsGet *r2 = (struct wkssvc_NetrWorkstationStatisticsGet *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWorkstationStatisticsGet replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWorkstationStatisticsGet, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrWorkstationStatisticsGet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 14: {
struct wkssvc_NetrLogonDomainNameAdd *r2 = (struct wkssvc_NetrLogonDomainNameAdd *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrLogonDomainNameAdd replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrLogonDomainNameAdd, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrLogonDomainNameAdd\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 15: {
struct wkssvc_NetrLogonDomainNameDel *r2 = (struct wkssvc_NetrLogonDomainNameDel *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrLogonDomainNameDel replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrLogonDomainNameDel, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrLogonDomainNameDel\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 16: {
struct wkssvc_NetrJoinDomain *r2 = (struct wkssvc_NetrJoinDomain *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrJoinDomain replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrJoinDomain, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrJoinDomain\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 17: {
struct wkssvc_NetrUnjoinDomain *r2 = (struct wkssvc_NetrUnjoinDomain *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUnjoinDomain replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUnjoinDomain, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUnjoinDomain\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 18: {
struct wkssvc_NetrRenameMachineInDomain *r2 = (struct wkssvc_NetrRenameMachineInDomain *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRenameMachineInDomain replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRenameMachineInDomain, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrRenameMachineInDomain\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 19: {
struct wkssvc_NetrValidateName *r2 = (struct wkssvc_NetrValidateName *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrValidateName replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrValidateName, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrValidateName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 20: {
struct wkssvc_NetrGetJoinInformation *r2 = (struct wkssvc_NetrGetJoinInformation *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinInformation replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinInformation, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrGetJoinInformation\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 21: {
struct wkssvc_NetrGetJoinableOus *r2 = (struct wkssvc_NetrGetJoinableOus *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinableOus replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinableOus, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrGetJoinableOus\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 22: {
struct wkssvc_NetrJoinDomain2 *r2 = (struct wkssvc_NetrJoinDomain2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrJoinDomain2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrJoinDomain2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrJoinDomain2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 23: {
struct wkssvc_NetrUnjoinDomain2 *r2 = (struct wkssvc_NetrUnjoinDomain2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUnjoinDomain2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUnjoinDomain2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrUnjoinDomain2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 24: {
struct wkssvc_NetrRenameMachineInDomain2 *r2 = (struct wkssvc_NetrRenameMachineInDomain2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRenameMachineInDomain2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRenameMachineInDomain2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrRenameMachineInDomain2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 25: {
struct wkssvc_NetrValidateName2 *r2 = (struct wkssvc_NetrValidateName2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrValidateName2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrValidateName2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrValidateName2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 26: {
struct wkssvc_NetrGetJoinableOus2 *r2 = (struct wkssvc_NetrGetJoinableOus2 *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinableOus2 replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinableOus2, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrGetJoinableOus2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 27: {
struct wkssvc_NetrAddAlternateComputerName *r2 = (struct wkssvc_NetrAddAlternateComputerName *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrAddAlternateComputerName replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrAddAlternateComputerName, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrAddAlternateComputerName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 28: {
struct wkssvc_NetrRemoveAlternateComputerName *r2 = (struct wkssvc_NetrRemoveAlternateComputerName *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRemoveAlternateComputerName replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRemoveAlternateComputerName, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrRemoveAlternateComputerName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 29: {
struct wkssvc_NetrSetPrimaryComputername *r2 = (struct wkssvc_NetrSetPrimaryComputername *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrSetPrimaryComputername replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrSetPrimaryComputername, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrSetPrimaryComputername\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
case 30: {
struct wkssvc_NetrEnumerateComputerNames *r2 = (struct wkssvc_NetrEnumerateComputerNames *)r;
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrEnumerateComputerNames replied async\n"));
}
if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrEnumerateComputerNames, NDR_OUT | NDR_SET_VALUES, r2);
}
if (dce_call->fault_code != 0) {
DEBUG(2,("dcerpc_fault %s in wkssvc_NetrEnumerateComputerNames\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
}
break;
}
default:
dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
break;
}
if (dce_call->fault_code != 0) {
dcerpc_log_packet(dce_call->conn->packet_log_dir,
&ndr_table_wkssvc, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
