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 tevent_req *subreq);
132 static void get_anon_ipc_sesssetup_done(struct tevent_req *subreq);
133 static void get_anon_ipc_tcon_done(struct tevent_req *subreq);
135 static struct tevent_req *get_anon_ipc_send(TALLOC_CTX *mem_ctx,
136 struct event_context *ev,
137 struct cli_state *cli)
139 struct tevent_req *req, *subreq;
140 struct get_anon_ipc_state *state;
142 req = tevent_req_create(mem_ctx, &state, struct get_anon_ipc_state);
149 subreq = cli_negprot_send(state, ev, cli);
150 if (tevent_req_nomem(subreq, req)) {
151 return tevent_req_post(req, ev);
153 tevent_req_set_callback(subreq, get_anon_ipc_negprot_done, req);
157 static void get_anon_ipc_negprot_done(struct tevent_req *subreq)
159 struct tevent_req *req = tevent_req_callback_data(
160 subreq, struct tevent_req);
161 struct get_anon_ipc_state *state = tevent_req_data(
162 req, struct get_anon_ipc_state);
165 status = cli_negprot_recv(subreq);
167 if (!NT_STATUS_IS_OK(status)) {
168 tevent_req_nterror(req, status);
172 subreq = cli_session_setup_guest_send(state, state->ev, state->cli);
173 if (tevent_req_nomem(subreq, req)) {
176 tevent_req_set_callback(subreq, get_anon_ipc_sesssetup_done, req);
179 static void get_anon_ipc_sesssetup_done(struct tevent_req *subreq)
181 struct tevent_req *req = tevent_req_callback_data(
182 subreq, struct tevent_req);
183 struct get_anon_ipc_state *state = tevent_req_data(
184 req, struct get_anon_ipc_state);
187 status = cli_session_setup_guest_recv(subreq);
189 if (!NT_STATUS_IS_OK(status)) {
190 tevent_req_nterror(req, status);
194 subreq = cli_tcon_andx_send(state, state->ev, state->cli,
195 "IPC$", "IPC", NULL, 0);
196 if (tevent_req_nomem(subreq, req)) {
199 tevent_req_set_callback(subreq, get_anon_ipc_tcon_done, req);
202 static void get_anon_ipc_tcon_done(struct tevent_req *subreq)
204 struct tevent_req *req = tevent_req_callback_data(
205 subreq, struct tevent_req);
208 status = cli_tcon_andx_recv(subreq);
210 if (!NT_STATUS_IS_OK(status)) {
211 tevent_req_nterror(req, status);
214 tevent_req_done(req);
217 static NTSTATUS get_anon_ipc_recv(struct tevent_req *req)
219 return tevent_req_simple_recv_ntstatus(req);
222 struct rpc_cli_smbd_conn_init_state {
223 struct event_context *ev;
224 struct rpc_cli_smbd_conn *conn;
227 static void rpc_cli_smbd_conn_init_done(struct tevent_req *subreq);
229 struct tevent_req *rpc_cli_smbd_conn_init_send(TALLOC_CTX *mem_ctx,
230 struct event_context *ev,
231 void (*stdout_callback)(char *buf,
236 struct tevent_req *req, *subreq;
237 struct rpc_cli_smbd_conn_init_state *state;
244 smb_sock[0] = smb_sock[1] = stdout_pipe[0] = stdout_pipe[1] = -1;
246 req = tevent_req_create(mem_ctx, &state,
247 struct rpc_cli_smbd_conn_init_state);
253 state->conn = talloc(state, struct rpc_cli_smbd_conn);
254 if (tevent_req_nomem(state->conn, req)) {
255 return tevent_req_post(req, ev);
258 state->conn->cli = cli_initialise();
259 if (tevent_req_nomem(state->conn->cli, req)) {
260 return tevent_req_post(req, ev);
262 state->conn->stdout_fd = -1;
263 state->conn->stdout_callback.fn = stdout_callback;
264 state->conn->stdout_callback.priv = priv;
265 talloc_set_destructor(state->conn, rpc_cli_smbd_conn_destructor);
267 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, smb_sock);
269 status = map_nt_error_from_unix(errno);
272 ret = pipe(stdout_pipe);
274 status = map_nt_error_from_unix(errno);
280 status = map_nt_error_from_unix(errno);
287 close(stdout_pipe[0]);
289 if (dup(smb_sock[1]) == -1) {
294 if (dup(stdout_pipe[1]) == -1) {
297 close(stdout_pipe[1]);
299 smbd_cmd = getenv("SMB_PATH");
301 if ((smbd_cmd == NULL)
302 && (asprintf(&smbd_cmd, "%s/smbd", get_dyn_SBINDIR())
307 if (asprintf(&smbd_cmd, "%s -F -S -d %d", smbd_cmd,
313 exit(system(smbd_cmd));
316 state->conn->cli->fd = smb_sock[0];
321 state->conn->stdout_fd = stdout_pipe[0];
323 close(stdout_pipe[1]);
326 subreq = get_anon_ipc_send(state, ev, state->conn->cli);
327 if (tevent_req_nomem(subreq, req)) {
328 return tevent_req_post(req, ev);
331 if (event_add_fd(ev, state, state->conn->stdout_fd, EVENT_FD_READ,
332 rpc_cli_smbd_stdout_reader, state->conn) == NULL) {
333 status = NT_STATUS_NO_MEMORY;
337 tevent_req_set_callback(subreq, rpc_cli_smbd_conn_init_done, req);
341 if (smb_sock[0] != -1) {
344 if (smb_sock[1] != -1) {
347 if (stdout_pipe[0] != -1) {
348 close(stdout_pipe[0]);
350 if (stdout_pipe[1] != -1) {
351 close(stdout_pipe[1]);
353 tevent_req_nterror(req, status);
354 return tevent_req_post(req, ev);
357 static void rpc_cli_smbd_conn_init_done(struct tevent_req *subreq)
359 struct tevent_req *req = tevent_req_callback_data(
360 subreq, struct tevent_req);
363 status = get_anon_ipc_recv(subreq);
365 if (!NT_STATUS_IS_OK(status)) {
366 tevent_req_nterror(req, status);
369 tevent_req_done(req);
372 NTSTATUS rpc_cli_smbd_conn_init_recv(struct tevent_req *req,
374 struct rpc_cli_smbd_conn **pconn)
376 struct rpc_cli_smbd_conn_init_state *state = tevent_req_data(
377 req, struct rpc_cli_smbd_conn_init_state);
380 if (tevent_req_is_nterror(req, &status)) {
383 *pconn = talloc_move(mem_ctx, &state->conn);
387 NTSTATUS rpc_cli_smbd_conn_init(TALLOC_CTX *mem_ctx,
388 struct rpc_cli_smbd_conn **pconn,
389 void (*stdout_callback)(char *buf,
394 TALLOC_CTX *frame = talloc_stackframe();
395 struct event_context *ev;
396 struct tevent_req *req;
399 ev = event_context_init(frame);
401 status = NT_STATUS_NO_MEMORY;
405 req = rpc_cli_smbd_conn_init_send(frame, ev, stdout_callback, priv);
407 status = NT_STATUS_NO_MEMORY;
411 if (!tevent_req_poll(req, ev)) {
412 status = map_nt_error_from_unix(errno);
416 status = rpc_cli_smbd_conn_init_recv(req, mem_ctx, pconn);
422 static void rpc_smbd_disconnect(struct rpc_transport_smbd_state *transp)
424 if (transp == NULL) {
428 if (transp->conn == NULL) {
432 if (transp->conn->cli == NULL) {
436 if (transp->conn->cli->fd != -1) {
437 close(transp->conn->cli->fd);
438 transp->conn->cli->fd = -1;
444 static bool rpc_smbd_is_connected(void *priv)
446 struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
447 priv, struct rpc_transport_smbd_state);
450 if (transp->conn == NULL) {
454 if (transp->sub_transp == NULL) {
458 ok = transp->sub_transp->is_connected(transp->sub_transp->priv);
460 rpc_smbd_disconnect(transp);
467 static unsigned int rpc_smbd_set_timeout(void *priv, unsigned int timeout)
469 struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
470 priv, struct rpc_transport_smbd_state);
473 ok = rpc_smbd_is_connected(transp);
478 if (transp->sub_transp->set_timeout == NULL) {
482 return transp->sub_transp->set_timeout(transp->sub_transp->priv, timeout);
485 struct rpc_smbd_write_state {
486 struct rpc_transport_smbd_state *transp;
490 static void rpc_smbd_write_done(struct tevent_req *subreq);
492 static struct tevent_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx,
493 struct event_context *ev,
494 const uint8_t *data, size_t size,
497 struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
498 priv, struct rpc_transport_smbd_state);
499 struct tevent_req *req, *subreq;
500 struct rpc_smbd_write_state *state;
503 req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_write_state);
508 ok = rpc_smbd_is_connected(transp);
510 tevent_req_nterror(req, NT_STATUS_CONNECTION_INVALID);
511 return tevent_req_post(req, ev);
514 state->transp = transp;
516 subreq = transp->sub_transp->write_send(state, ev, data, size,
517 transp->sub_transp->priv);
518 if (subreq == NULL) {
522 if (event_add_fd(ev, state, transp->conn->stdout_fd, EVENT_FD_READ,
523 rpc_cli_smbd_stdout_reader, transp->conn) == NULL) {
526 tevent_req_set_callback(subreq, rpc_smbd_write_done, req);
534 static void rpc_smbd_write_done(struct tevent_req *subreq)
536 struct tevent_req *req = tevent_req_callback_data(
537 subreq, struct tevent_req);
538 struct rpc_smbd_write_state *state = tevent_req_data(
539 req, struct rpc_smbd_write_state);
542 status = state->transp->sub_transp->write_recv(subreq, &state->written);
544 if (!NT_STATUS_IS_OK(status)) {
545 rpc_smbd_disconnect(state->transp);
546 tevent_req_nterror(req, status);
549 tevent_req_done(req);
552 static NTSTATUS rpc_smbd_write_recv(struct tevent_req *req, ssize_t *pwritten)
554 struct rpc_smbd_write_state *state = tevent_req_data(
555 req, struct rpc_smbd_write_state);
558 if (tevent_req_is_nterror(req, &status)) {
561 *pwritten = state->written;
565 struct rpc_smbd_read_state {
566 struct rpc_transport_smbd_state *transp;
570 static void rpc_smbd_read_done(struct tevent_req *subreq);
572 static struct tevent_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx,
573 struct event_context *ev,
574 uint8_t *data, size_t size,
577 struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
578 priv, struct rpc_transport_smbd_state);
579 struct tevent_req *req, *subreq;
580 struct rpc_smbd_read_state *state;
583 req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_read_state);
588 ok = rpc_smbd_is_connected(transp);
590 tevent_req_nterror(req, NT_STATUS_CONNECTION_INVALID);
591 return tevent_req_post(req, ev);
594 state->transp = transp;
596 subreq = transp->sub_transp->read_send(state, ev, data, size,
597 transp->sub_transp->priv);
598 if (subreq == NULL) {
602 if (event_add_fd(ev, state, transp->conn->stdout_fd, EVENT_FD_READ,
603 rpc_cli_smbd_stdout_reader, transp->conn) == NULL) {
606 tevent_req_set_callback(subreq, rpc_smbd_read_done, req);
613 static void rpc_smbd_read_done(struct tevent_req *subreq)
615 struct tevent_req *req = tevent_req_callback_data(
616 subreq, struct tevent_req);
617 struct rpc_smbd_read_state *state = tevent_req_data(
618 req, struct rpc_smbd_read_state);
621 status = state->transp->sub_transp->read_recv(subreq, &state->received);
623 if (!NT_STATUS_IS_OK(status)) {
624 rpc_smbd_disconnect(state->transp);
625 tevent_req_nterror(req, status);
628 tevent_req_done(req);
631 static NTSTATUS rpc_smbd_read_recv(struct tevent_req *req, ssize_t *preceived)
633 struct rpc_smbd_read_state *state = tevent_req_data(
634 req, struct rpc_smbd_read_state);
637 if (tevent_req_is_nterror(req, &status)) {
640 *preceived = state->received;
644 struct rpc_transport_smbd_init_state {
645 struct rpc_cli_transport *transport;
646 struct rpc_transport_smbd_state *transport_smbd;
649 static void rpc_transport_smbd_init_done(struct tevent_req *subreq);
651 struct tevent_req *rpc_transport_smbd_init_send(TALLOC_CTX *mem_ctx,
652 struct event_context *ev,
653 struct rpc_cli_smbd_conn *conn,
654 const struct ndr_syntax_id *abstract_syntax)
656 struct tevent_req *req, *subreq;
657 struct rpc_transport_smbd_init_state *state;
659 req = tevent_req_create(mem_ctx, &state,
660 struct rpc_transport_smbd_init_state);
665 state->transport = talloc(state, struct rpc_cli_transport);
666 if (tevent_req_nomem(state->transport, req)) {
667 return tevent_req_post(req, ev);
669 state->transport_smbd = talloc(state->transport,
670 struct rpc_transport_smbd_state);
671 if (tevent_req_nomem(state->transport_smbd, req)) {
672 return tevent_req_post(req, ev);
674 state->transport_smbd->conn = conn;
675 state->transport->priv = state->transport_smbd;
677 if (event_add_fd(ev, state, conn->stdout_fd, EVENT_FD_READ,
678 rpc_cli_smbd_stdout_reader, conn) == NULL) {
679 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
680 return tevent_req_post(req, ev);
683 subreq = rpc_transport_np_init_send(state, ev, conn->cli,
685 if (tevent_req_nomem(subreq, req)) {
686 return tevent_req_post(req, ev);
688 tevent_req_set_callback(subreq, rpc_transport_smbd_init_done, req);
692 static void rpc_transport_smbd_init_done(struct tevent_req *subreq)
694 struct tevent_req *req = tevent_req_callback_data(
695 subreq, struct tevent_req);
696 struct rpc_transport_smbd_init_state *state = tevent_req_data(
697 req, struct rpc_transport_smbd_init_state);
700 status = rpc_transport_np_init_recv(
701 subreq, state->transport_smbd,
702 &state->transport_smbd->sub_transp);
704 if (!NT_STATUS_IS_OK(status)) {
705 tevent_req_nterror(req, status);
708 tevent_req_done(req);
711 NTSTATUS rpc_transport_smbd_init_recv(struct tevent_req *req,
713 struct rpc_cli_transport **presult)
715 struct rpc_transport_smbd_init_state *state = tevent_req_data(
716 req, struct rpc_transport_smbd_init_state);
719 if (tevent_req_is_nterror(req, &status)) {
723 state->transport->write_send = rpc_smbd_write_send;
724 state->transport->write_recv = rpc_smbd_write_recv;
725 state->transport->read_send = rpc_smbd_read_send;
726 state->transport->read_recv = rpc_smbd_read_recv;
727 state->transport->trans_send = NULL;
728 state->transport->trans_recv = NULL;
729 state->transport->is_connected = rpc_smbd_is_connected;
730 state->transport->set_timeout = rpc_smbd_set_timeout;
732 *presult = talloc_move(mem_ctx, &state->transport);
736 NTSTATUS rpc_transport_smbd_init(TALLOC_CTX *mem_ctx,
737 struct rpc_cli_smbd_conn *conn,
738 const struct ndr_syntax_id *abstract_syntax,
739 struct rpc_cli_transport **presult)
741 TALLOC_CTX *frame = talloc_stackframe();
742 struct event_context *ev;
743 struct tevent_req *req;
746 ev = event_context_init(frame);
748 status = NT_STATUS_NO_MEMORY;
752 req = rpc_transport_smbd_init_send(frame, ev, conn, abstract_syntax);
754 status = NT_STATUS_NO_MEMORY;
758 if (!tevent_req_poll(req, ev)) {
759 status = map_nt_error_from_unix(errno);
763 status = rpc_transport_smbd_init_recv(req, mem_ctx, presult);