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 static void rpc_smbd_disconnect(struct rpc_transport_smbd_state
*transp
)
434 if (transp
== NULL
) {
438 if (transp
->conn
== NULL
) {
442 if (transp
->conn
->cli
== NULL
) {
446 if (transp
->conn
->cli
->fd
!= -1) {
447 close(transp
->conn
->cli
->fd
);
448 transp
->conn
->cli
->fd
= -1;
454 static bool rpc_smbd_is_connected(void *priv
)
456 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
457 priv
, struct rpc_transport_smbd_state
);
460 if (transp
->conn
== NULL
) {
464 if (transp
->sub_transp
== NULL
) {
468 ok
= transp
->sub_transp
->is_connected(transp
->sub_transp
->priv
);
470 rpc_smbd_disconnect(transp
);
477 static unsigned int rpc_smbd_set_timeout(void *priv
, unsigned int timeout
)
479 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
480 priv
, struct rpc_transport_smbd_state
);
483 ok
= rpc_smbd_is_connected(transp
);
488 if (transp
->sub_transp
->set_timeout
== NULL
) {
492 return transp
->sub_transp
->set_timeout(transp
->sub_transp
->priv
, timeout
);
495 struct rpc_smbd_write_state
{
496 struct rpc_transport_smbd_state
*transp
;
500 static void rpc_smbd_write_done(struct async_req
*subreq
);
502 static struct async_req
*rpc_smbd_write_send(TALLOC_CTX
*mem_ctx
,
503 struct event_context
*ev
,
504 const uint8_t *data
, size_t size
,
507 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
508 priv
, struct rpc_transport_smbd_state
);
509 struct async_req
*result
, *subreq
;
510 struct rpc_smbd_write_state
*state
;
513 if (!async_req_setup(mem_ctx
, &result
, &state
,
514 struct rpc_smbd_write_state
)) {
518 ok
= rpc_smbd_is_connected(transp
);
520 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
527 state
->transp
= transp
;
529 subreq
= transp
->sub_transp
->write_send(state
, ev
, data
, size
,
530 transp
->sub_transp
->priv
);
531 if (subreq
== NULL
) {
535 if (event_add_fd(ev
, state
, transp
->conn
->stdout_fd
, EVENT_FD_READ
,
536 rpc_cli_smbd_stdout_reader
, transp
->conn
) == NULL
) {
540 subreq
->async
.fn
= rpc_smbd_write_done
;
541 subreq
->async
.priv
= result
;
549 static void rpc_smbd_write_done(struct async_req
*subreq
)
551 struct async_req
*req
= talloc_get_type_abort(
552 subreq
->async
.priv
, struct async_req
);
553 struct rpc_smbd_write_state
*state
= talloc_get_type_abort(
554 req
->private_data
, struct rpc_smbd_write_state
);
557 status
= state
->transp
->sub_transp
->write_recv(subreq
, &state
->written
);
559 if (!NT_STATUS_IS_OK(status
)) {
560 rpc_smbd_disconnect(state
->transp
);
561 async_req_nterror(req
, status
);
567 static NTSTATUS
rpc_smbd_write_recv(struct async_req
*req
, ssize_t
*pwritten
)
569 struct rpc_smbd_write_state
*state
= talloc_get_type_abort(
570 req
->private_data
, struct rpc_smbd_write_state
);
573 if (async_req_is_nterror(req
, &status
)) {
576 *pwritten
= state
->written
;
580 struct rpc_smbd_read_state
{
581 struct rpc_transport_smbd_state
*transp
;
585 static void rpc_smbd_read_done(struct async_req
*subreq
);
587 static struct async_req
*rpc_smbd_read_send(TALLOC_CTX
*mem_ctx
,
588 struct event_context
*ev
,
589 uint8_t *data
, size_t size
,
592 struct rpc_transport_smbd_state
*transp
= talloc_get_type_abort(
593 priv
, struct rpc_transport_smbd_state
);
594 struct async_req
*result
, *subreq
;
595 struct rpc_smbd_read_state
*state
;
598 if (!async_req_setup(mem_ctx
, &result
, &state
,
599 struct rpc_smbd_read_state
)) {
603 ok
= rpc_smbd_is_connected(transp
);
605 ok
= async_post_ntstatus(result
, ev
, NT_STATUS_CONNECTION_INVALID
);
612 state
->transp
= transp
;
614 subreq
= transp
->sub_transp
->read_send(state
, ev
, data
, size
,
615 transp
->sub_transp
->priv
);
616 if (subreq
== NULL
) {
620 if (event_add_fd(ev
, state
, transp
->conn
->stdout_fd
, EVENT_FD_READ
,
621 rpc_cli_smbd_stdout_reader
, transp
->conn
) == NULL
) {
625 subreq
->async
.fn
= rpc_smbd_read_done
;
626 subreq
->async
.priv
= result
;
634 static void rpc_smbd_read_done(struct async_req
*subreq
)
636 struct async_req
*req
= talloc_get_type_abort(
637 subreq
->async
.priv
, struct async_req
);
638 struct rpc_smbd_read_state
*state
= talloc_get_type_abort(
639 req
->private_data
, struct rpc_smbd_read_state
);
642 status
= state
->transp
->sub_transp
->read_recv(subreq
, &state
->received
);
644 if (!NT_STATUS_IS_OK(status
)) {
645 rpc_smbd_disconnect(state
->transp
);
646 async_req_nterror(req
, status
);
652 static NTSTATUS
rpc_smbd_read_recv(struct async_req
*req
, ssize_t
*preceived
)
654 struct rpc_smbd_read_state
*state
= talloc_get_type_abort(
655 req
->private_data
, struct rpc_smbd_read_state
);
658 if (async_req_is_nterror(req
, &status
)) {
661 *preceived
= state
->received
;
665 struct rpc_transport_smbd_init_state
{
666 struct rpc_cli_transport
*transport
;
667 struct rpc_transport_smbd_state
*transport_smbd
;
670 static void rpc_transport_smbd_init_done(struct async_req
*subreq
);
672 struct async_req
*rpc_transport_smbd_init_send(TALLOC_CTX
*mem_ctx
,
673 struct event_context
*ev
,
674 struct rpc_cli_smbd_conn
*conn
,
675 const struct ndr_syntax_id
*abstract_syntax
)
677 struct async_req
*result
, *subreq
;
678 struct rpc_transport_smbd_init_state
*state
;
680 if (!async_req_setup(mem_ctx
, &result
, &state
,
681 struct rpc_transport_smbd_init_state
)) {
685 state
->transport
= talloc(state
, struct rpc_cli_transport
);
686 if (state
->transport
== NULL
) {
689 state
->transport_smbd
= talloc(state
->transport
,
690 struct rpc_transport_smbd_state
);
691 if (state
->transport_smbd
== NULL
) {
694 state
->transport_smbd
->conn
= conn
;
695 state
->transport
->priv
= state
->transport_smbd
;
697 if (event_add_fd(ev
, state
, conn
->stdout_fd
, EVENT_FD_READ
,
698 rpc_cli_smbd_stdout_reader
, conn
) == NULL
) {
702 subreq
= rpc_transport_np_init_send(state
, ev
, conn
->cli
,
704 if (subreq
== NULL
) {
707 subreq
->async
.fn
= rpc_transport_smbd_init_done
;
708 subreq
->async
.priv
= result
;
716 static void rpc_transport_smbd_init_done(struct async_req
*subreq
)
718 struct async_req
*req
= talloc_get_type_abort(
719 subreq
->async
.priv
, struct async_req
);
720 struct rpc_transport_smbd_init_state
*state
= talloc_get_type_abort(
721 req
->private_data
, struct rpc_transport_smbd_init_state
);
724 status
= rpc_transport_np_init_recv(
725 subreq
, state
->transport_smbd
,
726 &state
->transport_smbd
->sub_transp
);
728 if (!NT_STATUS_IS_OK(status
)) {
729 async_req_nterror(req
, status
);
735 NTSTATUS
rpc_transport_smbd_init_recv(struct async_req
*req
,
737 struct rpc_cli_transport
**presult
)
739 struct rpc_transport_smbd_init_state
*state
= talloc_get_type_abort(
740 req
->private_data
, struct rpc_transport_smbd_init_state
);
743 if (async_req_is_nterror(req
, &status
)) {
747 state
->transport
->write_send
= rpc_smbd_write_send
;
748 state
->transport
->write_recv
= rpc_smbd_write_recv
;
749 state
->transport
->read_send
= rpc_smbd_read_send
;
750 state
->transport
->read_recv
= rpc_smbd_read_recv
;
751 state
->transport
->trans_send
= NULL
;
752 state
->transport
->trans_recv
= NULL
;
753 state
->transport
->is_connected
= rpc_smbd_is_connected
;
754 state
->transport
->set_timeout
= rpc_smbd_set_timeout
;
756 *presult
= talloc_move(mem_ctx
, &state
->transport
);
760 NTSTATUS
rpc_transport_smbd_init(TALLOC_CTX
*mem_ctx
,
761 struct rpc_cli_smbd_conn
*conn
,
762 const struct ndr_syntax_id
*abstract_syntax
,
763 struct rpc_cli_transport
**presult
)
765 TALLOC_CTX
*frame
= talloc_stackframe();
766 struct event_context
*ev
;
767 struct async_req
*req
;
770 ev
= event_context_init(frame
);
772 status
= NT_STATUS_NO_MEMORY
;
776 req
= rpc_transport_smbd_init_send(frame
, ev
, conn
, abstract_syntax
);
778 status
= NT_STATUS_NO_MEMORY
;
782 while (req
->state
< ASYNC_REQ_DONE
) {
786 status
= rpc_transport_smbd_init_recv(req
, mem_ctx
, presult
);