本文整理汇总了C++中NDR_PRINT_FUNCTION_DEBUG函数的典型用法代码示例。如果您正苦于以下问题：C++ NDR_PRINT_FUNCTION_DEBUG函数的具体用法？C++ NDR_PRINT_FUNCTION_DEBUG怎么用？C++ NDR_PRINT_FUNCTION_DEBUG使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NDR_PRINT_FUNCTION_DEBUG函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: api_frstrans_RequestUpdates
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);
//.........这里部分代码省略.........
示例2: api_HrRRestoreRegisterComplete
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;
}示例3: atsvc__op_reply
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;
}示例4: api_frstrans_InitializeFileTransferAsync
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);
//.........这里部分代码省略.........
示例5: dssetup__op_dispatch
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) {
//.........这里部分代码省略.........
示例6: rpcecho__op_dispatch
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) {
//.........这里部分代码省略.........
示例7: epmapper__op_reply
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"));
//.........这里部分代码省略.........
示例8: api_rot_add
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;
}示例9: eventlog6__op_reply
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"));
//.........这里部分代码省略.........
示例10: eventlog6__op_dispatch
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) {
//.........这里部分代码省略.........
示例11: api_RemoteActivation
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);
//.........这里部分代码省略.........
示例12: api_EfsRpcDuplicateEncryptionInfoFile
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;
}示例13: wkssvc__op_dispatch
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) {
//.........这里部分代码省略.........
示例14: api_fss_PrepareShadowCopySet
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;
}示例15: epmapper__op_dispatch
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) {
//.........这里部分代码省略.........