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);