return h->ops->set_timeout(h, timeout);
}
+void dcerpc_binding_handle_auth_info(struct dcerpc_binding_handle *h,
+ enum dcerpc_AuthType *auth_type,
+ enum dcerpc_AuthLevel *auth_level)
+{
+ enum dcerpc_AuthType _auth_type;
+ enum dcerpc_AuthLevel _auth_level;
+
+ if (auth_type == NULL) {
+ auth_type = &_auth_type;
+ }
+
+ if (auth_level == NULL) {
+ auth_level = &_auth_level;
+ }
+
+ *auth_type = DCERPC_AUTH_TYPE_NONE;
+ *auth_level = DCERPC_AUTH_LEVEL_NONE;
+
+ if (h->ops->auth_info == NULL) {
+ return;
+ }
+
+ h->ops->auth_info(h, auth_type, auth_level);
+}
+
struct dcerpc_binding_handle_raw_call_state {
const struct dcerpc_binding_handle_ops *ops;
- uint8_t *out_data;
- size_t out_length;
- uint32_t out_flags;
+ struct tevent_context *ev;
+ struct tevent_req *subreq;
};
static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq);
{
struct tevent_req *req;
struct dcerpc_binding_handle_raw_call_state *state;
- struct tevent_req *subreq;
req = tevent_req_create(mem_ctx, &state,
struct dcerpc_binding_handle_raw_call_state);
return NULL;
}
state->ops = h->ops;
- state->out_data = NULL;
- state->out_length = 0;
- state->out_flags = 0;
+ state->ev = ev;
+
+ if (h->object != NULL) {
+ /*
+ * If an object is set on the binding handle,
+ * per request object passing is not allowed.
+ */
+ if (object != NULL) {
+ tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
+ return tevent_req_post(req, ev);
+ }
- subreq = state->ops->raw_call_send(state, ev, h,
- object, opnum,
- in_flags, in_data, in_length);
- if (tevent_req_nomem(subreq, req)) {
+ /*
+ * We use the object from the binding handle
+ */
+ object = h->object;
+ }
+
+ state->subreq = state->ops->raw_call_send(state, ev, h,
+ object, opnum,
+ in_flags, in_data, in_length);
+ if (tevent_req_nomem(state->subreq, req)) {
return tevent_req_post(req, ev);
}
- tevent_req_set_callback(subreq, dcerpc_binding_handle_raw_call_done, req);
+ tevent_req_set_callback(state->subreq,
+ dcerpc_binding_handle_raw_call_done,
+ req);
return req;
}
static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq)
{
- struct tevent_req *req = tevent_req_callback_data(subreq,
- struct tevent_req);
- struct dcerpc_binding_handle_raw_call_state *state =
- tevent_req_data(req,
- struct dcerpc_binding_handle_raw_call_state);
- NTSTATUS error;
+ struct tevent_req *req =
+ tevent_req_callback_data(subreq,
+ struct tevent_req);
- error = state->ops->raw_call_recv(subreq, state,
- &state->out_data,
- &state->out_length,
- &state->out_flags);
- TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(error)) {
- tevent_req_nterror(req, error);
+ if (tevent_req_is_in_progress(subreq)) {
+ tevent_req_notify_callback(req);
return;
}
struct dcerpc_binding_handle_raw_call_state);
NTSTATUS error;
- if (tevent_req_is_nterror(req, &error)) {
+ if (!tevent_req_is_in_progress(req)) {
+ if (tevent_req_is_nterror(req, &error)) {
+ tevent_req_received(req);
+ return error;
+ }
+ }
+
+ error = state->ops->raw_call_recv(state->subreq,
+ mem_ctx,
+ out_data,
+ out_length,
+ out_flags);
+ if (!NT_STATUS_IS_OK(error)) {
tevent_req_received(req);
return error;
}
- *out_data = talloc_move(mem_ctx, &state->out_data);
- *out_length = state->out_length;
- *out_flags = state->out_flags;
+ if (tevent_req_is_in_progress(state->subreq)) {
+ return NT_STATUS_OK;
+ }
+
tevent_req_received(req);
return NT_STATUS_OK;
}
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_context *ev;
struct tevent_req *subreq;
- NTSTATUS status;
+ NTSTATUS status = NT_STATUS_NO_MEMORY;
/*
* TODO: allow only one sync call
if (h->sync_ev) {
ev = h->sync_ev;
} else {
- ev = tevent_context_init(frame);
+ ev = samba_tevent_context_init(frame);
}
if (ev == NULL) {
- talloc_free(frame);
- return NT_STATUS_NO_MEMORY;
+ goto fail;
}
subreq = dcerpc_binding_handle_raw_call_send(frame, ev,
in_data,
in_length);
if (subreq == NULL) {
- talloc_free(frame);
- return NT_STATUS_NO_MEMORY;
+ goto fail;
}
- if (!tevent_req_poll(subreq, ev)) {
- status = map_nt_error_from_unix_common(errno);
- talloc_free(frame);
- return status;
+ if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
+ goto fail;
}
status = dcerpc_binding_handle_raw_call_recv(subreq,
out_data,
out_length,
out_flags);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(frame);
- return status;
- }
-
+fail:
TALLOC_FREE(frame);
- return NT_STATUS_OK;
+ return status;
}
struct dcerpc_binding_handle_disconnect_state {
error = state->ops->disconnect_recv(subreq);
TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(error)) {
- tevent_req_nterror(req, error);
+ if (tevent_req_nterror(req, error)) {
return;
}
return NT_STATUS_OK;
}
-struct dcerpc_binding_handle_call_state {
+struct dcerpc_binding_handle_call_params_state {
struct dcerpc_binding_handle *h;
const struct ndr_interface_call *call;
- TALLOC_CTX *r_mem;
- void *r_ptr;
+ struct dcerpc_binding_handle_call_params *params;
struct ndr_push *push;
DATA_BLOB request;
DATA_BLOB response;
struct ndr_pull *pull;
};
-static void dcerpc_binding_handle_call_done(struct tevent_req *subreq);
+static void dcerpc_binding_handle_call_params_done(struct tevent_req *subreq);
-struct tevent_req *dcerpc_binding_handle_call_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- struct dcerpc_binding_handle *h,
- const struct GUID *object,
- const struct ndr_interface_table *table,
- uint32_t opnum,
- TALLOC_CTX *r_mem,
- void *r_ptr)
+struct tevent_req *dcerpc_binding_handle_call_params_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct dcerpc_binding_handle *h,
+ const struct GUID *object,
+ const struct ndr_interface_table *table,
+ uint32_t opnum,
+ struct dcerpc_binding_handle_call_params *params)
{
struct tevent_req *req;
- struct dcerpc_binding_handle_call_state *state;
+ struct dcerpc_binding_handle_call_params_state *state;
struct tevent_req *subreq;
enum ndr_err_code ndr_err;
req = tevent_req_create(mem_ctx, &state,
- struct dcerpc_binding_handle_call_state);
+ struct dcerpc_binding_handle_call_params_state);
if (req == NULL) {
return NULL;
}
-#if 0 /* TODO: activate this when the callers are fixed */
if (table != h->table) {
tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
return tevent_req_post(req, ev);
}
-#endif
if (opnum >= table->num_calls) {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
state->h = h;
state->call = &table->calls[opnum];
+ state->params = params;
+
+ if (params->in.num_pipes != state->call->in_pipes.num_pipes) {
+ tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+ return tevent_req_post(req, ev);
+ }
+
+ if (params->out.num_pipes != state->call->out_pipes.num_pipes) {
+ tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+ return tevent_req_post(req, ev);
+ }
+
+ if (params->in.num_pipes != 0) {
+ tevent_req_nterror(req, NT_STATUS_RPC_CANNOT_SUPPORT);
+ return tevent_req_post(req, ev);
+ }
- state->r_mem = r_mem;
- state->r_ptr = r_ptr;
+ if (params->out.num_pipes != 0) {
+ tevent_req_nterror(req, NT_STATUS_RPC_CANNOT_SUPPORT);
+ return tevent_req_post(req, ev);
+ }
/* setup for a ndr_push_* call */
state->push = ndr_push_init_ctx(state);
if (h->ops->do_ndr_print) {
h->ops->do_ndr_print(h, NDR_IN | NDR_SET_VALUES,
- state->r_ptr, state->call);
+ state->params->r_ptr, state->call);
}
/* push the structure into a blob */
- ndr_err = state->call->ndr_push(state->push, NDR_IN, state->r_ptr);
+ ndr_err = state->call->ndr_push(state->push, NDR_IN, state->params->r_ptr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS error;
error = ndr_map_error2ntstatus(ndr_err);
if (h->ops->ndr_push_failed) {
h->ops->ndr_push_failed(h, error,
- state->r_ptr,
+ state->params->r_ptr,
state->call);
}
tevent_req_nterror(req, error);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
- tevent_req_set_callback(subreq, dcerpc_binding_handle_call_done, req);
+ tevent_req_set_callback(subreq, dcerpc_binding_handle_call_params_done, req);
return req;
}
-static void dcerpc_binding_handle_call_done(struct tevent_req *subreq)
+static void dcerpc_binding_handle_call_params_done(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(subreq,
struct tevent_req);
- struct dcerpc_binding_handle_call_state *state =
+ struct dcerpc_binding_handle_call_params_state *state =
tevent_req_data(req,
- struct dcerpc_binding_handle_call_state);
+ struct dcerpc_binding_handle_call_params_state);
struct dcerpc_binding_handle *h = state->h;
NTSTATUS error;
uint32_t out_flags = 0;
&state->response.length,
&out_flags);
TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(error)) {
- tevent_req_nterror(req, error);
+ if (tevent_req_nterror(req, error)) {
return;
}
state->pull->flags &= ~LIBNDR_FLAG_BIGENDIAN;
}
- state->pull->current_mem_ctx = state->r_mem;
+ state->pull->current_mem_ctx = state->params->r_mem;
/* pull the structure from the blob */
- ndr_err = state->call->ndr_pull(state->pull, NDR_OUT, state->r_ptr);
+ ndr_err = state->call->ndr_pull(state->pull, NDR_OUT,
+ state->params->r_ptr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
error = ndr_map_error2ntstatus(ndr_err);
if (h->ops->ndr_pull_failed) {
if (h->ops->do_ndr_print) {
h->ops->do_ndr_print(h, NDR_OUT,
- state->r_ptr, state->call);
+ state->params->r_ptr, state->call);
}
if (h->ops->ndr_validate_out) {
error = h->ops->ndr_validate_out(h,
state->pull,
- state->r_ptr,
+ state->params->r_ptr,
state->call);
if (!NT_STATUS_IS_OK(error)) {
tevent_req_nterror(req, error);
tevent_req_done(req);
}
-NTSTATUS dcerpc_binding_handle_call_recv(struct tevent_req *req)
+NTSTATUS dcerpc_binding_handle_call_params_recv(struct tevent_req *req)
+{
+ return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct dcerpc_binding_handle_call_state {
+ struct dcerpc_binding_handle_call_params params;
+};
+
+static void dcerpc_binding_handle_call_done(struct tevent_req *subreq);
+
+struct tevent_req *dcerpc_binding_handle_call_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct dcerpc_binding_handle *h,
+ const struct GUID *object,
+ const struct ndr_interface_table *table,
+ uint32_t opnum,
+ TALLOC_CTX *r_mem,
+ void *r_ptr)
{
+ struct tevent_req *req;
+ struct dcerpc_binding_handle_call_state *state;
+ struct tevent_req *subreq;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct dcerpc_binding_handle_call_state);
+ if (req == NULL) {
+ return NULL;
+ }
+
+ state->params.r_mem = r_mem;
+ state->params.r_ptr = r_ptr;
+
+ subreq = dcerpc_binding_handle_call_params_send(state, ev, h,
+ object, table, opnum,
+ &state->params);
+ if (tevent_req_nomem(subreq, req)) {
+ return tevent_req_post(req, ev);
+ }
+ tevent_req_set_callback(subreq, dcerpc_binding_handle_call_done, req);
+
+ return req;
+}
+
+static void dcerpc_binding_handle_call_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
NTSTATUS error;
- if (tevent_req_is_nterror(req, &error)) {
- tevent_req_received(req);
- return error;
+ error = dcerpc_binding_handle_call_params_recv(subreq);
+ TALLOC_FREE(subreq);
+ if (tevent_req_nterror(req, error)) {
+ return;
}
- tevent_req_received(req);
- return NT_STATUS_OK;
+ tevent_req_done(req);
+}
+
+NTSTATUS dcerpc_binding_handle_call_recv(struct tevent_req *req)
+{
+ return tevent_req_simple_recv_ntstatus(req);
}
NTSTATUS dcerpc_binding_handle_call(struct dcerpc_binding_handle *h,
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_context *ev;
struct tevent_req *subreq;
- NTSTATUS status;
+ struct dcerpc_binding_handle_call_params params;
+ NTSTATUS status = NT_STATUS_NO_MEMORY;
/*
* TODO: allow only one sync call
if (h->sync_ev) {
ev = h->sync_ev;
} else {
- ev = tevent_context_init(frame);
+ ev = samba_tevent_context_init(frame);
}
if (ev == NULL) {
- talloc_free(frame);
- return NT_STATUS_NO_MEMORY;
+ goto fail;
}
- subreq = dcerpc_binding_handle_call_send(frame, ev,
- h, object, table,
- opnum, r_mem, r_ptr);
- if (subreq == NULL) {
- talloc_free(frame);
- return NT_STATUS_NO_MEMORY;
- }
+ ZERO_STRUCT(params);
+ params.r_mem = r_mem;
+ params.r_ptr = r_ptr;
- if (!tevent_req_poll(subreq, ev)) {
- status = map_nt_error_from_unix_common(errno);
- talloc_free(frame);
- return status;
+ subreq = dcerpc_binding_handle_call_params_send(frame, ev, h,
+ object, table, opnum,
+ ¶ms);
+ if (subreq == NULL) {
+ goto fail;
}
- status = dcerpc_binding_handle_call_recv(subreq);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(frame);
- return status;
+ if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
+ goto fail;
}
+ status = dcerpc_binding_handle_call_params_recv(subreq);
+fail:
TALLOC_FREE(frame);
- return NT_STATUS_OK;
+ return status;
}
git.samba.org / metze / samba / wip.git / blobdiff