2 * Unix SMB/CIFS implementation.
3 * RPC client transport over named pipes to a child smbd
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
26 * struct rpc_cli_smbd_conn represents a forked smbd. This structure should
27 * exist only once per process which does the rpc calls.
29 * RPC pipe handles can be attached to this smbd connection with
30 * rpc_pipe_open_local().
32 * For this to work right, we can not use rpc_transport_np directly, because
33 * the child smbd wants to write its DEBUG output somewhere. We redirect the
34 * child's output to rpc_cli_smbd_conn->stdout_fd. While the RPC calls are
35 * active, we have an event context available and attach a fd event to the
39 struct rpc_cli_smbd_conn
{
41 * The smb connection to handle the named pipe traffic over
43 struct cli_state
*cli
;
46 * Attached to stdout in the forked smbd, this is where smbd will
52 * Custom callback provided by the owner of the
53 * rpc_cli_smbd_conn. Here we send the smbd DEBUG output. Can be NULL.
56 void (*fn
)(char *buf
, size_t len
, void *priv
);
62 * Event handler to be called whenever the forked smbd prints debugging
66 static void rpc_cli_smbd_stdout_reader(struct event_context
*ev
,
68 uint16_t flags
, void *priv
)
70 struct rpc_cli_smbd_conn
*conn
= talloc_get_type_abort(
71 priv
, struct rpc_cli_smbd_conn
);
75 if ((flags
& EVENT_FD_READ
) == 0) {
79 nread
= read(conn
->stdout_fd
, buf
, sizeof(buf
)-1);
81 DEBUG(0, ("Could not read from smbd stdout: %s\n",
87 DEBUG(0, ("EOF from smbd stdout\n"));
93 if (conn
->stdout_callback
.fn
!= NULL
) {
94 conn
->stdout_callback
.fn(buf
, nread
,
95 conn
->stdout_callback
.priv
);
100 * struct rpc_transport_smbd_state is the link from a struct rpc_pipe_client
101 * to the rpc_cli_smbd_conn. We use a named pipe transport as a subtransport.
104 struct rpc_transport_smbd_state
{
105 struct rpc_cli_smbd_conn
*conn
;
106 struct rpc_cli_transport
*sub_transp
;
109 static int rpc_cli_smbd_conn_destructor(struct rpc_cli_smbd_conn
*conn
)
111 if (conn
->cli
!= NULL
) {
112 cli_shutdown(conn
->cli
);
115 if (conn
->stdout_fd
!= -1) {
116 close(conn
->stdout_fd
);
117 conn
->stdout_fd
= -1;
123 * Do the negprot/sesssetup/tcon to an anonymous ipc$ connection
126 struct get_anon_ipc_state
{
127 struct event_context
*ev
;
128 struct cli_state
*cli
;
131 static void get_anon_ipc_negprot_done(struct async_req
*subreq
);
132 static void get_anon_ipc_sesssetup_done(struct async_req
*subreq
);
133 static void get_anon_ipc_tcon_done(struct async_req
*subreq
);
135 static struct async_req
*get_anon_ipc_send(TALLOC_CTX
*mem_ctx
,
136 struct event_context
*ev
,
137 struct cli_state
*cli
)
139 struct async_req
*result
, *subreq
;
140 struct get_anon_ipc_state
*state
;
142 if (!async_req_setup(mem_ctx
, &result
, &state
,
143 struct get_anon_ipc_state
)) {
150 subreq
= cli_negprot_send(state
, ev
, cli
);
151 if (subreq
== NULL
) {
154 subreq
->async
.fn
= get_anon_ipc_negprot_done
;
155 subreq
->async
.priv
= result
;
162 static void get_anon_ipc_negprot_done(struct async_req
*subreq
)
164 struct async_req
*req
= talloc_get_type_abort(
165 subreq
->async
.priv
, struct async_req
);
166 struct get_anon_ipc_state
*state
= talloc_get_type_abort(
167 req
->private_data
, struct get_anon_ipc_state
);
170 status
= cli_negprot_recv(subreq
);
172 if (!NT_STATUS_IS_OK(status
)) {
173 async_req_nterror(req
, status
);
177 subreq
= cli_session_setup_guest_send(state
, state
->ev
, state
->cli
);
178 if (async_req_nomem(subreq
, req
)) {
181 subreq
->async
.fn
= get_anon_ipc_sesssetup_done
;
182 subreq
->async
.priv
= req
;
185 static void get_anon_ipc_sesssetup_done(struct async_req
*subreq
)
187 struct async_req
*req
= talloc_get_type_abort(
188 subreq
->async
.priv
, struct async_req
);
189 struct get_anon_ipc_state
*state
= talloc_get_type_abort(
190 req
->private_data
, struct get_anon_ipc_state
);
193 status
= cli_session_setup_guest_recv(subreq
);
195 if (!NT_STATUS_IS_OK(status
)) {
196 async_req_nterror(req
, status
);
200 subreq
= cli_tcon_andx_send(state
, state
->ev
, state
->cli
,
201 "IPC$", "IPC", NULL
, 0);
202 if (async_req_nomem(subreq
, req
)) {
205 subreq
->async
.fn
= get_anon_ipc_tcon_done
;
206 subreq
->async
.priv
= req
;
209 static void get_anon_ipc_tcon_done(struct async_req
*subreq
)
211 struct async_req
*req
= talloc_get_type_abort(
212 subreq
->async
.priv
, struct async_req
);
215 status
= cli_tcon_andx_recv(subreq
);
217 if (!NT_STATUS_IS_OK(status
)) {
218 async_req_nterror(req
, status
);
224 static NTSTATUS
get_anon_ipc_recv(struct async_req
*req
)
226 return async_req_simple_recv_ntstatus(req
);
229 struct rpc_cli_smbd_conn_init_state
{
230 struct event_context
*ev
;
231 struct rpc_cli_smbd_conn
*conn
;
234 static void rpc_cli_smbd_conn_init_done(struct async_req
*subreq
);
236 struct async_req
*rpc_cli_smbd_conn_init_send(TALLOC_CTX
*mem_ctx
,
237 struct event_context
*ev
,
238 void (*stdout_callback
)(char *buf
,
243 struct async_req
*result
, *subreq
;
244 struct rpc_cli_smbd_conn_init_state
*state
;
251 smb_sock
[0] = smb_sock
[1] = stdout_pipe
[0] = stdout_pipe
[1] = -1;
253 if (!async_req_setup(mem_ctx
, &result
, &state
,
254 struct rpc_cli_smbd_conn_init_state
)) {
259 state
->conn
= talloc(state
, struct rpc_cli_smbd_conn
);
260 if (state
->conn
== NULL
) {
264 state
->conn
->cli
= cli_initialise();
265 if (state
->conn
->cli
== NULL
) {
268 state
->conn
->stdout_fd
= -1;
269 state
->conn
->stdout_callback
.fn
= stdout_callback
;
270 state
->conn
->stdout_callback
.priv
= priv
;
271 talloc_set_destructor(state
->conn
, rpc_cli_smbd_conn_destructor
);
273 ret
= socketpair(AF_UNIX
, SOCK_STREAM
, 0, smb_sock
);
275 status
= map_nt_error_from_unix(errno
);
278 ret
= pipe(stdout_pipe
);
280 status
= map_nt_error_from_unix(errno
);
286 status
= map_nt_error_from_unix(errno
);
293 close(stdout_pipe
[0]);
295 if (dup(smb_sock
[1]) == -1) {
300 if (dup(stdout_pipe
[1]) == -1) {
303 close(stdout_pipe
[1]);
305 smbd_cmd
= getenv("SMB_PATH");
307 if ((smbd_cmd
== NULL
)
308 && (asprintf(&smbd_cmd
, "%s/smbd", get_dyn_SBINDIR())
313 if (asprintf(&smbd_cmd
, "%s -F -S -d %d", smbd_cmd
,
319 exit(system(smbd_cmd
));
322 state
->conn
->cli
->fd
= smb_sock
[0];
327 state
->conn
->stdout_fd
= stdout_pipe
[0];
329 close(stdout_pipe
[1]);
332 subreq
= get_anon_ipc_send(state
, ev
, state
->conn
->cli
);
333 if (subreq
== NULL
) {
337 if (event_add_fd(ev
, state
, state
->conn
->stdout_fd
, EVENT_FD_READ
,
338 rpc_cli_smbd_stdout_reader
, state
->conn
) == NULL
) {
342 subreq
->async
.fn
= rpc_cli_smbd_conn_init_done
;
343 subreq
->async
.priv
= result
;
347 status
= NT_STATUS_NO_MEMORY
;
349 if (smb_sock
[0] != -1) {
352 if (smb_sock
[1] != -1) {
355 if (stdout_pipe
[0] != -1) {
356 close(stdout_pipe
[0]);
358 if (stdout_pipe
[1] != -1) {
359 close(stdout_pipe
[1]);
361 if (async_post_ntstatus(result
, ev
, status
)) {
368 static void rpc_cli_smbd_conn_init_done(struct async_req
*subreq
)
370 struct async_req
*req
= talloc_get_type_abort(
371 subreq
->async
.priv
, struct async_req
);
374 status
= get_anon_ipc_recv(subreq
);
376 if (!NT_STATUS_IS_OK(status
)) {
377 async_req_nterror(req
, status
);
383 NTSTATUS
rpc_cli_smbd_conn_init_recv(struct async_req
*req
,
385 struct rpc_cli_smbd_conn
**pconn
)
387 struct rpc_cli_smbd_conn_init_state
*state
= talloc_get_type_abort(
388 req
->private_data
, struct rpc_cli_smbd_conn_init_state
);
391 if (async_req_is_nterror(req
, &status
)) {
394 *pconn
= talloc_move(mem_ctx
, &state
->conn
);
398 NTSTATUS
rpc_cli_smbd_conn_init(TALLOC_CTX
*mem_ctx
,
399 struct rpc_cli_smbd_conn
**pconn
,
400 void (*stdout_callback
)(char *buf
,
405 TALLOC_CTX
*frame
= talloc_stackframe();
406 struct event_context
*ev
;
407 struct async_req
*req
;
410 ev
= event_context_init(frame
);
412 status
= NT_STATUS_NO_MEMORY
;
416 req
= rpc_cli_smbd_conn_init_send(frame
, ev
, stdout_callback
, priv
);
418 status
= NT_STATUS_NO_MEMORY
;
422 while (req
->state
< ASYNC_REQ_DONE
) {
426 status
= rpc_cli_smbd_conn_init_recv(req
, mem_ctx
, pconn
);
432 struct rpc_smbd_write_state
{
433 struct rpc_cli_transport
*sub_transp
;
437 static void rpc_smbd_write_done(struct tevent_req
*subreq
);
439 static struct tevent_req
*rpc_smbd_write_send(TALLOC_CTX
*mem_ctx
,
440 struct event_context
*ev
,
441 const uint8_t *data
, size_t size
,
444 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
445 priv
, struct rpc_transport_smbd_state
);
446 struct tevent_req
*req
, *subreq
;
447 struct rpc_smbd_write_state
*state
;
449 req
= tevent_req_create(mem_ctx
, &state
, struct rpc_smbd_write_state
);
453 state
->sub_transp
= transp
->sub_transp
;
455 subreq
= transp
->sub_transp
->write_send(state
, ev
, data
, size
,
456 transp
->sub_transp
->priv
);
457 if (subreq
== NULL
) {
461 if (event_add_fd(ev
, state
, transp
->conn
->stdout_fd
, EVENT_FD_READ
,
462 rpc_cli_smbd_stdout_reader
, transp
->conn
) == NULL
) {
465 tevent_req_set_callback(subreq
, rpc_smbd_write_done
, req
);
473 static void rpc_smbd_write_done(struct tevent_req
*subreq
)
475 struct tevent_req
*req
= tevent_req_callback_data(
476 subreq
, struct tevent_req
);
477 struct rpc_smbd_write_state
*state
= tevent_req_data(
478 req
, struct rpc_smbd_write_state
);
481 status
= state
->sub_transp
->write_recv(subreq
, &state
->written
);
483 if (!NT_STATUS_IS_OK(status
)) {
484 tevent_req_nterror(req
, status
);
487 tevent_req_done(req
);
490 static NTSTATUS
rpc_smbd_write_recv(struct tevent_req
*req
, ssize_t
*pwritten
)
492 struct rpc_smbd_write_state
*state
= tevent_req_data(
493 req
, struct rpc_smbd_write_state
);
496 if (tevent_req_is_nterror(req
, &status
)) {
499 *pwritten
= state
->written
;
503 struct rpc_smbd_read_state
{
504 struct rpc_cli_transport
*sub_transp
;
508 static void rpc_smbd_read_done(struct tevent_req
*subreq
);
510 static struct tevent_req
*rpc_smbd_read_send(TALLOC_CTX
*mem_ctx
,
511 struct event_context
*ev
,
512 uint8_t *data
, size_t size
,
515 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
516 priv
, struct rpc_transport_smbd_state
);
517 struct tevent_req
*req
, *subreq
;
518 struct rpc_smbd_read_state
*state
;
520 req
= tevent_req_create(mem_ctx
, &state
, struct rpc_smbd_read_state
);
524 state
->sub_transp
= transp
->sub_transp
;
526 subreq
= transp
->sub_transp
->read_send(state
, ev
, data
, size
,
527 transp
->sub_transp
->priv
);
528 if (subreq
== NULL
) {
532 if (event_add_fd(ev
, state
, transp
->conn
->stdout_fd
, EVENT_FD_READ
,
533 rpc_cli_smbd_stdout_reader
, transp
->conn
) == NULL
) {
536 tevent_req_set_callback(subreq
, rpc_smbd_read_done
, req
);
543 static void rpc_smbd_read_done(struct tevent_req
*subreq
)
545 struct tevent_req
*req
= tevent_req_callback_data(
546 subreq
, struct tevent_req
);
547 struct rpc_smbd_read_state
*state
= tevent_req_data(
548 req
, struct rpc_smbd_read_state
);
551 status
= state
->sub_transp
->read_recv(subreq
, &state
->received
);
553 if (!NT_STATUS_IS_OK(status
)) {
554 tevent_req_nterror(req
, status
);
557 tevent_req_done(req
);
560 static NTSTATUS
rpc_smbd_read_recv(struct tevent_req
*req
, ssize_t
*preceived
)
562 struct rpc_smbd_read_state
*state
= tevent_req_data(
563 req
, struct rpc_smbd_read_state
);
566 if (tevent_req_is_nterror(req
, &status
)) {
569 *preceived
= state
->received
;
573 struct rpc_transport_smbd_init_state
{
574 struct rpc_cli_transport
*transport
;
575 struct rpc_transport_smbd_state
*transport_smbd
;
578 static void rpc_transport_smbd_init_done(struct async_req
*subreq
);
580 struct async_req
*rpc_transport_smbd_init_send(TALLOC_CTX
*mem_ctx
,
581 struct event_context
*ev
,
582 struct rpc_cli_smbd_conn
*conn
,
583 const struct ndr_syntax_id
*abstract_syntax
)
585 struct async_req
*result
, *subreq
;
586 struct rpc_transport_smbd_init_state
*state
;
588 if (!async_req_setup(mem_ctx
, &result
, &state
,
589 struct rpc_transport_smbd_init_state
)) {
593 state
->transport
= talloc(state
, struct rpc_cli_transport
);
594 if (state
->transport
== NULL
) {
597 state
->transport_smbd
= talloc(state
->transport
,
598 struct rpc_transport_smbd_state
);
599 if (state
->transport_smbd
== NULL
) {
602 state
->transport_smbd
->conn
= conn
;
603 state
->transport
->priv
= state
->transport_smbd
;
605 if (event_add_fd(ev
, state
, conn
->stdout_fd
, EVENT_FD_READ
,
606 rpc_cli_smbd_stdout_reader
, conn
) == NULL
) {
610 subreq
= rpc_transport_np_init_send(state
, ev
, conn
->cli
,
612 if (subreq
== NULL
) {
615 subreq
->async
.fn
= rpc_transport_smbd_init_done
;
616 subreq
->async
.priv
= result
;
624 static void rpc_transport_smbd_init_done(struct async_req
*subreq
)
626 struct async_req
*req
= talloc_get_type_abort(
627 subreq
->async
.priv
, struct async_req
);
628 struct rpc_transport_smbd_init_state
*state
= talloc_get_type_abort(
629 req
->private_data
, struct rpc_transport_smbd_init_state
);
632 status
= rpc_transport_np_init_recv(
633 subreq
, state
->transport_smbd
,
634 &state
->transport_smbd
->sub_transp
);
636 if (!NT_STATUS_IS_OK(status
)) {
637 async_req_nterror(req
, status
);
643 NTSTATUS
rpc_transport_smbd_init_recv(struct async_req
*req
,
645 struct rpc_cli_transport
**presult
)
647 struct rpc_transport_smbd_init_state
*state
= talloc_get_type_abort(
648 req
->private_data
, struct rpc_transport_smbd_init_state
);
651 if (async_req_is_nterror(req
, &status
)) {
655 state
->transport
->write_send
= rpc_smbd_write_send
;
656 state
->transport
->write_recv
= rpc_smbd_write_recv
;
657 state
->transport
->read_send
= rpc_smbd_read_send
;
658 state
->transport
->read_recv
= rpc_smbd_read_recv
;
659 state
->transport
->trans_send
= NULL
;
660 state
->transport
->trans_recv
= NULL
;
662 *presult
= talloc_move(mem_ctx
, &state
->transport
);
666 NTSTATUS
rpc_transport_smbd_init(TALLOC_CTX
*mem_ctx
,
667 struct rpc_cli_smbd_conn
*conn
,
668 const struct ndr_syntax_id
*abstract_syntax
,
669 struct rpc_cli_transport
**presult
)
671 TALLOC_CTX
*frame
= talloc_stackframe();
672 struct event_context
*ev
;
673 struct async_req
*req
;
676 ev
= event_context_init(frame
);
678 status
= NT_STATUS_NO_MEMORY
;
682 req
= rpc_transport_smbd_init_send(frame
, ev
, conn
, abstract_syntax
);
684 status
= NT_STATUS_NO_MEMORY
;
688 while (req
->state
< ASYNC_REQ_DONE
) {
692 status
= rpc_transport_smbd_init_recv(req
, mem_ctx
, presult
);