2 * Unix SMB/CIFS implementation.
3 * RPC client transport over named pipes
4 * Copyright (C) Volker Lendecke 2009
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
23 #define DBGC_CLASS DBGC_RPC_CLI
25 struct rpc_transport_np_state
{
26 struct cli_state
*cli
;
27 const char *pipe_name
;
31 static bool rpc_np_is_connected(void *priv
)
33 struct rpc_transport_np_state
*np_transport
= talloc_get_type_abort(
34 priv
, struct rpc_transport_np_state
);
37 if (np_transport
->cli
== NULL
) {
41 ok
= cli_state_is_connected(np_transport
->cli
);
43 np_transport
->cli
= NULL
;
50 static unsigned int rpc_np_set_timeout(void *priv
, unsigned int timeout
)
52 struct rpc_transport_np_state
*np_transport
= talloc_get_type_abort(
53 priv
, struct rpc_transport_np_state
);
56 if (np_transport
->cli
== NULL
) {
60 ok
= rpc_np_is_connected(np_transport
);
65 return cli_set_timeout(np_transport
->cli
, timeout
);
68 static int rpc_transport_np_state_destructor(struct rpc_transport_np_state
*s
)
72 if (!rpc_np_is_connected(s
)) {
73 DEBUG(10, ("socket was closed, no need to send close request.\n"));
77 ret
= cli_close(s
->cli
, s
->fnum
);
79 DEBUG(1, ("rpc_transport_np_state_destructor: cli_close "
80 "failed on pipe %s. Error was %s\n", s
->pipe_name
,
83 DEBUG(10, ("rpc_pipe_destructor: closed %s\n", s
->pipe_name
));
85 * We can't do much on failure
90 struct rpc_np_write_state
{
91 struct rpc_transport_np_state
*np_transport
;
96 static void rpc_np_write_done(struct async_req
*subreq
);
98 static struct async_req
*rpc_np_write_send(TALLOC_CTX
*mem_ctx
,
99 struct event_context
*ev
,
100 const uint8_t *data
, size_t size
,
103 struct rpc_transport_np_state
*np_transport
= talloc_get_type_abort(
104 priv
, struct rpc_transport_np_state
);
105 struct async_req
*result
, *subreq
;
106 struct rpc_np_write_state
*state
;
109 if (!async_req_setup(mem_ctx
, &result
, &state
,
110 struct rpc_np_write_state
)) {
114 ok
= rpc_np_is_connected(np_transport
);
116 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
123 state
->np_transport
= np_transport
;
127 subreq
= cli_write_andx_send(mem_ctx
, ev
, np_transport
->cli
,
129 8, /* 8 means message mode. */
131 if (subreq
== NULL
) {
134 subreq
->async
.fn
= rpc_np_write_done
;
135 subreq
->async
.priv
= result
;
142 static void rpc_np_write_done(struct async_req
*subreq
)
144 struct async_req
*req
= talloc_get_type_abort(
145 subreq
->async
.priv
, struct async_req
);
146 struct rpc_np_write_state
*state
= talloc_get_type_abort(
147 req
->private_data
, struct rpc_np_write_state
);
150 status
= cli_write_andx_recv(subreq
, &state
->written
);
152 if (!NT_STATUS_IS_OK(status
)) {
153 state
->np_transport
->cli
= NULL
;
154 async_req_nterror(req
, status
);
160 static NTSTATUS
rpc_np_write_recv(struct async_req
*req
, ssize_t
*pwritten
)
162 struct rpc_np_write_state
*state
= talloc_get_type_abort(
163 req
->private_data
, struct rpc_np_write_state
);
166 if (async_req_is_nterror(req
, &status
)) {
169 *pwritten
= state
->written
;
173 struct rpc_np_read_state
{
174 struct rpc_transport_np_state
*np_transport
;
180 static void rpc_np_read_done(struct async_req
*subreq
);
182 static struct async_req
*rpc_np_read_send(TALLOC_CTX
*mem_ctx
,
183 struct event_context
*ev
,
184 uint8_t *data
, size_t size
,
187 struct rpc_transport_np_state
*np_transport
= talloc_get_type_abort(
188 priv
, struct rpc_transport_np_state
);
189 struct async_req
*result
, *subreq
;
190 struct rpc_np_read_state
*state
;
193 if (!async_req_setup(mem_ctx
, &result
, &state
,
194 struct rpc_np_read_state
)) {
198 ok
= rpc_np_is_connected(np_transport
);
200 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
207 state
->np_transport
= np_transport
;
211 subreq
= cli_read_andx_send(mem_ctx
, ev
, np_transport
->cli
,
212 np_transport
->fnum
, 0, size
);
213 if (subreq
== NULL
) {
216 subreq
->async
.fn
= rpc_np_read_done
;
217 subreq
->async
.priv
= result
;
224 static void rpc_np_read_done(struct async_req
*subreq
)
226 struct async_req
*req
= talloc_get_type_abort(
227 subreq
->async
.priv
, struct async_req
);
228 struct rpc_np_read_state
*state
= talloc_get_type_abort(
229 req
->private_data
, struct rpc_np_read_state
);
233 /* We must free subreq in this function as there is
234 a timer event attached to it. */
236 status
= cli_read_andx_recv(subreq
, &state
->received
, &rcvbuf
);
238 * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
241 if (NT_STATUS_EQUAL(status
, NT_STATUS_BUFFER_TOO_SMALL
)) {
242 status
= NT_STATUS_OK
;
244 if (!NT_STATUS_IS_OK(status
)) {
246 state
->np_transport
->cli
= NULL
;
247 async_req_nterror(req
, status
);
251 if (state
->received
> state
->size
) {
253 state
->np_transport
->cli
= NULL
;
254 async_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
258 if (state
->received
== 0) {
260 state
->np_transport
->cli
= NULL
;
261 async_req_nterror(req
, NT_STATUS_PIPE_BROKEN
);
265 memcpy(state
->data
, rcvbuf
, state
->received
);
270 static NTSTATUS
rpc_np_read_recv(struct async_req
*req
, ssize_t
*preceived
)
272 struct rpc_np_read_state
*state
= talloc_get_type_abort(
273 req
->private_data
, struct rpc_np_read_state
);
276 if (async_req_is_nterror(req
, &status
)) {
279 *preceived
= state
->received
;
283 struct rpc_np_trans_state
{
284 struct rpc_transport_np_state
*np_transport
;
286 uint32_t max_rdata_len
;
291 static void rpc_np_trans_done(struct async_req
*subreq
);
293 static struct async_req
*rpc_np_trans_send(TALLOC_CTX
*mem_ctx
,
294 struct event_context
*ev
,
295 uint8_t *data
, size_t data_len
,
296 uint32_t max_rdata_len
,
299 struct rpc_transport_np_state
*np_transport
= talloc_get_type_abort(
300 priv
, struct rpc_transport_np_state
);
301 struct async_req
*result
, *subreq
;
302 struct rpc_np_trans_state
*state
;
305 if (!async_req_setup(mem_ctx
, &result
, &state
,
306 struct rpc_np_trans_state
)) {
310 ok
= rpc_np_is_connected(np_transport
);
312 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
319 state
->np_transport
= np_transport
;
320 state
->max_rdata_len
= max_rdata_len
;
322 SSVAL(state
->setup
+0, 0, TRANSACT_DCERPCCMD
);
323 SSVAL(state
->setup
+1, 0, np_transport
->fnum
);
325 subreq
= cli_trans_send(
326 state
, ev
, np_transport
->cli
, SMBtrans
,
327 "\\PIPE\\", 0, 0, 0, state
->setup
, 2, 0,
328 NULL
, 0, 0, data
, data_len
, max_rdata_len
);
329 if (subreq
== NULL
) {
332 subreq
->async
.fn
= rpc_np_trans_done
;
333 subreq
->async
.priv
= result
;
341 static void rpc_np_trans_done(struct async_req
*subreq
)
343 struct async_req
*req
= talloc_get_type_abort(
344 subreq
->async
.priv
, struct async_req
);
345 struct rpc_np_trans_state
*state
= talloc_get_type_abort(
346 req
->private_data
, struct rpc_np_trans_state
);
349 status
= cli_trans_recv(subreq
, state
, NULL
, NULL
, NULL
, NULL
,
350 &state
->rdata
, &state
->rdata_len
);
352 if (NT_STATUS_EQUAL(status
, NT_STATUS_BUFFER_TOO_SMALL
)) {
353 status
= NT_STATUS_OK
;
355 if (!NT_STATUS_IS_OK(status
)) {
356 state
->np_transport
->cli
= NULL
;
357 async_req_nterror(req
, status
);
361 if (state
->rdata_len
> state
->max_rdata_len
) {
362 state
->np_transport
->cli
= NULL
;
363 async_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
367 if (state
->rdata_len
== 0) {
368 state
->np_transport
->cli
= NULL
;
369 async_req_nterror(req
, NT_STATUS_PIPE_BROKEN
);
376 static NTSTATUS
rpc_np_trans_recv(struct async_req
*req
, TALLOC_CTX
*mem_ctx
,
377 uint8_t **prdata
, uint32_t *prdata_len
)
379 struct rpc_np_trans_state
*state
= talloc_get_type_abort(
380 req
->private_data
, struct rpc_np_trans_state
);
383 if (async_req_is_nterror(req
, &status
)) {
386 *prdata
= talloc_move(mem_ctx
, &state
->rdata
);
387 *prdata_len
= state
->rdata_len
;
391 struct rpc_transport_np_init_state
{
392 struct rpc_cli_transport
*transport
;
393 struct rpc_transport_np_state
*transport_np
;
396 static void rpc_transport_np_init_pipe_open(struct async_req
*subreq
);
398 struct async_req
*rpc_transport_np_init_send(TALLOC_CTX
*mem_ctx
,
399 struct event_context
*ev
,
400 struct cli_state
*cli
,
401 const struct ndr_syntax_id
*abstract_syntax
)
403 struct async_req
*result
, *subreq
;
404 struct rpc_transport_np_init_state
*state
;
407 if (!async_req_setup(mem_ctx
, &result
, &state
,
408 struct rpc_transport_np_init_state
)) {
412 ok
= cli_state_is_connected(cli
);
414 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
421 state
->transport
= talloc(state
, struct rpc_cli_transport
);
422 if (state
->transport
== NULL
) {
425 state
->transport_np
= talloc(state
->transport
,
426 struct rpc_transport_np_state
);
427 if (state
->transport_np
== NULL
) {
430 state
->transport
->priv
= state
->transport_np
;
432 state
->transport_np
->pipe_name
= get_pipe_name_from_iface(
434 state
->transport_np
->cli
= cli
;
436 subreq
= cli_ntcreate_send(
437 state
, ev
, cli
, state
->transport_np
->pipe_name
, 0,
438 DESIRED_ACCESS_PIPE
, 0, FILE_SHARE_READ
|FILE_SHARE_WRITE
,
440 if (subreq
== NULL
) {
443 subreq
->async
.fn
= rpc_transport_np_init_pipe_open
;
444 subreq
->async
.priv
= result
;
452 static void rpc_transport_np_init_pipe_open(struct async_req
*subreq
)
454 struct async_req
*req
= talloc_get_type_abort(
455 subreq
->async
.priv
, struct async_req
);
456 struct rpc_transport_np_init_state
*state
= talloc_get_type_abort(
457 req
->private_data
, struct rpc_transport_np_init_state
);
460 status
= cli_ntcreate_recv(subreq
, &state
->transport_np
->fnum
);
462 if (!NT_STATUS_IS_OK(status
)) {
463 async_req_nterror(req
, status
);
467 talloc_set_destructor(state
->transport_np
,
468 rpc_transport_np_state_destructor
);
472 NTSTATUS
rpc_transport_np_init_recv(struct async_req
*req
,
474 struct rpc_cli_transport
**presult
)
476 struct rpc_transport_np_init_state
*state
= talloc_get_type_abort(
477 req
->private_data
, struct rpc_transport_np_init_state
);
480 if (async_req_is_nterror(req
, &status
)) {
484 state
->transport
->write_send
= rpc_np_write_send
;
485 state
->transport
->write_recv
= rpc_np_write_recv
;
486 state
->transport
->read_send
= rpc_np_read_send
;
487 state
->transport
->read_recv
= rpc_np_read_recv
;
488 state
->transport
->trans_send
= rpc_np_trans_send
;
489 state
->transport
->trans_recv
= rpc_np_trans_recv
;
490 state
->transport
->is_connected
= rpc_np_is_connected
;
491 state
->transport
->set_timeout
= rpc_np_set_timeout
;
493 *presult
= talloc_move(mem_ctx
, &state
->transport
);
497 NTSTATUS
rpc_transport_np_init(TALLOC_CTX
*mem_ctx
, struct cli_state
*cli
,
498 const struct ndr_syntax_id
*abstract_syntax
,
499 struct rpc_cli_transport
**presult
)
501 TALLOC_CTX
*frame
= talloc_stackframe();
502 struct event_context
*ev
;
503 struct async_req
*req
;
506 ev
= event_context_init(frame
);
508 status
= NT_STATUS_NO_MEMORY
;
512 req
= rpc_transport_np_init_send(frame
, ev
, cli
, abstract_syntax
);
514 status
= NT_STATUS_NO_MEMORY
;
518 while (req
->state
< ASYNC_REQ_DONE
) {
522 status
= rpc_transport_np_init_recv(req
, mem_ctx
, presult
);
528 struct cli_state
*rpc_pipe_np_smb_conn(struct rpc_pipe_client
*p
)
530 struct rpc_transport_np_state
*state
= talloc_get_type(
531 p
->transport
->priv
, struct rpc_transport_np_state
);