2 Unix SMB/Netbios implementation.
3 Generic infrstructure for RPC Daemons
4 Copyright (C) Simo Sorce 2010
5 Copyright (C) Andrew Bartlett 2011
6 Copyright (C) Andreas Schneider 2011
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "rpc_server/rpc_pipes.h"
24 #include "rpc_server/rpc_server.h"
25 #include "rpc_server/rpc_config.h"
27 #include "librpc/gen_ndr/netlogon.h"
28 #include "librpc/gen_ndr/auth.h"
29 #include "lib/tsocket/tsocket.h"
30 #include "libcli/named_pipe_auth/npa_tstream.h"
31 #include "../auth/auth_sam_reply.h"
33 #include "rpc_server/rpc_ncacn_np.h"
34 #include "rpc_server/srv_pipe_hnd.h"
35 #include "rpc_server/srv_pipe.h"
37 #define SERVER_TCP_LOW_PORT 1024
38 #define SERVER_TCP_HIGH_PORT 1300
40 static NTSTATUS
auth_anonymous_session_info(TALLOC_CTX
*mem_ctx
,
41 struct auth_session_info
**session_info
)
45 status
= make_session_info_guest(mem_ctx
, session_info
);
46 if (!NT_STATUS_IS_OK(status
)) {
53 /* Creates a pipes_struct and initializes it with the information
54 * sent from the client */
55 static int make_server_pipes_struct(TALLOC_CTX
*mem_ctx
,
56 struct messaging_context
*msg_ctx
,
57 const char *pipe_name
,
58 enum dcerpc_transport_t transport
,
59 bool ncalrpc_as_system
,
60 const struct tsocket_address
*local_address
,
61 const struct tsocket_address
*remote_address
,
62 struct auth_session_info
*session_info
,
63 struct pipes_struct
**_p
,
66 struct pipes_struct
*p
;
70 ret
= make_base_pipes_struct(mem_ctx
, msg_ctx
, pipe_name
,
71 transport
, RPC_LITTLE_ENDIAN
,
73 remote_address
, local_address
, &p
);
79 if (session_info
->unix_token
&& session_info
->unix_info
&& session_info
->security_token
) {
80 /* Don't call create_local_token(), we already have the full details here */
81 p
->session_info
= talloc_steal(p
, session_info
);
84 struct auth_user_info_dc
*auth_user_info_dc
;
85 struct auth_serversupplied_info
*server_info
;
86 struct netr_SamInfo3
*info3
;
88 /* Fake up an auth_user_info_dc for now, to make an info3, to make the session_info structure */
89 auth_user_info_dc
= talloc_zero(p
, struct auth_user_info_dc
);
90 if (!auth_user_info_dc
) {
96 auth_user_info_dc
->num_sids
= session_info
->security_token
->num_sids
;
97 auth_user_info_dc
->sids
= session_info
->security_token
->sids
;
98 auth_user_info_dc
->info
= session_info
->info
;
99 auth_user_info_dc
->user_session_key
= session_info
->session_key
;
101 /* This creates the input structure that make_server_info_info3 is looking for */
102 status
= auth_convert_user_info_dc_saminfo3(p
, auth_user_info_dc
,
105 if (!NT_STATUS_IS_OK(status
)) {
106 DEBUG(1, ("Failed to convert auth_user_info_dc into netr_SamInfo3\n"));
112 status
= make_server_info_info3(p
,
113 info3
->base
.account_name
.string
,
114 info3
->base
.logon_domain
.string
,
115 &server_info
, info3
);
116 if (!NT_STATUS_IS_OK(status
)) {
117 DEBUG(1, ("Failed to init server info\n"));
124 * Some internal functions need a local token to determine access to
127 status
= create_local_token(p
, server_info
, &session_info
->session_key
, info3
->base
.account_name
.string
,
129 talloc_free(server_info
);
130 if (!NT_STATUS_IS_OK(status
)) {
131 DEBUG(1, ("Failed to init local auth token\n"));
142 /* Start listening on the appropriate unix socket and setup all is needed to
143 * dispatch requests to the pipes rpc implementation */
145 struct dcerpc_ncacn_listen_state
{
146 struct ndr_syntax_id syntax_id
;
154 struct tevent_context
*ev_ctx
;
155 struct messaging_context
*msg_ctx
;
156 dcerpc_ncacn_disconnect_fn disconnect_fn
;
159 static void named_pipe_listener(struct tevent_context
*ev
,
160 struct tevent_fd
*fde
,
164 int create_named_pipe_socket(const char *pipe_name
)
170 * As lp_ncalrpc_dir() should have 0755, but
171 * lp_ncalrpc_dir()/np should have 0700, we need to
172 * create lp_ncalrpc_dir() first.
174 if (!directory_create_or_exist(lp_ncalrpc_dir(), geteuid(), 0755)) {
175 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
176 lp_ncalrpc_dir(), strerror(errno
)));
180 np_dir
= talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
182 DEBUG(0, ("Out of memory\n"));
186 if (!directory_create_or_exist(np_dir
, geteuid(), 0700)) {
187 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
188 np_dir
, strerror(errno
)));
192 fd
= create_pipe_sock(np_dir
, pipe_name
, 0700);
194 DEBUG(0, ("Failed to create pipe socket! [%s/%s]\n",
199 DEBUG(10, ("Openened pipe socket fd %d for %s\n", fd
, pipe_name
));
206 bool setup_named_pipe_socket(const char *pipe_name
,
207 struct tevent_context
*ev_ctx
,
208 struct messaging_context
*msg_ctx
)
210 struct dcerpc_ncacn_listen_state
*state
;
211 struct tevent_fd
*fde
;
214 state
= talloc(ev_ctx
, struct dcerpc_ncacn_listen_state
);
216 DEBUG(0, ("Out of memory\n"));
219 state
->ep
.name
= talloc_strdup(state
, pipe_name
);
220 if (state
->ep
.name
== NULL
) {
221 DEBUG(0, ("Out of memory\n"));
224 state
->fd
= create_named_pipe_socket(pipe_name
);
225 if (state
->fd
== -1) {
229 rc
= listen(state
->fd
, 5);
231 DEBUG(0, ("Failed to listen on pipe socket %s: %s\n",
232 pipe_name
, strerror(errno
)));
236 state
->ev_ctx
= ev_ctx
;
237 state
->msg_ctx
= msg_ctx
;
239 DEBUG(10, ("Openened pipe socket fd %d for %s\n",
240 state
->fd
, pipe_name
));
242 fde
= tevent_add_fd(ev_ctx
,
243 state
, state
->fd
, TEVENT_FD_READ
,
244 named_pipe_listener
, state
);
246 DEBUG(0, ("Failed to add event handler!\n"));
250 tevent_fd_set_auto_close(fde
);
254 if (state
->fd
!= -1) {
261 static void named_pipe_listener(struct tevent_context
*ev
,
262 struct tevent_fd
*fde
,
266 struct dcerpc_ncacn_listen_state
*state
=
267 talloc_get_type_abort(private_data
,
268 struct dcerpc_ncacn_listen_state
);
269 struct sockaddr_un sunaddr
;
273 /* TODO: should we have a limit to the number of clients ? */
275 len
= sizeof(sunaddr
);
277 sd
= accept(state
->fd
,
278 (struct sockaddr
*)(void *)&sunaddr
, &len
);
281 if (errno
!= EINTR
) {
282 DEBUG(6, ("Failed to get a valid socket [%s]\n",
288 DEBUG(6, ("Accepted socket %d\n", sd
));
290 named_pipe_accept_function(state
->ev_ctx
,
297 /* This is the core of the rpc server.
298 * Accepts connections from clients and process requests using the appropriate
299 * dispatcher table. */
301 struct named_pipe_client
{
302 const char *pipe_name
;
304 struct tevent_context
*ev
;
305 struct messaging_context
*msg_ctx
;
308 uint16_t device_state
;
309 uint64_t allocation_size
;
311 struct tstream_context
*tstream
;
313 struct tsocket_address
*client
;
315 struct tsocket_address
*server
;
318 struct auth_session_info
*session_info
;
320 struct pipes_struct
*p
;
322 struct tevent_queue
*write_queue
;
327 named_pipe_termination_fn
*term_fn
;
331 static int named_pipe_destructor(struct named_pipe_client
*npc
)
334 npc
->term_fn(npc
->private_data
);
339 static void named_pipe_accept_done(struct tevent_req
*subreq
);
341 void named_pipe_accept_function(struct tevent_context
*ev_ctx
,
342 struct messaging_context
*msg_ctx
,
343 const char *pipe_name
, int fd
,
344 named_pipe_termination_fn
*term_fn
,
347 struct named_pipe_client
*npc
;
348 struct tstream_context
*plain
;
349 struct tevent_req
*subreq
;
352 npc
= talloc_zero(ev_ctx
, struct named_pipe_client
);
354 DEBUG(0, ("Out of memory!\n"));
359 npc
->pipe_name
= talloc_strdup(npc
, pipe_name
);
360 if (npc
->pipe_name
== NULL
) {
361 DEBUG(0, ("Out of memory!\n"));
367 npc
->msg_ctx
= msg_ctx
;
368 npc
->term_fn
= term_fn
;
369 npc
->private_data
= private_data
;
371 talloc_set_destructor(npc
, named_pipe_destructor
);
373 /* make sure socket is in NON blocking state */
374 ret
= set_blocking(fd
, false);
376 DEBUG(2, ("Failed to make socket non-blocking\n"));
382 ret
= tstream_bsd_existing_socket(npc
, fd
, &plain
);
384 DEBUG(2, ("Failed to create tstream socket\n"));
390 npc
->file_type
= FILE_TYPE_MESSAGE_MODE_PIPE
;
391 npc
->device_state
= 0xff | 0x0400 | 0x0100;
392 npc
->allocation_size
= 4096;
394 subreq
= tstream_npa_accept_existing_send(npc
, npc
->ev
, plain
,
397 npc
->allocation_size
);
399 DEBUG(2, ("Failed to start async accept procedure\n"));
404 tevent_req_set_callback(subreq
, named_pipe_accept_done
, npc
);
407 static void named_pipe_packet_process(struct tevent_req
*subreq
);
408 static void named_pipe_packet_done(struct tevent_req
*subreq
);
410 static void named_pipe_accept_done(struct tevent_req
*subreq
)
412 struct auth_session_info_transport
*session_info_transport
;
413 struct named_pipe_client
*npc
=
414 tevent_req_callback_data(subreq
, struct named_pipe_client
);
418 ret
= tstream_npa_accept_existing_recv(subreq
, &error
, npc
,
424 &session_info_transport
);
426 npc
->session_info
= talloc_move(npc
, &session_info_transport
->session_info
);
430 DEBUG(2, ("Failed to accept named pipe connection! (%s)\n",
436 ret
= make_server_pipes_struct(npc
,
438 npc
->pipe_name
, NCACN_NP
,
439 false, npc
->server
, npc
->client
, npc
->session_info
,
442 DEBUG(2, ("Failed to create pipes_struct! (%s)\n",
447 npc
->write_queue
= tevent_queue_create(npc
, "np_server_write_queue");
448 if (!npc
->write_queue
) {
449 DEBUG(2, ("Failed to set up write queue!\n"));
453 /* And now start receiving and processing packets */
454 subreq
= dcerpc_read_ncacn_packet_send(npc
, npc
->ev
, npc
->tstream
);
456 DEBUG(2, ("Failed to start receving packets\n"));
459 tevent_req_set_callback(subreq
, named_pipe_packet_process
, npc
);
463 DEBUG(2, ("Fatal error. Terminating client(%s) connection!\n",
465 /* terminate client connection */
470 static void named_pipe_packet_process(struct tevent_req
*subreq
)
472 struct named_pipe_client
*npc
=
473 tevent_req_callback_data(subreq
, struct named_pipe_client
);
474 struct _output_data
*out
= &npc
->p
->out_data
;
475 DATA_BLOB recv_buffer
= data_blob_null
;
476 struct ncacn_packet
*pkt
;
485 status
= dcerpc_read_ncacn_packet_recv(subreq
, npc
, &pkt
, &recv_buffer
);
487 if (!NT_STATUS_IS_OK(status
)) {
491 data_left
= recv_buffer
.length
;
492 data
= (char *)recv_buffer
.data
;
496 data_used
= process_incoming_data(npc
->p
, data
, data_left
);
498 DEBUG(3, ("Failed to process dceprc request!\n"));
499 status
= NT_STATUS_UNEXPECTED_IO_ERROR
;
503 data_left
-= data_used
;
507 /* Do not leak this buffer, npc is a long lived context */
508 talloc_free(recv_buffer
.data
);
511 /* this is needed because of the way DCERPC Binds work in
512 * the RPC marshalling code */
513 to_send
= out
->frag
.length
- out
->current_pdu_sent
;
516 npc
->iov
= talloc_zero(npc
, struct iovec
);
518 status
= NT_STATUS_NO_MEMORY
;
523 npc
->iov
[0].iov_base
= out
->frag
.data
524 + out
->current_pdu_sent
;
525 npc
->iov
[0].iov_len
= to_send
;
527 out
->current_pdu_sent
+= to_send
;
530 /* this condition is false for bind packets, or when we haven't
531 * yet got a full request, and need to wait for more data from
533 while (out
->data_sent_length
< out
->rdata
.length
) {
535 ok
= create_next_pdu(npc
->p
);
537 DEBUG(3, ("Failed to create next PDU!\n"));
538 status
= NT_STATUS_UNEXPECTED_IO_ERROR
;
542 npc
->iov
= talloc_realloc(npc
, npc
->iov
,
543 struct iovec
, npc
->count
+ 1);
545 status
= NT_STATUS_NO_MEMORY
;
549 npc
->iov
[npc
->count
].iov_base
= out
->frag
.data
;
550 npc
->iov
[npc
->count
].iov_len
= out
->frag
.length
;
555 /* we still don't have a complete request, go back and wait for more
557 if (npc
->count
== 0) {
558 /* Wait for the next packet */
559 subreq
= dcerpc_read_ncacn_packet_send(npc
, npc
->ev
, npc
->tstream
);
561 DEBUG(2, ("Failed to start receving packets\n"));
562 status
= NT_STATUS_NO_MEMORY
;
565 tevent_req_set_callback(subreq
, named_pipe_packet_process
, npc
);
569 DEBUG(10, ("Sending %u fragments in a total of %u bytes\n",
570 (unsigned int)npc
->count
,
571 (unsigned int)npc
->p
->out_data
.data_sent_length
));
573 for (i
= 0; i
< npc
->count
; i
++) {
574 DEBUG(10, ("Sending PDU number: %d, PDU Length: %u\n",
576 (unsigned int)npc
->iov
[i
].iov_len
));
577 dump_data(11, (const uint8_t *)npc
->iov
[i
].iov_base
,
578 npc
->iov
[i
].iov_len
);
580 subreq
= tstream_writev_queue_send(npc
,
587 DEBUG(2, ("Failed to send packet\n"));
588 status
= NT_STATUS_NO_MEMORY
;
591 tevent_req_set_callback(subreq
, named_pipe_packet_done
, npc
);
597 DEBUG(2, ("Fatal error(%s). "
598 "Terminating client(%s) connection!\n",
599 nt_errstr(status
), npc
->client_name
));
600 /* terminate client connection */
605 static void named_pipe_packet_done(struct tevent_req
*subreq
)
607 struct named_pipe_client
*npc
=
608 tevent_req_callback_data(subreq
, struct named_pipe_client
);
612 ret
= tstream_writev_queue_recv(subreq
, &sys_errno
);
615 DEBUG(2, ("Writev failed!\n"));
619 if (tevent_queue_length(npc
->write_queue
) > 0) {
623 /* clear out any data that may have been left around */
625 TALLOC_FREE(npc
->iov
);
626 data_blob_free(&npc
->p
->in_data
.data
);
627 data_blob_free(&npc
->p
->out_data
.frag
);
628 data_blob_free(&npc
->p
->out_data
.rdata
);
630 talloc_free_children(npc
->p
->mem_ctx
);
632 /* Wait for the next packet */
633 subreq
= dcerpc_read_ncacn_packet_send(npc
, npc
->ev
, npc
->tstream
);
635 DEBUG(2, ("Failed to start receving packets\n"));
639 tevent_req_set_callback(subreq
, named_pipe_packet_process
, npc
);
643 DEBUG(2, ("Fatal error(%s). "
644 "Terminating client(%s) connection!\n",
645 strerror(sys_errno
), npc
->client_name
));
646 /* terminate client connection */
651 /********************************************************************
652 * Start listening on the tcp/ip socket
653 ********************************************************************/
655 static void dcerpc_ncacn_tcpip_listener(struct tevent_context
*ev
,
656 struct tevent_fd
*fde
,
660 int create_tcpip_socket(const struct sockaddr_storage
*ifss
, uint16_t *port
)
667 for (i
= SERVER_TCP_LOW_PORT
; i
<= SERVER_TCP_HIGH_PORT
; i
++) {
668 fd
= open_socket_in(SOCK_STREAM
,
679 fd
= open_socket_in(SOCK_STREAM
,
686 DEBUG(0, ("Failed to create socket on port %u!\n", *port
));
690 DEBUG(10, ("Opened tcpip socket fd %d for port %u\n", fd
, *port
));
695 uint16_t setup_dcerpc_ncacn_tcpip_socket(struct tevent_context
*ev_ctx
,
696 struct messaging_context
*msg_ctx
,
697 const struct sockaddr_storage
*ifss
,
700 struct dcerpc_ncacn_listen_state
*state
;
701 struct tevent_fd
*fde
;
704 state
= talloc(ev_ctx
, struct dcerpc_ncacn_listen_state
);
706 DEBUG(0, ("setup_dcerpc_ncacn_tcpip_socket: Out of memory\n"));
711 state
->ep
.port
= port
;
712 state
->disconnect_fn
= NULL
;
714 state
->fd
= create_tcpip_socket(ifss
, &state
->ep
.port
);
715 if (state
->fd
== -1) {
719 state
->ev_ctx
= ev_ctx
;
720 state
->msg_ctx
= msg_ctx
;
722 /* ready to listen */
723 set_socket_options(state
->fd
, "SO_KEEPALIVE");
724 set_socket_options(state
->fd
, lp_socket_options());
726 /* Set server socket to non-blocking for the accept. */
727 set_blocking(state
->fd
, false);
729 rc
= listen(state
->fd
, SMBD_LISTEN_BACKLOG
);
731 DEBUG(0,("setup_tcpip_socket: listen - %s\n", strerror(errno
)));
735 DEBUG(10, ("setup_tcpip_socket: openened socket fd %d for port %u\n",
736 state
->fd
, state
->ep
.port
));
738 fde
= tevent_add_fd(state
->ev_ctx
,
742 dcerpc_ncacn_tcpip_listener
,
745 DEBUG(0, ("setup_tcpip_socket: Failed to add event handler!\n"));
749 tevent_fd_set_auto_close(fde
);
751 return state
->ep
.port
;
753 if (state
->fd
!= -1) {
761 static void dcerpc_ncacn_tcpip_listener(struct tevent_context
*ev
,
762 struct tevent_fd
*fde
,
766 struct dcerpc_ncacn_listen_state
*state
=
767 talloc_get_type_abort(private_data
,
768 struct dcerpc_ncacn_listen_state
);
769 struct tsocket_address
*cli_addr
= NULL
;
770 struct tsocket_address
*srv_addr
= NULL
;
771 struct sockaddr_storage addr
;
772 socklen_t in_addrlen
= sizeof(addr
);
776 s
= accept(state
->fd
, (struct sockaddr
*)(void *) &addr
, &in_addrlen
);
778 if (errno
!= EINTR
) {
779 DEBUG(0,("tcpip_listener accept: %s\n",
785 rc
= tsocket_address_bsd_from_sockaddr(state
,
786 (struct sockaddr
*)(void *) &addr
,
794 rc
= getsockname(s
, (struct sockaddr
*)(void *) &addr
, &in_addrlen
);
800 rc
= tsocket_address_bsd_from_sockaddr(state
,
801 (struct sockaddr
*)(void *) &addr
,
809 DEBUG(6, ("tcpip_listener: Accepted socket %d\n", s
));
811 dcerpc_ncacn_accept(state
->ev_ctx
,
821 /********************************************************************
822 * Start listening on the ncalrpc socket
823 ********************************************************************/
825 static void dcerpc_ncalrpc_listener(struct tevent_context
*ev
,
826 struct tevent_fd
*fde
,
830 int create_dcerpc_ncalrpc_socket(const char *name
)
838 if (!directory_create_or_exist(lp_ncalrpc_dir(), geteuid(), 0755)) {
839 DEBUG(0, ("Failed to create ncalrpc directory %s - %s\n",
840 lp_ncalrpc_dir(), strerror(errno
)));
844 fd
= create_pipe_sock(lp_ncalrpc_dir(), name
, 0755);
846 DEBUG(0, ("Failed to create ncalrpc socket! [%s/%s]\n",
847 lp_ncalrpc_dir(), name
));
851 DEBUG(10, ("Openened ncalrpc socket fd %d for %s\n", fd
, name
));
856 bool setup_dcerpc_ncalrpc_socket(struct tevent_context
*ev_ctx
,
857 struct messaging_context
*msg_ctx
,
859 dcerpc_ncacn_disconnect_fn fn
)
861 struct dcerpc_ncacn_listen_state
*state
;
862 struct tevent_fd
*fde
;
865 state
= talloc(ev_ctx
, struct dcerpc_ncacn_listen_state
);
867 DEBUG(0, ("Out of memory\n"));
872 state
->disconnect_fn
= fn
;
878 state
->ep
.name
= talloc_strdup(state
, name
);
879 if (state
->ep
.name
== NULL
) {
880 DEBUG(0, ("Out of memory\n"));
885 state
->fd
= create_dcerpc_ncalrpc_socket(name
);
886 if (state
->fd
== -1) {
890 rc
= listen(state
->fd
, 5);
892 DEBUG(0, ("Failed to listen on ncalrpc socket %s: %s\n",
893 name
, strerror(errno
)));
897 state
->ev_ctx
= ev_ctx
;
898 state
->msg_ctx
= msg_ctx
;
900 /* Set server socket to non-blocking for the accept. */
901 set_blocking(state
->fd
, false);
903 fde
= tevent_add_fd(state
->ev_ctx
,
907 dcerpc_ncalrpc_listener
,
910 DEBUG(0, ("Failed to add event handler for ncalrpc!\n"));
914 tevent_fd_set_auto_close(fde
);
918 if (state
->fd
!= -1) {
926 static void dcerpc_ncalrpc_listener(struct tevent_context
*ev
,
927 struct tevent_fd
*fde
,
931 struct dcerpc_ncacn_listen_state
*state
=
932 talloc_get_type_abort(private_data
,
933 struct dcerpc_ncacn_listen_state
);
934 struct tsocket_address
*cli_addr
= NULL
;
935 struct sockaddr_un sunaddr
;
936 struct sockaddr
*addr
= (struct sockaddr
*)(void *)&sunaddr
;
937 socklen_t len
= sizeof(sunaddr
);
941 ZERO_STRUCT(sunaddr
);
943 sd
= accept(state
->fd
, addr
, &len
);
945 if (errno
!= EINTR
) {
946 DEBUG(0, ("ncalrpc accept() failed: %s\n", strerror(errno
)));
951 rc
= tsocket_address_bsd_from_sockaddr(state
,
959 DEBUG(10, ("Accepted ncalrpc socket %d\n", sd
));
961 dcerpc_ncacn_accept(state
->ev_ctx
,
966 state
->disconnect_fn
);
969 struct dcerpc_ncacn_conn
{
970 enum dcerpc_transport_t transport
;
974 struct pipes_struct
*p
;
975 dcerpc_ncacn_disconnect_fn disconnect_fn
;
977 struct tevent_context
*ev_ctx
;
978 struct messaging_context
*msg_ctx
;
980 struct tstream_context
*tstream
;
981 struct tevent_queue
*send_queue
;
983 struct tsocket_address
*client
;
985 struct tsocket_address
*server
;
987 struct auth_session_info
*session_info
;
993 static void dcerpc_ncacn_packet_process(struct tevent_req
*subreq
);
994 static void dcerpc_ncacn_packet_done(struct tevent_req
*subreq
);
996 void dcerpc_ncacn_accept(struct tevent_context
*ev_ctx
,
997 struct messaging_context
*msg_ctx
,
998 enum dcerpc_transport_t transport
,
1000 struct tsocket_address
*cli_addr
,
1001 struct tsocket_address
*srv_addr
,
1003 dcerpc_ncacn_disconnect_fn fn
) {
1004 struct dcerpc_ncacn_conn
*ncacn_conn
;
1005 struct tevent_req
*subreq
;
1006 bool system_user
= false;
1014 DEBUG(10, ("dcerpc_ncacn_accept\n"));
1016 ncacn_conn
= talloc_zero(ev_ctx
, struct dcerpc_ncacn_conn
);
1017 if (ncacn_conn
== NULL
) {
1018 DEBUG(0, ("Out of memory!\n"));
1023 ncacn_conn
->transport
= transport
;
1024 ncacn_conn
->ev_ctx
= ev_ctx
;
1025 ncacn_conn
->msg_ctx
= msg_ctx
;
1026 ncacn_conn
->sock
= s
;
1027 ncacn_conn
->disconnect_fn
= fn
;
1029 ncacn_conn
->client
= talloc_move(ncacn_conn
, &cli_addr
);
1030 if (tsocket_address_is_inet(ncacn_conn
->client
, "ip")) {
1031 ncacn_conn
->client_name
=
1032 tsocket_address_inet_addr_string(ncacn_conn
->client
,
1035 ncacn_conn
->client_name
=
1036 tsocket_address_unix_path(ncacn_conn
->client
,
1039 if (ncacn_conn
->client_name
== NULL
) {
1040 DEBUG(0, ("Out of memory!\n"));
1041 talloc_free(ncacn_conn
);
1046 if (srv_addr
!= NULL
) {
1047 ncacn_conn
->server
= talloc_move(ncacn_conn
, &srv_addr
);
1049 ncacn_conn
->server_name
=
1050 tsocket_address_inet_addr_string(ncacn_conn
->server
,
1052 if (ncacn_conn
->server_name
== NULL
) {
1053 DEBUG(0, ("Out of memory!\n"));
1054 talloc_free(ncacn_conn
);
1060 switch (transport
) {
1062 pipe_name
= tsocket_address_string(ncacn_conn
->client
,
1064 if (pipe_name
== NULL
) {
1066 talloc_free(ncacn_conn
);
1072 rc
= getpeereid(s
, &uid
, &gid
);
1074 DEBUG(2, ("Failed to get ncalrpc connecting "
1075 "uid - %s!\n", strerror(errno
)));
1077 if (uid
== sec_initial_uid()) {
1082 pipe_name
= talloc_strdup(ncacn_conn
,
1084 if (pipe_name
== NULL
) {
1086 talloc_free(ncacn_conn
);
1091 DEBUG(0, ("unknown dcerpc transport: %u!\n",
1093 talloc_free(ncacn_conn
);
1098 rc
= set_blocking(s
, false);
1100 DEBUG(2, ("Failed to set dcerpc socket to non-blocking\n"));
1101 talloc_free(ncacn_conn
);
1107 * As soon as we have tstream_bsd_existing_socket set up it will
1108 * take care of closing the socket.
1110 rc
= tstream_bsd_existing_socket(ncacn_conn
, s
, &ncacn_conn
->tstream
);
1112 DEBUG(2, ("Failed to create tstream socket for dcerpc\n"));
1113 talloc_free(ncacn_conn
);
1118 if (ncacn_conn
->session_info
== NULL
) {
1119 status
= auth_anonymous_session_info(ncacn_conn
,
1120 &ncacn_conn
->session_info
);
1121 if (!NT_STATUS_IS_OK(status
)) {
1122 DEBUG(2, ("Failed to create "
1123 "auth_anonymous_session_info - %s\n",
1124 nt_errstr(status
)));
1125 talloc_free(ncacn_conn
);
1130 rc
= make_server_pipes_struct(ncacn_conn
,
1131 ncacn_conn
->msg_ctx
,
1133 ncacn_conn
->transport
,
1137 ncacn_conn
->session_info
,
1141 DEBUG(2, ("Failed to create pipe struct - %s",
1142 strerror(sys_errno
)));
1143 talloc_free(ncacn_conn
);
1147 ncacn_conn
->send_queue
= tevent_queue_create(ncacn_conn
,
1148 "dcerpc send queue");
1149 if (ncacn_conn
->send_queue
== NULL
) {
1150 DEBUG(0, ("Out of memory!\n"));
1151 talloc_free(ncacn_conn
);
1155 subreq
= dcerpc_read_ncacn_packet_send(ncacn_conn
,
1157 ncacn_conn
->tstream
);
1158 if (subreq
== NULL
) {
1159 DEBUG(2, ("Failed to send ncacn packet\n"));
1160 talloc_free(ncacn_conn
);
1164 tevent_req_set_callback(subreq
, dcerpc_ncacn_packet_process
, ncacn_conn
);
1166 DEBUG(10, ("dcerpc_ncacn_accept done\n"));
1171 static void dcerpc_ncacn_packet_process(struct tevent_req
*subreq
)
1173 struct dcerpc_ncacn_conn
*ncacn_conn
=
1174 tevent_req_callback_data(subreq
, struct dcerpc_ncacn_conn
);
1176 struct _output_data
*out
= &ncacn_conn
->p
->out_data
;
1177 DATA_BLOB recv_buffer
= data_blob_null
;
1178 struct ncacn_packet
*pkt
;
1186 status
= dcerpc_read_ncacn_packet_recv(subreq
, ncacn_conn
, &pkt
, &recv_buffer
);
1187 TALLOC_FREE(subreq
);
1188 if (!NT_STATUS_IS_OK(status
)) {
1189 if (ncacn_conn
->disconnect_fn
!= NULL
) {
1190 ok
= ncacn_conn
->disconnect_fn(ncacn_conn
->p
);
1192 DEBUG(3, ("Failed to call disconnect function\n"));
1198 data_left
= recv_buffer
.length
;
1199 data
= (char *) recv_buffer
.data
;
1202 data_used
= process_incoming_data(ncacn_conn
->p
, data
, data_left
);
1203 if (data_used
< 0) {
1204 DEBUG(3, ("Failed to process dcerpc request!\n"));
1205 status
= NT_STATUS_UNEXPECTED_IO_ERROR
;
1209 data_left
-= data_used
;
1213 /* Do not leak this buffer */
1214 talloc_free(recv_buffer
.data
);
1218 * This is needed because of the way DCERPC binds work in the RPC
1221 to_send
= out
->frag
.length
- out
->current_pdu_sent
;
1224 DEBUG(10, ("Current_pdu_len = %u, "
1225 "current_pdu_sent = %u "
1226 "Returning %u bytes\n",
1227 (unsigned int)out
->frag
.length
,
1228 (unsigned int)out
->current_pdu_sent
,
1229 (unsigned int)to_send
));
1231 ncacn_conn
->iov
= talloc_zero(ncacn_conn
, struct iovec
);
1232 if (ncacn_conn
->iov
== NULL
) {
1233 status
= NT_STATUS_NO_MEMORY
;
1234 DEBUG(3, ("Out of memory!\n"));
1237 ncacn_conn
->count
= 1;
1239 ncacn_conn
->iov
[0].iov_base
= out
->frag
.data
1240 + out
->current_pdu_sent
;
1241 ncacn_conn
->iov
[0].iov_len
= to_send
;
1243 out
->current_pdu_sent
+= to_send
;
1247 * This condition is false for bind packets, or when we haven't yet got
1248 * a full request, and need to wait for more data from the client
1250 while (out
->data_sent_length
< out
->rdata
.length
) {
1251 ok
= create_next_pdu(ncacn_conn
->p
);
1253 DEBUG(3, ("Failed to create next PDU!\n"));
1254 status
= NT_STATUS_UNEXPECTED_IO_ERROR
;
1258 ncacn_conn
->iov
= talloc_realloc(ncacn_conn
,
1261 ncacn_conn
->count
+ 1);
1262 if (ncacn_conn
->iov
== NULL
) {
1263 DEBUG(3, ("Out of memory!\n"));
1264 status
= NT_STATUS_NO_MEMORY
;
1268 ncacn_conn
->iov
[ncacn_conn
->count
].iov_base
= out
->frag
.data
;
1269 ncacn_conn
->iov
[ncacn_conn
->count
].iov_len
= out
->frag
.length
;
1271 DEBUG(10, ("PDU number: %d, PDU Length: %u\n",
1272 (unsigned int) ncacn_conn
->count
,
1273 (unsigned int) ncacn_conn
->iov
[ncacn_conn
->count
].iov_len
));
1274 dump_data(11, (const uint8_t *) ncacn_conn
->iov
[ncacn_conn
->count
].iov_base
,
1275 ncacn_conn
->iov
[ncacn_conn
->count
].iov_len
);
1276 ncacn_conn
->count
++;
1280 * We still don't have a complete request, go back and wait for more
1283 if (ncacn_conn
->count
== 0) {
1284 /* Wait for the next packet */
1285 subreq
= dcerpc_read_ncacn_packet_send(ncacn_conn
,
1287 ncacn_conn
->tstream
);
1288 if (subreq
== NULL
) {
1289 DEBUG(2, ("Failed to start receving packets\n"));
1290 status
= NT_STATUS_NO_MEMORY
;
1293 tevent_req_set_callback(subreq
, dcerpc_ncacn_packet_process
, ncacn_conn
);
1297 DEBUG(10, ("Sending a total of %u bytes\n",
1298 (unsigned int)ncacn_conn
->p
->out_data
.data_sent_length
));
1300 subreq
= tstream_writev_queue_send(ncacn_conn
,
1302 ncacn_conn
->tstream
,
1303 ncacn_conn
->send_queue
,
1306 if (subreq
== NULL
) {
1307 DEBUG(2, ("Failed to send packet\n"));
1308 status
= NT_STATUS_NO_MEMORY
;
1312 tevent_req_set_callback(subreq
, dcerpc_ncacn_packet_done
, ncacn_conn
);
1316 DEBUG(3, ("Terminating client(%s) connection! - '%s'\n",
1317 ncacn_conn
->client_name
, nt_errstr(status
)));
1319 /* Terminate client connection */
1320 talloc_free(ncacn_conn
);
1324 static void dcerpc_ncacn_packet_done(struct tevent_req
*subreq
)
1326 struct dcerpc_ncacn_conn
*ncacn_conn
=
1327 tevent_req_callback_data(subreq
, struct dcerpc_ncacn_conn
);
1328 NTSTATUS status
= NT_STATUS_OK
;
1332 rc
= tstream_writev_queue_recv(subreq
, &sys_errno
);
1333 TALLOC_FREE(subreq
);
1335 DEBUG(2, ("Writev failed!\n"));
1336 status
= map_nt_error_from_unix(sys_errno
);
1340 /* clear out any data that may have been left around */
1341 ncacn_conn
->count
= 0;
1342 TALLOC_FREE(ncacn_conn
->iov
);
1343 data_blob_free(&ncacn_conn
->p
->in_data
.data
);
1344 data_blob_free(&ncacn_conn
->p
->out_data
.frag
);
1345 data_blob_free(&ncacn_conn
->p
->out_data
.rdata
);
1347 talloc_free_children(ncacn_conn
->p
->mem_ctx
);
1349 /* Wait for the next packet */
1350 subreq
= dcerpc_read_ncacn_packet_send(ncacn_conn
,
1352 ncacn_conn
->tstream
);
1353 if (subreq
== NULL
) {
1354 DEBUG(2, ("Failed to start receving packets\n"));
1355 status
= NT_STATUS_NO_MEMORY
;
1359 tevent_req_set_callback(subreq
, dcerpc_ncacn_packet_process
, ncacn_conn
);
1363 DEBUG(3, ("Terminating client(%s) connection! - '%s'\n",
1364 ncacn_conn
->client_name
, nt_errstr(status
)));
1366 /* Terminate client connection */
1367 talloc_free(ncacn_conn
);
1371 /* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */