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 struct dcerpc_binding_handle_raw_call_state
{
102 const struct dcerpc_binding_handle_ops
*ops
;
108 static void dcerpc_binding_handle_raw_call_done(struct tevent_req
*subreq
);
110 struct tevent_req
*dcerpc_binding_handle_raw_call_send(TALLOC_CTX
*mem_ctx
,
111 struct tevent_context
*ev
,
112 struct dcerpc_binding_handle
*h
,
113 const struct GUID
*object
,
116 const uint8_t *in_data
,
119 struct tevent_req
*req
;
120 struct dcerpc_binding_handle_raw_call_state
*state
;
121 struct tevent_req
*subreq
;
123 req
= tevent_req_create(mem_ctx
, &state
,
124 struct dcerpc_binding_handle_raw_call_state
);
129 state
->out_data
= NULL
;
130 state
->out_length
= 0;
131 state
->out_flags
= 0;
133 subreq
= state
->ops
->raw_call_send(state
, ev
, h
,
135 in_flags
, in_data
, in_length
);
136 if (tevent_req_nomem(subreq
, req
)) {
137 return tevent_req_post(req
, ev
);
139 tevent_req_set_callback(subreq
, dcerpc_binding_handle_raw_call_done
, req
);
144 static void dcerpc_binding_handle_raw_call_done(struct tevent_req
*subreq
)
146 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
148 struct dcerpc_binding_handle_raw_call_state
*state
=
150 struct dcerpc_binding_handle_raw_call_state
);
153 error
= state
->ops
->raw_call_recv(subreq
, state
,
158 if (!NT_STATUS_IS_OK(error
)) {
159 tevent_req_nterror(req
, error
);
163 tevent_req_done(req
);
166 NTSTATUS
dcerpc_binding_handle_raw_call_recv(struct tevent_req
*req
,
172 struct dcerpc_binding_handle_raw_call_state
*state
=
174 struct dcerpc_binding_handle_raw_call_state
);
177 if (tevent_req_is_nterror(req
, &error
)) {
178 tevent_req_received(req
);
182 *out_data
= talloc_move(mem_ctx
, &state
->out_data
);
183 *out_length
= state
->out_length
;
184 *out_flags
= state
->out_flags
;
185 tevent_req_received(req
);
189 struct dcerpc_binding_handle_disconnect_state
{
190 const struct dcerpc_binding_handle_ops
*ops
;
193 static void dcerpc_binding_handle_disconnect_done(struct tevent_req
*subreq
);
195 struct tevent_req
*dcerpc_binding_handle_disconnect_send(TALLOC_CTX
*mem_ctx
,
196 struct tevent_context
*ev
,
197 struct dcerpc_binding_handle
*h
)
199 struct tevent_req
*req
;
200 struct dcerpc_binding_handle_disconnect_state
*state
;
201 struct tevent_req
*subreq
;
203 req
= tevent_req_create(mem_ctx
, &state
,
204 struct dcerpc_binding_handle_disconnect_state
);
211 subreq
= state
->ops
->disconnect_send(state
, ev
, h
);
212 if (tevent_req_nomem(subreq
, req
)) {
213 return tevent_req_post(req
, ev
);
215 tevent_req_set_callback(subreq
, dcerpc_binding_handle_disconnect_done
, req
);
220 static void dcerpc_binding_handle_disconnect_done(struct tevent_req
*subreq
)
222 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
224 struct dcerpc_binding_handle_disconnect_state
*state
=
226 struct dcerpc_binding_handle_disconnect_state
);
229 error
= state
->ops
->disconnect_recv(subreq
);
231 if (!NT_STATUS_IS_OK(error
)) {
232 tevent_req_nterror(req
, error
);
236 tevent_req_done(req
);
239 NTSTATUS
dcerpc_binding_handle_disconnect_recv(struct tevent_req
*req
)
243 if (tevent_req_is_nterror(req
, &error
)) {
244 tevent_req_received(req
);
248 tevent_req_received(req
);
252 struct dcerpc_binding_handle_call_state
{
253 struct dcerpc_binding_handle
*h
;
254 const struct ndr_interface_call
*call
;
257 struct ndr_push
*push
;
260 struct ndr_pull
*pull
;
263 static void dcerpc_binding_handle_call_done(struct tevent_req
*subreq
);
265 struct tevent_req
*dcerpc_binding_handle_call_send(TALLOC_CTX
*mem_ctx
,
266 struct tevent_context
*ev
,
267 struct dcerpc_binding_handle
*h
,
268 const struct GUID
*object
,
269 const struct ndr_interface_table
*table
,
274 struct tevent_req
*req
;
275 struct dcerpc_binding_handle_call_state
*state
;
276 struct tevent_req
*subreq
;
277 enum ndr_err_code ndr_err
;
279 req
= tevent_req_create(mem_ctx
, &state
,
280 struct dcerpc_binding_handle_call_state
);
285 #if 0 /* TODO: activate this when the callers are fixed */
286 if (table
!= h
->table
) {
287 tevent_req_nterror(req
, NT_STATUS_INVALID_HANDLE
);
288 return tevent_req_post(req
, ev
);
292 if (opnum
>= table
->num_calls
) {
293 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
294 return tevent_req_post(req
, ev
);
298 state
->call
= &table
->calls
[opnum
];
300 state
->r_mem
= r_mem
;
301 state
->r_ptr
= r_ptr
;
303 /* setup for a ndr_push_* call */
304 state
->push
= ndr_push_init_ctx(state
);
305 if (tevent_req_nomem(state
->push
, req
)) {
306 return tevent_req_post(req
, ev
);
309 if (h
->ops
->ref_alloc
&& h
->ops
->ref_alloc(h
)) {
310 state
->push
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
313 if (h
->ops
->push_bigendian
&& h
->ops
->push_bigendian(h
)) {
314 state
->push
->flags
|= LIBNDR_FLAG_BIGENDIAN
;
317 if (h
->ops
->use_ndr64
&& h
->ops
->use_ndr64(h
)) {
318 state
->push
->flags
|= LIBNDR_FLAG_NDR64
;
321 if (h
->ops
->do_ndr_print
) {
322 h
->ops
->do_ndr_print(h
, NDR_IN
| NDR_SET_VALUES
,
323 state
->r_ptr
, state
->call
);
326 /* push the structure into a blob */
327 ndr_err
= state
->call
->ndr_push(state
->push
, NDR_IN
, state
->r_ptr
);
328 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
330 error
= ndr_map_error2ntstatus(ndr_err
);
331 if (h
->ops
->ndr_push_failed
) {
332 h
->ops
->ndr_push_failed(h
, error
,
336 tevent_req_nterror(req
, error
);
337 return tevent_req_post(req
, ev
);
340 /* retrieve the blob */
341 state
->request
= ndr_push_blob(state
->push
);
343 if (h
->ops
->ndr_validate_in
) {
345 error
= h
->ops
->ndr_validate_in(h
, state
,
348 if (!NT_STATUS_IS_OK(error
)) {
349 tevent_req_nterror(req
, error
);
350 return tevent_req_post(req
, ev
);
354 subreq
= dcerpc_binding_handle_raw_call_send(state
, ev
,
358 state
->request
.length
);
359 if (tevent_req_nomem(subreq
, req
)) {
360 return tevent_req_post(req
, ev
);
362 tevent_req_set_callback(subreq
, dcerpc_binding_handle_call_done
, req
);
367 static void dcerpc_binding_handle_call_done(struct tevent_req
*subreq
)
369 struct tevent_req
*req
= tevent_req_callback_data(subreq
,
371 struct dcerpc_binding_handle_call_state
*state
=
373 struct dcerpc_binding_handle_call_state
);
374 struct dcerpc_binding_handle
*h
= state
->h
;
376 uint32_t out_flags
= 0;
377 enum ndr_err_code ndr_err
;
379 error
= dcerpc_binding_handle_raw_call_recv(subreq
, state
,
380 &state
->response
.data
,
381 &state
->response
.length
,
384 if (!NT_STATUS_IS_OK(error
)) {
385 tevent_req_nterror(req
, error
);
389 state
->pull
= ndr_pull_init_blob(&state
->response
, state
);
390 if (tevent_req_nomem(state
->pull
, req
)) {
393 state
->pull
->flags
= state
->push
->flags
;
395 if (out_flags
& LIBNDR_FLAG_BIGENDIAN
) {
396 state
->pull
->flags
|= LIBNDR_FLAG_BIGENDIAN
;
398 state
->pull
->flags
&= ~LIBNDR_FLAG_BIGENDIAN
;
401 state
->pull
->current_mem_ctx
= state
->r_mem
;
403 /* pull the structure from the blob */
404 ndr_err
= state
->call
->ndr_pull(state
->pull
, NDR_OUT
, state
->r_ptr
);
405 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
406 error
= ndr_map_error2ntstatus(ndr_err
);
407 if (h
->ops
->ndr_pull_failed
) {
408 h
->ops
->ndr_pull_failed(h
, error
,
412 tevent_req_nterror(req
, error
);
416 if (h
->ops
->do_ndr_print
) {
417 h
->ops
->do_ndr_print(h
, NDR_OUT
,
418 state
->r_ptr
, state
->call
);
421 if (h
->ops
->ndr_validate_out
) {
422 error
= h
->ops
->ndr_validate_out(h
,
426 if (!NT_STATUS_IS_OK(error
)) {
427 tevent_req_nterror(req
, error
);
432 tevent_req_done(req
);
435 NTSTATUS
dcerpc_binding_handle_call_recv(struct tevent_req
*req
)
439 if (tevent_req_is_nterror(req
, &error
)) {
440 tevent_req_received(req
);
444 tevent_req_received(req
);
448 NTSTATUS
dcerpc_binding_handle_call(struct dcerpc_binding_handle
*h
,
449 const struct GUID
*object
,
450 const struct ndr_interface_table
*table
,
455 TALLOC_CTX
*frame
= talloc_stackframe();
456 struct tevent_context
*ev
;
457 struct tevent_req
*subreq
;
461 * TODO: allow only one sync call
467 ev
= tevent_context_init(frame
);
471 return NT_STATUS_NO_MEMORY
;
474 subreq
= dcerpc_binding_handle_call_send(frame
, ev
,
476 opnum
, r_mem
, r_ptr
);
477 if (subreq
== NULL
) {
479 return NT_STATUS_NO_MEMORY
;
482 if (!tevent_req_poll(subreq
, ev
)) {
483 status
= map_nt_error_from_unix(errno
);
488 status
= dcerpc_binding_handle_call_recv(subreq
);
489 if (!NT_STATUS_IS_OK(status
)) {