2 Unix SMB/CIFS implementation.
4 dcerpc binding handle functions
6 Copyright (C) Stefan Metzmacher 2010
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "../lib/util/tevent_ntstatus.h"
25 #include "librpc/rpc/dcerpc.h"
26 #include "rpc_common.h"
28 struct dcerpc_binding_handle {
30 const struct dcerpc_binding_handle_ops *ops;
32 const struct GUID *object;
33 const struct ndr_interface_table *table;
34 struct tevent_context *sync_ev;
37 static int dcerpc_binding_handle_destructor(struct dcerpc_binding_handle *b)
42 struct dcerpc_binding_handle *_dcerpc_binding_handle_create(TALLOC_CTX *mem_ctx,
43 const struct dcerpc_binding_handle_ops *ops,
44 const struct GUID *object,
45 const struct ndr_interface_table *table,
51 struct dcerpc_binding_handle *h;
52 void **ppstate = (void **)pstate;
55 h = talloc_zero(mem_ctx, struct dcerpc_binding_handle);
60 h->location = location;
64 state = talloc_zero_size(h, psize);
69 talloc_set_name_const(state, type);
71 h->private_data = state;
73 talloc_set_destructor(h, dcerpc_binding_handle_destructor);
79 void *_dcerpc_binding_handle_data(struct dcerpc_binding_handle *h)
81 return h->private_data;
84 void dcerpc_binding_handle_set_sync_ev(struct dcerpc_binding_handle *h,
85 struct tevent_context *ev)
90 bool dcerpc_binding_handle_is_connected(struct dcerpc_binding_handle *h)
92 return h->ops->is_connected(h);
95 uint32_t dcerpc_binding_handle_set_timeout(struct dcerpc_binding_handle *h,
98 return h->ops->set_timeout(h, timeout);
101 void dcerpc_binding_handle_auth_info(struct dcerpc_binding_handle *h,
102 enum dcerpc_AuthType *auth_type,
103 enum dcerpc_AuthLevel *auth_level)
105 enum dcerpc_AuthType _auth_type;
106 enum dcerpc_AuthLevel _auth_level;
108 if (auth_type == NULL) {
109 auth_type = &_auth_type;
112 if (auth_level == NULL) {
113 auth_level = &_auth_level;
116 *auth_type = DCERPC_AUTH_TYPE_NONE;
117 *auth_level = DCERPC_AUTH_LEVEL_NONE;
119 if (h->ops->auth_info == NULL) {
123 h->ops->auth_info(h, auth_type, auth_level);
126 struct dcerpc_binding_handle_raw_call_state {
127 const struct dcerpc_binding_handle_ops *ops;
133 static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq);
135 struct tevent_req *dcerpc_binding_handle_raw_call_send(TALLOC_CTX *mem_ctx,
136 struct tevent_context *ev,
137 struct dcerpc_binding_handle *h,
138 const struct GUID *object,
141 const uint8_t *in_data,
144 struct tevent_req *req;
145 struct dcerpc_binding_handle_raw_call_state *state;
146 struct tevent_req *subreq;
148 req = tevent_req_create(mem_ctx, &state,
149 struct dcerpc_binding_handle_raw_call_state);
154 state->out_data = NULL;
155 state->out_length = 0;
156 state->out_flags = 0;
158 subreq = state->ops->raw_call_send(state, ev, h,
160 in_flags, in_data, in_length);
161 if (tevent_req_nomem(subreq, req)) {
162 return tevent_req_post(req, ev);
164 tevent_req_set_callback(subreq, dcerpc_binding_handle_raw_call_done, req);
169 static void dcerpc_binding_handle_raw_call_done(struct tevent_req *subreq)
171 struct tevent_req *req = tevent_req_callback_data(subreq,
173 struct dcerpc_binding_handle_raw_call_state *state =
175 struct dcerpc_binding_handle_raw_call_state);
178 error = state->ops->raw_call_recv(subreq, state,
183 if (!NT_STATUS_IS_OK(error)) {
184 tevent_req_nterror(req, error);
188 tevent_req_done(req);
191 NTSTATUS dcerpc_binding_handle_raw_call_recv(struct tevent_req *req,
197 struct dcerpc_binding_handle_raw_call_state *state =
199 struct dcerpc_binding_handle_raw_call_state);
202 if (tevent_req_is_nterror(req, &error)) {
203 tevent_req_received(req);
207 *out_data = talloc_move(mem_ctx, &state->out_data);
208 *out_length = state->out_length;
209 *out_flags = state->out_flags;
210 tevent_req_received(req);
214 NTSTATUS dcerpc_binding_handle_raw_call(struct dcerpc_binding_handle *h,
215 const struct GUID *object,
218 const uint8_t *in_data,
225 TALLOC_CTX *frame = talloc_stackframe();
226 struct tevent_context *ev;
227 struct tevent_req *subreq;
231 * TODO: allow only one sync call
237 ev = samba_tevent_context_init(frame);
241 return NT_STATUS_NO_MEMORY;
244 subreq = dcerpc_binding_handle_raw_call_send(frame, ev,
249 if (subreq == NULL) {
251 return NT_STATUS_NO_MEMORY;
254 if (!tevent_req_poll(subreq, ev)) {
255 status = map_nt_error_from_unix_common(errno);
260 status = dcerpc_binding_handle_raw_call_recv(subreq,
265 if (!NT_STATUS_IS_OK(status)) {
274 struct dcerpc_binding_handle_disconnect_state {
275 const struct dcerpc_binding_handle_ops *ops;
278 static void dcerpc_binding_handle_disconnect_done(struct tevent_req *subreq);
280 struct tevent_req *dcerpc_binding_handle_disconnect_send(TALLOC_CTX *mem_ctx,
281 struct tevent_context *ev,
282 struct dcerpc_binding_handle *h)
284 struct tevent_req *req;
285 struct dcerpc_binding_handle_disconnect_state *state;
286 struct tevent_req *subreq;
288 req = tevent_req_create(mem_ctx, &state,
289 struct dcerpc_binding_handle_disconnect_state);
296 subreq = state->ops->disconnect_send(state, ev, h);
297 if (tevent_req_nomem(subreq, req)) {
298 return tevent_req_post(req, ev);
300 tevent_req_set_callback(subreq, dcerpc_binding_handle_disconnect_done, req);
305 static void dcerpc_binding_handle_disconnect_done(struct tevent_req *subreq)
307 struct tevent_req *req = tevent_req_callback_data(subreq,
309 struct dcerpc_binding_handle_disconnect_state *state =
311 struct dcerpc_binding_handle_disconnect_state);
314 error = state->ops->disconnect_recv(subreq);
316 if (!NT_STATUS_IS_OK(error)) {
317 tevent_req_nterror(req, error);
321 tevent_req_done(req);
324 NTSTATUS dcerpc_binding_handle_disconnect_recv(struct tevent_req *req)
328 if (tevent_req_is_nterror(req, &error)) {
329 tevent_req_received(req);
333 tevent_req_received(req);
337 struct dcerpc_binding_handle_call_state {
338 struct dcerpc_binding_handle *h;
339 const struct ndr_interface_call *call;
342 struct ndr_push *push;
345 struct ndr_pull *pull;
348 static void dcerpc_binding_handle_call_done(struct tevent_req *subreq);
350 struct tevent_req *dcerpc_binding_handle_call_send(TALLOC_CTX *mem_ctx,
351 struct tevent_context *ev,
352 struct dcerpc_binding_handle *h,
353 const struct GUID *object,
354 const struct ndr_interface_table *table,
359 struct tevent_req *req;
360 struct dcerpc_binding_handle_call_state *state;
361 struct tevent_req *subreq;
362 enum ndr_err_code ndr_err;
364 req = tevent_req_create(mem_ctx, &state,
365 struct dcerpc_binding_handle_call_state);
370 #if 0 /* TODO: activate this when the callers are fixed */
371 if (table != h->table) {
372 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
373 return tevent_req_post(req, ev);
377 if (opnum >= table->num_calls) {
378 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
379 return tevent_req_post(req, ev);
383 state->call = &table->calls[opnum];
385 state->r_mem = r_mem;
386 state->r_ptr = r_ptr;
388 /* setup for a ndr_push_* call */
389 state->push = ndr_push_init_ctx(state);
390 if (tevent_req_nomem(state->push, req)) {
391 return tevent_req_post(req, ev);
394 if (h->ops->ref_alloc && h->ops->ref_alloc(h)) {
395 state->push->flags |= LIBNDR_FLAG_REF_ALLOC;
398 if (h->ops->push_bigendian && h->ops->push_bigendian(h)) {
399 state->push->flags |= LIBNDR_FLAG_BIGENDIAN;
402 if (h->ops->use_ndr64 && h->ops->use_ndr64(h)) {
403 state->push->flags |= LIBNDR_FLAG_NDR64;
406 if (h->ops->do_ndr_print) {
407 h->ops->do_ndr_print(h, NDR_IN | NDR_SET_VALUES,
408 state->r_ptr, state->call);
411 /* push the structure into a blob */
412 ndr_err = state->call->ndr_push(state->push, NDR_IN, state->r_ptr);
413 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
415 error = ndr_map_error2ntstatus(ndr_err);
416 if (h->ops->ndr_push_failed) {
417 h->ops->ndr_push_failed(h, error,
421 tevent_req_nterror(req, error);
422 return tevent_req_post(req, ev);
425 /* retrieve the blob */
426 state->request = ndr_push_blob(state->push);
428 if (h->ops->ndr_validate_in) {
430 error = h->ops->ndr_validate_in(h, state,
433 if (!NT_STATUS_IS_OK(error)) {
434 tevent_req_nterror(req, error);
435 return tevent_req_post(req, ev);
439 subreq = dcerpc_binding_handle_raw_call_send(state, ev,
443 state->request.length);
444 if (tevent_req_nomem(subreq, req)) {
445 return tevent_req_post(req, ev);
447 tevent_req_set_callback(subreq, dcerpc_binding_handle_call_done, req);
452 static void dcerpc_binding_handle_call_done(struct tevent_req *subreq)
454 struct tevent_req *req = tevent_req_callback_data(subreq,
456 struct dcerpc_binding_handle_call_state *state =
458 struct dcerpc_binding_handle_call_state);
459 struct dcerpc_binding_handle *h = state->h;
461 uint32_t out_flags = 0;
462 enum ndr_err_code ndr_err;
464 error = dcerpc_binding_handle_raw_call_recv(subreq, state,
465 &state->response.data,
466 &state->response.length,
469 if (!NT_STATUS_IS_OK(error)) {
470 tevent_req_nterror(req, error);
474 state->pull = ndr_pull_init_blob(&state->response, state);
475 if (tevent_req_nomem(state->pull, req)) {
478 state->pull->flags = state->push->flags;
480 if (out_flags & LIBNDR_FLAG_BIGENDIAN) {
481 state->pull->flags |= LIBNDR_FLAG_BIGENDIAN;
483 state->pull->flags &= ~LIBNDR_FLAG_BIGENDIAN;
486 state->pull->current_mem_ctx = state->r_mem;
488 /* pull the structure from the blob */
489 ndr_err = state->call->ndr_pull(state->pull, NDR_OUT, state->r_ptr);
490 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
491 error = ndr_map_error2ntstatus(ndr_err);
492 if (h->ops->ndr_pull_failed) {
493 h->ops->ndr_pull_failed(h, error,
497 tevent_req_nterror(req, error);
501 if (h->ops->do_ndr_print) {
502 h->ops->do_ndr_print(h, NDR_OUT,
503 state->r_ptr, state->call);
506 if (h->ops->ndr_validate_out) {
507 error = h->ops->ndr_validate_out(h,
511 if (!NT_STATUS_IS_OK(error)) {
512 tevent_req_nterror(req, error);
517 tevent_req_done(req);
520 NTSTATUS dcerpc_binding_handle_call_recv(struct tevent_req *req)
522 return tevent_req_simple_recv_ntstatus(req);
525 NTSTATUS dcerpc_binding_handle_call(struct dcerpc_binding_handle *h,
526 const struct GUID *object,
527 const struct ndr_interface_table *table,
532 TALLOC_CTX *frame = talloc_stackframe();
533 struct tevent_context *ev;
534 struct tevent_req *subreq;
535 NTSTATUS status = NT_STATUS_NO_MEMORY;
538 * TODO: allow only one sync call
544 ev = samba_tevent_context_init(frame);
550 subreq = dcerpc_binding_handle_call_send(frame, ev,
552 opnum, r_mem, r_ptr);
553 if (subreq == NULL) {
557 if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
561 status = dcerpc_binding_handle_call_recv(subreq);