static bool api_frstrans_RequestUpdates(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct frstrans_RequestUpdates *r;
call = &ndr_table_frstrans.calls[NDR_FRSTRANS_REQUESTUPDATES];
r = talloc(talloc_tos(), struct frstrans_RequestUpdates);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(frstrans_RequestUpdates, NDR_IN, r);
}
ZERO_STRUCT(r->out);
r->out.frs_update = talloc_zero_array(r, struct frstrans_Update, r->in.credits_available);
if (r->out.frs_update == NULL) {
talloc_free(r);
return false;
}
r->out.update_count = talloc_zero(r, uint32_t);
if (r->out.update_count == NULL) {
talloc_free(r);
return false;
}
r->out.update_status = talloc_zero(r, enum frstrans_UpdateStatus);
if (r->out.update_status == NULL) {
talloc_free(r);
return false;
}
r->out.gvsn_db_guid = talloc_zero(r, struct GUID);
if (r->out.gvsn_db_guid == NULL) {
talloc_free(r);
return false;
}
r->out.gvsn_version = talloc_zero(r, uint64_t);
if (r->out.gvsn_version == NULL) {
talloc_free(r);
return false;
}
r->out.result = _frstrans_RequestUpdates(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(frstrans_RequestUpdates, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static bool api_HrRRestoreRegisterComplete(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct HrRRestoreRegisterComplete *r;
call = &ndr_table_ad_restore.calls[NDR_HRRRESTOREREGISTERCOMPLETE];
r = talloc(talloc_tos(), struct HrRRestoreRegisterComplete);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(HrRRestoreRegisterComplete, NDR_IN, r);
}
_HrRRestoreRegisterComplete(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(HrRRestoreRegisterComplete, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
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;
}
static bool api_frstrans_InitializeFileTransferAsync(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct frstrans_InitializeFileTransferAsync *r;
call = &ndr_table_frstrans.calls[NDR_FRSTRANS_INITIALIZEFILETRANSFERASYNC];
r = talloc(talloc_tos(), struct frstrans_InitializeFileTransferAsync);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(frstrans_InitializeFileTransferAsync, NDR_IN, r);
}
ZERO_STRUCT(r->out);
r->out.frs_update = r->in.frs_update;
r->out.staging_policy = r->in.staging_policy;
r->out.server_context = talloc_zero(r, struct policy_handle);
if (r->out.server_context == NULL) {
talloc_free(r);
return false;
}
r->out.rdc_file_info = talloc_zero(r, struct frstrans_RdcFileInfo *);
if (r->out.rdc_file_info == NULL) {
talloc_free(r);
return false;
}
r->out.data_buffer = talloc_zero_array(r, uint8_t, r->in.buffer_size);
if (r->out.data_buffer == NULL) {
talloc_free(r);
return false;
}
r->out.size_read = talloc_zero(r, uint32_t);
if (r->out.size_read == NULL) {
talloc_free(r);
return false;
}
r->out.is_end_of_file = talloc_zero(r, uint32_t);
if (r->out.is_end_of_file == NULL) {
talloc_free(r);
return false;
}
r->out.result = _frstrans_InitializeFileTransferAsync(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(frstrans_InitializeFileTransferAsync, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static NTSTATUS dssetup__op_dispatch(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 (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleGetPrimaryDomainInformation(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetPrimaryDomainInformation will reply async\n"));
}
break;
}
case 1: {
struct dssetup_DsRoleDnsNameToFlatName *r2 = (struct dssetup_DsRoleDnsNameToFlatName *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDnsNameToFlatName, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleDnsNameToFlatName(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDnsNameToFlatName will reply async\n"));
}
break;
}
case 2: {
struct dssetup_DsRoleDcAsDc *r2 = (struct dssetup_DsRoleDcAsDc *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDcAsDc, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleDcAsDc(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDcAsDc will reply async\n"));
}
break;
}
case 3: {
struct dssetup_DsRoleDcAsReplica *r2 = (struct dssetup_DsRoleDcAsReplica *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDcAsReplica, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleDcAsReplica(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDcAsReplica will reply async\n"));
}
break;
}
case 4: {
struct dssetup_DsRoleDemoteDc *r2 = (struct dssetup_DsRoleDemoteDc *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleDemoteDc, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleDemoteDc(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleDemoteDc will reply async\n"));
}
break;
}
case 5: {
struct dssetup_DsRoleGetDcOperationProgress *r2 = (struct dssetup_DsRoleGetDcOperationProgress *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetDcOperationProgress, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleGetDcOperationProgress(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetDcOperationProgress will reply async\n"));
}
break;
}
case 6: {
struct dssetup_DsRoleGetDcOperationResults *r2 = (struct dssetup_DsRoleGetDcOperationResults *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleGetDcOperationResults, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleGetDcOperationResults(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleGetDcOperationResults will reply async\n"));
}
break;
}
case 7: {
struct dssetup_DsRoleCancel *r2 = (struct dssetup_DsRoleCancel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleCancel, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleCancel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleCancel will reply async\n"));
}
break;
}
case 8: {
struct dssetup_DsRoleServerSaveStateForUpgrade *r2 = (struct dssetup_DsRoleServerSaveStateForUpgrade *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleServerSaveStateForUpgrade(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleServerSaveStateForUpgrade will reply async\n"));
}
break;
}
case 9: {
struct dssetup_DsRoleUpgradeDownlevelServer *r2 = (struct dssetup_DsRoleUpgradeDownlevelServer *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleUpgradeDownlevelServer(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleUpgradeDownlevelServer will reply async\n"));
}
break;
}
case 10: {
struct dssetup_DsRoleAbortDownlevelServerUpgrade *r2 = (struct dssetup_DsRoleAbortDownlevelServerUpgrade *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, NDR_IN, r2);
}
r2->out.result = dcesrv_dssetup_DsRoleAbortDownlevelServerUpgrade(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function dssetup_DsRoleAbortDownlevelServerUpgrade will reply async\n"));
}
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;
}
static NTSTATUS rpcecho__op_dispatch(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 (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_IN, r2);
}
dcesrv_echo_AddOne(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_AddOne will reply async\n"));
}
break;
}
case 1: {
struct echo_EchoData *r2 = (struct echo_EchoData *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_IN, r2);
}
dcesrv_echo_EchoData(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_EchoData will reply async\n"));
}
break;
}
case 2: {
struct echo_SinkData *r2 = (struct echo_SinkData *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_IN, r2);
}
dcesrv_echo_SinkData(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_SinkData will reply async\n"));
}
break;
}
case 3: {
struct echo_SourceData *r2 = (struct echo_SourceData *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_IN, r2);
}
dcesrv_echo_SourceData(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_SourceData will reply async\n"));
}
break;
}
case 4: {
struct echo_TestCall *r2 = (struct echo_TestCall *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_IN, r2);
}
dcesrv_echo_TestCall(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestCall will reply async\n"));
}
break;
}
case 5: {
struct echo_TestCall2 *r2 = (struct echo_TestCall2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_IN, r2);
}
r2->out.result = dcesrv_echo_TestCall2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestCall2 will reply async\n"));
}
break;
}
case 6: {
struct echo_TestSleep *r2 = (struct echo_TestSleep *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_IN, r2);
}
r2->out.result = dcesrv_echo_TestSleep(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestSleep will reply async\n"));
}
break;
}
case 7: {
struct echo_TestEnum *r2 = (struct echo_TestEnum *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_IN, r2);
}
dcesrv_echo_TestEnum(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestEnum will reply async\n"));
}
break;
}
case 8: {
struct echo_TestSurrounding *r2 = (struct echo_TestSurrounding *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_IN, r2);
}
dcesrv_echo_TestSurrounding(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestSurrounding will reply async\n"));
}
break;
}
case 9: {
struct echo_TestDoublePointer *r2 = (struct echo_TestDoublePointer *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_IN, r2);
}
r2->out.result = dcesrv_echo_TestDoublePointer(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function echo_TestDoublePointer will reply async\n"));
}
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;
}
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 bool api_rot_add(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct rot_add *r;
call = &ndr_table_rot.calls[NDR_ROT_ADD];
r = talloc(talloc_tos(), struct rot_add);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(rot_add, NDR_IN, r);
}
ZERO_STRUCT(r->out);
r->out.rotid = talloc_zero(r, uint32_t);
if (r->out.rotid == NULL) {
talloc_free(r);
return false;
}
r->out.result = _rot_add(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(rot_add, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
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;
}
static NTSTATUS eventlog6__op_dispatch(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 (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterRemoteSubscription, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRegisterRemoteSubscription(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterRemoteSubscription will reply async\n"));
}
break;
}
case 1: {
struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionNextAsync *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionNextAsync, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRemoteSubscriptionNextAsync(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionNextAsync will reply async\n"));
}
break;
}
case 2: {
struct eventlog6_EvtRpcRemoteSubscriptionNext *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionNext *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionNext, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRemoteSubscriptionNext(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionNext will reply async\n"));
}
break;
}
case 3: {
struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *r2 = (struct eventlog6_EvtRpcRemoteSubscriptionWaitAsync *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRemoteSubscriptionWaitAsync, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRemoteSubscriptionWaitAsync(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRemoteSubscriptionWaitAsync will reply async\n"));
}
break;
}
case 4: {
struct eventlog6_EvtRpcRegisterControllableOperation *r2 = (struct eventlog6_EvtRpcRegisterControllableOperation *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterControllableOperation, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRegisterControllableOperation(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterControllableOperation will reply async\n"));
}
break;
}
case 5: {
struct eventlog6_EvtRpcRegisterLogQuery *r2 = (struct eventlog6_EvtRpcRegisterLogQuery *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRegisterLogQuery, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRegisterLogQuery(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRegisterLogQuery will reply async\n"));
}
break;
}
case 6: {
struct eventlog6_EvtRpcClearLog *r2 = (struct eventlog6_EvtRpcClearLog *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcClearLog, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcClearLog(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcClearLog will reply async\n"));
}
break;
}
case 7: {
struct eventlog6_EvtRpcExportLog *r2 = (struct eventlog6_EvtRpcExportLog *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcExportLog, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcExportLog(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcExportLog will reply async\n"));
}
break;
}
case 8: {
struct eventlog6_EvtRpcLocalizeExportLog *r2 = (struct eventlog6_EvtRpcLocalizeExportLog *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcLocalizeExportLog, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcLocalizeExportLog(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcLocalizeExportLog will reply async\n"));
}
break;
}
case 9: {
struct eventlog6_EvtRpcMessageRender *r2 = (struct eventlog6_EvtRpcMessageRender *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcMessageRender, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcMessageRender(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcMessageRender will reply async\n"));
}
break;
}
case 10: {
struct eventlog6_EvtRpcMessageRenderDefault *r2 = (struct eventlog6_EvtRpcMessageRenderDefault *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcMessageRenderDefault, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcMessageRenderDefault(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcMessageRenderDefault will reply async\n"));
}
break;
}
case 11: {
struct eventlog6_EvtRpcQueryNext *r2 = (struct eventlog6_EvtRpcQueryNext *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcQueryNext, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcQueryNext(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcQueryNext will reply async\n"));
}
break;
}
case 12: {
struct eventlog6_EvtRpcQuerySeek *r2 = (struct eventlog6_EvtRpcQuerySeek *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcQuerySeek, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcQuerySeek(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcQuerySeek will reply async\n"));
}
break;
}
case 13: {
struct eventlog6_EvtRpcClose *r2 = (struct eventlog6_EvtRpcClose *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcClose, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcClose(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcClose will reply async\n"));
}
break;
}
case 14: {
struct eventlog6_EvtRpcCancel *r2 = (struct eventlog6_EvtRpcCancel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcCancel, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcCancel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcCancel will reply async\n"));
}
break;
}
case 15: {
struct eventlog6_EvtRpcAssertConfig *r2 = (struct eventlog6_EvtRpcAssertConfig *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcAssertConfig, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcAssertConfig(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcAssertConfig will reply async\n"));
}
break;
}
case 16: {
struct eventlog6_EvtRpcRetractConfig *r2 = (struct eventlog6_EvtRpcRetractConfig *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcRetractConfig, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcRetractConfig(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcRetractConfig will reply async\n"));
}
break;
}
case 17: {
struct eventlog6_EvtRpcOpenLogHandle *r2 = (struct eventlog6_EvtRpcOpenLogHandle *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcOpenLogHandle, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcOpenLogHandle(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcOpenLogHandle will reply async\n"));
}
break;
}
case 18: {
struct eventlog6_EvtRpcGetLogFileInfo *r2 = (struct eventlog6_EvtRpcGetLogFileInfo *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetLogFileInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetLogFileInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetLogFileInfo will reply async\n"));
}
break;
}
case 19: {
struct eventlog6_EvtRpcGetChannelList *r2 = (struct eventlog6_EvtRpcGetChannelList *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetChannelList, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetChannelList(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetChannelList will reply async\n"));
}
break;
}
case 20: {
struct eventlog6_EvtRpcGetChannelConfig *r2 = (struct eventlog6_EvtRpcGetChannelConfig *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetChannelConfig, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetChannelConfig(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetChannelConfig will reply async\n"));
}
break;
}
case 21: {
struct eventlog6_EvtRpcPutChannelConfig *r2 = (struct eventlog6_EvtRpcPutChannelConfig *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcPutChannelConfig, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcPutChannelConfig(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcPutChannelConfig will reply async\n"));
}
break;
}
case 22: {
struct eventlog6_EvtRpcGetPublisherList *r2 = (struct eventlog6_EvtRpcGetPublisherList *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherList, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetPublisherList(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherList will reply async\n"));
}
break;
}
case 23: {
struct eventlog6_EvtRpcGetPublisherListForChannel *r2 = (struct eventlog6_EvtRpcGetPublisherListForChannel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherListForChannel, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetPublisherListForChannel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherListForChannel will reply async\n"));
}
break;
}
case 24: {
struct eventlog6_EvtRpcGetPublisherMetadata *r2 = (struct eventlog6_EvtRpcGetPublisherMetadata *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherMetadata, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetPublisherMetadata(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherMetadata will reply async\n"));
}
break;
}
case 25: {
struct eventlog6_EvtRpcGetPublisherResourceMetadata *r2 = (struct eventlog6_EvtRpcGetPublisherResourceMetadata *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetPublisherResourceMetadata, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetPublisherResourceMetadata(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetPublisherResourceMetadata will reply async\n"));
}
break;
}
case 26: {
struct eventlog6_EvtRpcGetEventMetadataEnum *r2 = (struct eventlog6_EvtRpcGetEventMetadataEnum *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetEventMetadataEnum, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetEventMetadataEnum(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetEventMetadataEnum will reply async\n"));
}
break;
}
case 27: {
struct eventlog6_EvtRpcGetNextEventMetadata *r2 = (struct eventlog6_EvtRpcGetNextEventMetadata *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetNextEventMetadata, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetNextEventMetadata(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetNextEventMetadata will reply async\n"));
}
break;
}
case 28: {
struct eventlog6_EvtRpcGetClassicLogDisplayName *r2 = (struct eventlog6_EvtRpcGetClassicLogDisplayName *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog6_EvtRpcGetClassicLogDisplayName, NDR_IN, r2);
}
r2->out.result = dcesrv_eventlog6_EvtRpcGetClassicLogDisplayName(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function eventlog6_EvtRpcGetClassicLogDisplayName will reply async\n"));
}
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;
}
static bool api_RemoteActivation(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct RemoteActivation *r;
call = &ndr_table_IRemoteActivation.calls[NDR_REMOTEACTIVATION];
r = talloc(talloc_tos(), struct RemoteActivation);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(RemoteActivation, NDR_IN, r);
}
ZERO_STRUCT(r->out);
r->out.that = talloc_zero(r, struct ORPCTHAT);
if (r->out.that == NULL) {
talloc_free(r);
return false;
}
r->out.pOxid = talloc_zero(r, uint64_t);
if (r->out.pOxid == NULL) {
talloc_free(r);
return false;
}
r->out.pdsaOxidBindings = talloc_zero(r, struct DUALSTRINGARRAY);
if (r->out.pdsaOxidBindings == NULL) {
talloc_free(r);
return false;
}
r->out.ipidRemUnknown = talloc_zero(r, struct GUID);
if (r->out.ipidRemUnknown == NULL) {
talloc_free(r);
return false;
}
r->out.AuthnHint = talloc_zero(r, uint32_t);
if (r->out.AuthnHint == NULL) {
talloc_free(r);
return false;
}
r->out.ServerVersion = talloc_zero(r, struct COMVERSION);
if (r->out.ServerVersion == NULL) {
talloc_free(r);
return false;
}
r->out.hr = talloc_zero(r, WERROR);
if (r->out.hr == NULL) {
talloc_free(r);
return false;
}
r->out.ifaces = talloc_zero_array(r, struct MInterfacePointer *, r->in.Interfaces);
if (r->out.ifaces == NULL) {
talloc_free(r);
return false;
}
r->out.results = talloc_zero_array(r, WERROR, r->in.Interfaces);
if (r->out.results == NULL) {
talloc_free(r);
return false;
}
r->out.result = _RemoteActivation(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(RemoteActivation, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static bool api_EfsRpcDuplicateEncryptionInfoFile(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct EfsRpcDuplicateEncryptionInfoFile *r;
call = &ndr_table_efs.calls[NDR_EFSRPCDUPLICATEENCRYPTIONINFOFILE];
r = talloc(talloc_tos(), struct EfsRpcDuplicateEncryptionInfoFile);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(EfsRpcDuplicateEncryptionInfoFile, NDR_IN, r);
}
r->out.result = _EfsRpcDuplicateEncryptionInfoFile(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(EfsRpcDuplicateEncryptionInfoFile, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static NTSTATUS wkssvc__op_dispatch(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 (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaGetInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetWkstaGetInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaGetInfo will reply async\n"));
}
break;
}
case 1: {
struct wkssvc_NetWkstaSetInfo *r2 = (struct wkssvc_NetWkstaSetInfo *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaSetInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetWkstaSetInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaSetInfo will reply async\n"));
}
break;
}
case 2: {
struct wkssvc_NetWkstaEnumUsers *r2 = (struct wkssvc_NetWkstaEnumUsers *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaEnumUsers, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetWkstaEnumUsers(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaEnumUsers will reply async\n"));
}
break;
}
case 3: {
struct wkssvc_NetrWkstaUserGetInfo *r2 = (struct wkssvc_NetrWkstaUserGetInfo *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaUserGetInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrWkstaUserGetInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaUserGetInfo will reply async\n"));
}
break;
}
case 4: {
struct wkssvc_NetrWkstaUserSetInfo *r2 = (struct wkssvc_NetrWkstaUserSetInfo *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaUserSetInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrWkstaUserSetInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaUserSetInfo will reply async\n"));
}
break;
}
case 5: {
struct wkssvc_NetWkstaTransportEnum *r2 = (struct wkssvc_NetWkstaTransportEnum *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetWkstaTransportEnum, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetWkstaTransportEnum(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetWkstaTransportEnum will reply async\n"));
}
break;
}
case 6: {
struct wkssvc_NetrWkstaTransportAdd *r2 = (struct wkssvc_NetrWkstaTransportAdd *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaTransportAdd, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrWkstaTransportAdd(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaTransportAdd will reply async\n"));
}
break;
}
case 7: {
struct wkssvc_NetrWkstaTransportDel *r2 = (struct wkssvc_NetrWkstaTransportDel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWkstaTransportDel, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrWkstaTransportDel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWkstaTransportDel will reply async\n"));
}
break;
}
case 8: {
struct wkssvc_NetrUseAdd *r2 = (struct wkssvc_NetrUseAdd *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseAdd, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUseAdd(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseAdd will reply async\n"));
}
break;
}
case 9: {
struct wkssvc_NetrUseGetInfo *r2 = (struct wkssvc_NetrUseGetInfo *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseGetInfo, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUseGetInfo(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseGetInfo will reply async\n"));
}
break;
}
case 10: {
struct wkssvc_NetrUseDel *r2 = (struct wkssvc_NetrUseDel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseDel, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUseDel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseDel will reply async\n"));
}
break;
}
case 11: {
struct wkssvc_NetrUseEnum *r2 = (struct wkssvc_NetrUseEnum *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUseEnum, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUseEnum(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUseEnum will reply async\n"));
}
break;
}
case 12: {
struct wkssvc_NetrMessageBufferSend *r2 = (struct wkssvc_NetrMessageBufferSend *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrMessageBufferSend, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrMessageBufferSend(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrMessageBufferSend will reply async\n"));
}
break;
}
case 13: {
struct wkssvc_NetrWorkstationStatisticsGet *r2 = (struct wkssvc_NetrWorkstationStatisticsGet *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrWorkstationStatisticsGet, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrWorkstationStatisticsGet(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrWorkstationStatisticsGet will reply async\n"));
}
break;
}
case 14: {
struct wkssvc_NetrLogonDomainNameAdd *r2 = (struct wkssvc_NetrLogonDomainNameAdd *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrLogonDomainNameAdd, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrLogonDomainNameAdd(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrLogonDomainNameAdd will reply async\n"));
}
break;
}
case 15: {
struct wkssvc_NetrLogonDomainNameDel *r2 = (struct wkssvc_NetrLogonDomainNameDel *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrLogonDomainNameDel, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrLogonDomainNameDel(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrLogonDomainNameDel will reply async\n"));
}
break;
}
case 16: {
struct wkssvc_NetrJoinDomain *r2 = (struct wkssvc_NetrJoinDomain *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrJoinDomain, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrJoinDomain(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrJoinDomain will reply async\n"));
}
break;
}
case 17: {
struct wkssvc_NetrUnjoinDomain *r2 = (struct wkssvc_NetrUnjoinDomain *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUnjoinDomain, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUnjoinDomain(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUnjoinDomain will reply async\n"));
}
break;
}
case 18: {
struct wkssvc_NetrRenameMachineInDomain *r2 = (struct wkssvc_NetrRenameMachineInDomain *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRenameMachineInDomain, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrRenameMachineInDomain(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRenameMachineInDomain will reply async\n"));
}
break;
}
case 19: {
struct wkssvc_NetrValidateName *r2 = (struct wkssvc_NetrValidateName *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrValidateName, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrValidateName(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrValidateName will reply async\n"));
}
break;
}
case 20: {
struct wkssvc_NetrGetJoinInformation *r2 = (struct wkssvc_NetrGetJoinInformation *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinInformation, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrGetJoinInformation(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinInformation will reply async\n"));
}
break;
}
case 21: {
struct wkssvc_NetrGetJoinableOus *r2 = (struct wkssvc_NetrGetJoinableOus *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinableOus, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrGetJoinableOus(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinableOus will reply async\n"));
}
break;
}
case 22: {
struct wkssvc_NetrJoinDomain2 *r2 = (struct wkssvc_NetrJoinDomain2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrJoinDomain2, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrJoinDomain2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrJoinDomain2 will reply async\n"));
}
break;
}
case 23: {
struct wkssvc_NetrUnjoinDomain2 *r2 = (struct wkssvc_NetrUnjoinDomain2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrUnjoinDomain2, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrUnjoinDomain2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrUnjoinDomain2 will reply async\n"));
}
break;
}
case 24: {
struct wkssvc_NetrRenameMachineInDomain2 *r2 = (struct wkssvc_NetrRenameMachineInDomain2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRenameMachineInDomain2, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrRenameMachineInDomain2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRenameMachineInDomain2 will reply async\n"));
}
break;
}
case 25: {
struct wkssvc_NetrValidateName2 *r2 = (struct wkssvc_NetrValidateName2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrValidateName2, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrValidateName2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrValidateName2 will reply async\n"));
}
break;
}
case 26: {
struct wkssvc_NetrGetJoinableOus2 *r2 = (struct wkssvc_NetrGetJoinableOus2 *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrGetJoinableOus2, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrGetJoinableOus2(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrGetJoinableOus2 will reply async\n"));
}
break;
}
case 27: {
struct wkssvc_NetrAddAlternateComputerName *r2 = (struct wkssvc_NetrAddAlternateComputerName *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrAddAlternateComputerName, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrAddAlternateComputerName(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrAddAlternateComputerName will reply async\n"));
}
break;
}
case 28: {
struct wkssvc_NetrRemoveAlternateComputerName *r2 = (struct wkssvc_NetrRemoveAlternateComputerName *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrRemoveAlternateComputerName, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrRemoveAlternateComputerName(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrRemoveAlternateComputerName will reply async\n"));
}
break;
}
case 29: {
struct wkssvc_NetrSetPrimaryComputername *r2 = (struct wkssvc_NetrSetPrimaryComputername *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrSetPrimaryComputername, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrSetPrimaryComputername(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrSetPrimaryComputername will reply async\n"));
}
break;
}
case 30: {
struct wkssvc_NetrEnumerateComputerNames *r2 = (struct wkssvc_NetrEnumerateComputerNames *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wkssvc_NetrEnumerateComputerNames, NDR_IN, r2);
}
r2->out.result = dcesrv_wkssvc_NetrEnumerateComputerNames(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function wkssvc_NetrEnumerateComputerNames will reply async\n"));
}
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;
}
static bool api_fss_PrepareShadowCopySet(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct fss_PrepareShadowCopySet *r;
call = &ndr_table_FileServerVssAgent.calls[NDR_FSS_PREPARESHADOWCOPYSET];
r = talloc(talloc_tos(), struct fss_PrepareShadowCopySet);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(fss_PrepareShadowCopySet, NDR_IN, r);
}
r->out.result = _fss_PrepareShadowCopySet(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(fss_PrepareShadowCopySet, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static NTSTATUS epmapper__op_dispatch(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 (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_Insert, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_Insert(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Insert will reply async\n"));
}
break;
}
case 1: {
struct epm_Delete *r2 = (struct epm_Delete *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_Delete, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_Delete(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Delete will reply async\n"));
}
break;
}
case 2: {
struct epm_Lookup *r2 = (struct epm_Lookup *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_Lookup, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_Lookup(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Lookup will reply async\n"));
}
break;
}
case 3: {
struct epm_Map *r2 = (struct epm_Map *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_Map, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_Map(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_Map will reply async\n"));
}
break;
}
case 4: {
struct epm_LookupHandleFree *r2 = (struct epm_LookupHandleFree *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_LookupHandleFree, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_LookupHandleFree(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_LookupHandleFree will reply async\n"));
}
break;
}
case 5: {
struct epm_InqObject *r2 = (struct epm_InqObject *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_InqObject, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_InqObject(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_InqObject will reply async\n"));
}
break;
}
case 6: {
struct epm_MgmtDelete *r2 = (struct epm_MgmtDelete *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_MgmtDelete, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_MgmtDelete(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_MgmtDelete will reply async\n"));
}
break;
}
case 7: {
struct epm_MapAuth *r2 = (struct epm_MapAuth *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(epm_MapAuth, NDR_IN, r2);
}
r2->out.result = dcesrv_epm_MapAuth(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function epm_MapAuth will reply async\n"));
}
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 bool api_mgmt_stop_server_listening(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct mgmt_stop_server_listening *r;
call = &ndr_table_mgmt.calls[NDR_MGMT_STOP_SERVER_LISTENING];
r = talloc(talloc_tos(), struct mgmt_stop_server_listening);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_stop_server_listening, NDR_IN, r);
}
r->out.result = _mgmt_stop_server_listening(p, r);
if (p->rng_fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(mgmt_stop_server_listening, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static bool api_eventlog_ReportEventW(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct eventlog_ReportEventW *r;
call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
r = talloc(talloc_tos(), struct eventlog_ReportEventW);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog_ReportEventW, NDR_IN, r);
}
ZERO_STRUCT(r->out);
r->out.record_number = r->in.record_number;
r->out.time_written = r->in.time_written;
r->out.result = _eventlog_ReportEventW(p, r);
if (p->rng_fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(eventlog_ReportEventW, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
static NTSTATUS unixinfo__op_dispatch(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 unixinfo_SidToUid *r2 = (struct unixinfo_SidToUid *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(unixinfo_SidToUid, NDR_IN, r2);
}
r2->out.result = dcesrv_unixinfo_SidToUid(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function unixinfo_SidToUid will reply async\n"));
}
break;
}
case 1: {
struct unixinfo_UidToSid *r2 = (struct unixinfo_UidToSid *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(unixinfo_UidToSid, NDR_IN, r2);
}
r2->out.result = dcesrv_unixinfo_UidToSid(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function unixinfo_UidToSid will reply async\n"));
}
break;
}
case 2: {
struct unixinfo_SidToGid *r2 = (struct unixinfo_SidToGid *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(unixinfo_SidToGid, NDR_IN, r2);
}
r2->out.result = dcesrv_unixinfo_SidToGid(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function unixinfo_SidToGid will reply async\n"));
}
break;
}
case 3: {
struct unixinfo_GidToSid *r2 = (struct unixinfo_GidToSid *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(unixinfo_GidToSid, NDR_IN, r2);
}
r2->out.result = dcesrv_unixinfo_GidToSid(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function unixinfo_GidToSid will reply async\n"));
}
break;
}
case 4: {
struct unixinfo_GetPWUid *r2 = (struct unixinfo_GetPWUid *)r;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(unixinfo_GetPWUid, NDR_IN, r2);
}
r2->out.result = dcesrv_unixinfo_GetPWUid(dce_call, mem_ctx, r2);
if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
DEBUG(5,("function unixinfo_GetPWUid will reply async\n"));
}
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_unixinfo, opnum, NDR_IN,
&dce_call->pkt.u.request.stub_and_verifier);
return NT_STATUS_NET_WRITE_FAULT;
}
return NT_STATUS_OK;
}
/*
drsuapi_DsAddEntry
*/
WERROR dcesrv_drsuapi_DsAddEntry(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
struct drsuapi_DsAddEntry *r)
{
WERROR status;
struct drsuapi_bind_state *b_state;
struct dcesrv_handle *h;
uint32_t num = 0;
struct drsuapi_DsReplicaObjectIdentifier2 *ids = NULL;
int ret;
const struct drsuapi_DsReplicaObjectListItem *first_object;
if (DEBUGLVL(4)) {
NDR_PRINT_FUNCTION_DEBUG(drsuapi_DsAddEntry, NDR_IN, r);
}
/* TODO: check which out level the client supports */
ZERO_STRUCTP(r->out.ctr);
*r->out.level_out = 3;
r->out.ctr->ctr3.err_ver = 1;
r->out.ctr->ctr3.err_data = talloc_zero(mem_ctx, union drsuapi_DsAddEntry_ErrData);
DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
b_state = h->data;
status = drs_security_level_check(dce_call, "DsAddEntry", SECURITY_DOMAIN_CONTROLLER, NULL);
if (!W_ERROR_IS_OK(status)) {
return status;
}
switch (r->in.level) {
case 2:
ret = ldb_transaction_start(b_state->sam_ctx);
if (ret != LDB_SUCCESS) {
return WERR_DS_DRA_INTERNAL_ERROR;
}
first_object = &r->in.req->req2.first_object;
status = dsdb_origin_objects_commit(b_state->sam_ctx,
mem_ctx,
first_object,
&num,
DSDB_REPL_FLAG_ADD_NCNAME,
&ids);
if (!W_ERROR_IS_OK(status)) {
r->out.ctr->ctr3.err_data->v1.status = status;
ldb_transaction_cancel(b_state->sam_ctx);
DEBUG(0,(__location__ ": DsAddEntry failed - %s\n", win_errstr(status)));
return status;
}
r->out.ctr->ctr3.count = num;
r->out.ctr->ctr3.objects = ids;
break;
default:
return WERR_FOOBAR;
}
/* if any of the added entries are nTDSDSA objects then we
* need to add the SPNs to the machine account
*/
status = drsuapi_add_SPNs(b_state, dce_call, mem_ctx, first_object);
if (!W_ERROR_IS_OK(status)) {
r->out.ctr->ctr3.err_data->v1.status = status;
ldb_transaction_cancel(b_state->sam_ctx);
DEBUG(0,(__location__ ": DsAddEntry add SPNs failed - %s\n", win_errstr(status)));
return status;
}
ret = ldb_transaction_commit(b_state->sam_ctx);
if (ret != LDB_SUCCESS) {
DEBUG(0,(__location__ ": DsAddEntry commit failed: %s\n",
ldb_errstring(b_state->sam_ctx)));
return WERR_DS_DRA_INTERNAL_ERROR;
}
return WERR_OK;
}
static bool api_wzcsvc_EnumWZCDbLogRecords(struct pipes_struct *p)
{
const struct ndr_interface_call *call;
struct ndr_pull *pull;
struct ndr_push *push;
enum ndr_err_code ndr_err;
struct wzcsvc_EnumWZCDbLogRecords *r;
call = &ndr_table_wzcsvc.calls[NDR_WZCSVC_ENUMWZCDBLOGRECORDS];
r = talloc(talloc_tos(), struct wzcsvc_EnumWZCDbLogRecords);
if (r == NULL) {
return false;
}
pull = ndr_pull_init_blob(&p->in_data.data, r);
if (pull == NULL) {
talloc_free(r);
return false;
}
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (p->endian) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr_err = call->ndr_pull(pull, NDR_IN, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wzcsvc_EnumWZCDbLogRecords, NDR_IN, r);
}
_wzcsvc_EnumWZCDbLogRecords(p, r);
if (p->fault_state) {
talloc_free(r);
/* Return true here, srv_pipe_hnd.c will take care */
return true;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_FUNCTION_DEBUG(wzcsvc_EnumWZCDbLogRecords, NDR_OUT | NDR_SET_VALUES, r);
}
push = ndr_push_init_ctx(r);
if (push == NULL) {
talloc_free(r);
return false;
}
/*
* carry over the pointer count to the reply in case we are
* using full pointer. See NDR specification for full pointers
*/
push->ptr_count = pull->ptr_count;
ndr_err = call->ndr_push(push, NDR_OUT, r);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
return false;
}
p->out_data.rdata = ndr_push_blob(push);
talloc_steal(p->mem_ctx, p->out_data.rdata.data);
talloc_free(r);
return true;
}
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;
}
