2 Unix SMB/CIFS implementation.
4 dcerpc over standard sockets transport
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2004
8 Copyright (C) Rafal Szczesniak 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "lib/events/events.h"
26 #include "lib/socket/socket.h"
27 #include "lib/stream/packet.h"
28 #include "libcli/composite/composite.h"
29 #include "librpc/rpc/dcerpc.h"
30 #include "librpc/rpc/dcerpc_proto.h"
31 #include "libcli/resolve/resolve.h"
32 #include "librpc/rpc/rpc_common.h"
34 /* transport private information used by general socket pipe transports */
36 struct tevent_fd
*fde
;
37 struct socket_context
*sock
;
40 struct packet_context
*packet
;
41 uint32_t pending_reads
;
43 const char *path
; /* For ncacn_unix_sock and ncalrpc */
50 static void sock_dead(struct dcerpc_connection
*p
, NTSTATUS status
)
52 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
57 packet_recv_disable(sock
->packet
);
58 packet_set_fde(sock
->packet
, NULL
);
59 packet_set_socket(sock
->packet
, NULL
);
63 talloc_free(sock
->fde
);
68 talloc_free(sock
->sock
);
72 if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL
, status
)) {
73 status
= NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
76 if (NT_STATUS_EQUAL(NT_STATUS_OK
, status
)) {
77 status
= NT_STATUS_END_OF_FILE
;
80 if (p
->transport
.recv_data
) {
81 p
->transport
.recv_data(p
, NULL
, status
);
87 handle socket recv errors
89 static void sock_error_handler(void *private_data
, NTSTATUS status
)
91 struct dcerpc_connection
*p
= talloc_get_type(private_data
,
92 struct dcerpc_connection
);
97 check if a blob is a complete packet
99 static NTSTATUS
sock_complete_packet(void *private_data
, DATA_BLOB blob
, size_t *size
)
101 if (blob
.length
< DCERPC_FRAG_LEN_OFFSET
+2) {
102 return STATUS_MORE_ENTRIES
;
104 *size
= dcerpc_get_frag_length(&blob
);
105 if (*size
> blob
.length
) {
106 return STATUS_MORE_ENTRIES
;
112 process recv requests
114 static NTSTATUS
sock_process_recv(void *private_data
, DATA_BLOB blob
)
116 struct dcerpc_connection
*p
= talloc_get_type(private_data
,
117 struct dcerpc_connection
);
118 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
119 sock
->pending_reads
--;
120 if (sock
->pending_reads
== 0) {
121 packet_recv_disable(sock
->packet
);
123 p
->transport
.recv_data(p
, &blob
, NT_STATUS_OK
);
128 called when a IO is triggered by the events system
130 static void sock_io_handler(struct tevent_context
*ev
, struct tevent_fd
*fde
,
131 uint16_t flags
, void *private_data
)
133 struct dcerpc_connection
*p
= talloc_get_type(private_data
,
134 struct dcerpc_connection
);
135 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
137 if (flags
& EVENT_FD_WRITE
) {
138 packet_queue_run(sock
->packet
);
142 if (sock
->sock
== NULL
) {
146 if (flags
& EVENT_FD_READ
) {
147 packet_recv(sock
->packet
);
152 initiate a read request - not needed for dcerpc sockets
154 static NTSTATUS
sock_send_read(struct dcerpc_connection
*p
)
156 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
157 sock
->pending_reads
++;
158 if (sock
->pending_reads
== 1) {
159 packet_recv_enable(sock
->packet
);
165 send an initial pdu in a multi-pdu sequence
167 static NTSTATUS
sock_send_request(struct dcerpc_connection
*p
, DATA_BLOB
*data
,
170 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
174 if (sock
->sock
== NULL
) {
175 return NT_STATUS_CONNECTION_DISCONNECTED
;
178 blob
= data_blob_talloc(sock
->packet
, data
->data
, data
->length
);
179 if (blob
.data
== NULL
) {
180 return NT_STATUS_NO_MEMORY
;
183 status
= packet_send(sock
->packet
, blob
);
184 if (!NT_STATUS_IS_OK(status
)) {
196 shutdown sock pipe connection
198 static NTSTATUS
sock_shutdown_pipe(struct dcerpc_connection
*p
, NTSTATUS status
)
200 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
202 if (sock
&& sock
->sock
) {
203 sock_dead(p
, status
);
210 return sock server name
212 static const char *sock_peer_name(struct dcerpc_connection
*p
)
214 struct sock_private
*sock
= talloc_get_type(p
->transport
.private_data
, struct sock_private
);
215 return sock
->server_name
;
219 return remote name we make the actual connection (good for kerberos)
221 static const char *sock_target_hostname(struct dcerpc_connection
*p
)
223 struct sock_private
*sock
= talloc_get_type(p
->transport
.private_data
, struct sock_private
);
224 return sock
->server_name
;
228 struct pipe_open_socket_state
{
229 struct dcerpc_connection
*conn
;
230 struct socket_context
*socket_ctx
;
231 struct sock_private
*sock
;
232 struct socket_address
*localaddr
;
233 struct socket_address
*server
;
234 const char *target_hostname
;
235 enum dcerpc_transport_t transport
;
239 static void continue_socket_connect(struct composite_context
*ctx
)
241 struct dcerpc_connection
*conn
;
242 struct sock_private
*sock
;
243 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
244 struct composite_context
);
245 struct pipe_open_socket_state
*s
= talloc_get_type(c
->private_data
,
246 struct pipe_open_socket_state
);
248 /* make it easier to write a function calls */
252 c
->status
= socket_connect_recv(ctx
);
253 if (!NT_STATUS_IS_OK(c
->status
)) {
254 DEBUG(0, ("Failed to connect host %s on port %d - %s\n",
255 s
->server
->addr
, s
->server
->port
,
256 nt_errstr(c
->status
)));
257 composite_error(c
, c
->status
);
262 fill in the transport methods
264 conn
->transport
.transport
= s
->transport
;
265 conn
->transport
.private_data
= NULL
;
267 conn
->transport
.send_request
= sock_send_request
;
268 conn
->transport
.send_read
= sock_send_read
;
269 conn
->transport
.recv_data
= NULL
;
271 conn
->transport
.shutdown_pipe
= sock_shutdown_pipe
;
272 conn
->transport
.peer_name
= sock_peer_name
;
273 conn
->transport
.target_hostname
= sock_target_hostname
;
275 sock
->sock
= s
->socket_ctx
;
276 sock
->pending_reads
= 0;
277 sock
->server_name
= strupper_talloc(sock
, s
->target_hostname
);
279 sock
->fde
= event_add_fd(conn
->event_ctx
, sock
->sock
, socket_get_fd(sock
->sock
),
280 EVENT_FD_READ
, sock_io_handler
, conn
);
282 conn
->transport
.private_data
= sock
;
284 sock
->packet
= packet_init(sock
);
285 if (sock
->packet
== NULL
) {
286 composite_error(c
, NT_STATUS_NO_MEMORY
);
291 packet_set_private(sock
->packet
, conn
);
292 packet_set_socket(sock
->packet
, sock
->sock
);
293 packet_set_callback(sock
->packet
, sock_process_recv
);
294 packet_set_full_request(sock
->packet
, sock_complete_packet
);
295 packet_set_error_handler(sock
->packet
, sock_error_handler
);
296 packet_set_event_context(sock
->packet
, conn
->event_ctx
);
297 packet_set_fde(sock
->packet
, sock
->fde
);
298 packet_set_serialise(sock
->packet
);
299 packet_set_initial_read(sock
->packet
, 16);
301 /* ensure we don't get SIGPIPE */
302 BlockSignals(true, SIGPIPE
);
308 static struct composite_context
*dcerpc_pipe_open_socket_send(TALLOC_CTX
*mem_ctx
,
309 struct dcerpc_connection
*cn
,
310 struct socket_address
*localaddr
,
311 struct socket_address
*server
,
312 const char *target_hostname
,
313 const char *full_path
,
314 enum dcerpc_transport_t transport
)
316 struct composite_context
*c
;
317 struct pipe_open_socket_state
*s
;
318 struct composite_context
*conn_req
;
320 c
= composite_create(mem_ctx
, cn
->event_ctx
);
321 if (c
== NULL
) return NULL
;
323 s
= talloc_zero(c
, struct pipe_open_socket_state
);
324 if (composite_nomem(s
, c
)) return c
;
328 s
->transport
= transport
;
330 s
->localaddr
= talloc_reference(c
, localaddr
);
331 if (composite_nomem(s
->localaddr
, c
)) return c
;
333 s
->server
= talloc_reference(c
, server
);
334 if (composite_nomem(s
->server
, c
)) return c
;
335 s
->target_hostname
= talloc_reference(s
, target_hostname
);
337 s
->sock
= talloc(cn
, struct sock_private
);
338 if (composite_nomem(s
->sock
, c
)) return c
;
340 c
->status
= socket_create(server
->family
, SOCKET_TYPE_STREAM
, &s
->socket_ctx
, 0);
341 if (!composite_is_ok(c
)) return c
;
343 talloc_steal(s
->sock
, s
->socket_ctx
);
345 s
->sock
->path
= talloc_reference(s
->sock
, full_path
);
347 conn_req
= socket_connect_send(s
->socket_ctx
, s
->localaddr
, s
->server
, 0,
349 composite_continue(c
, conn_req
, continue_socket_connect
, c
);
354 static NTSTATUS
dcerpc_pipe_open_socket_recv(struct composite_context
*c
)
356 NTSTATUS status
= composite_wait(c
);
362 struct pipe_tcp_state
{
364 const char *target_hostname
;
367 struct socket_address
*localaddr
;
368 struct socket_address
*srvaddr
;
369 struct resolve_context
*resolve_ctx
;
370 struct dcerpc_connection
*conn
;
374 #if 0 /* disabled till we can resolve names to ipv6 addresses */
375 static void continue_ipv6_open_socket(struct composite_context
*ctx
);
377 static void continue_ipv4_open_socket(struct composite_context
*ctx
);
378 static void continue_ip_resolve_name(struct composite_context
*ctx
);
380 static void continue_ip_resolve_name(struct composite_context
*ctx
)
382 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
383 struct composite_context
);
384 struct pipe_tcp_state
*s
= talloc_get_type(c
->private_data
,
385 struct pipe_tcp_state
);
386 struct composite_context
*sock_ipv4_req
;
388 c
->status
= resolve_name_recv(ctx
, s
, &s
->address
);
389 if (!composite_is_ok(c
)) return;
391 /* prepare server address using host ip:port and transport name */
392 s
->srvaddr
= socket_address_from_strings(s
->conn
, "ipv4", s
->address
, s
->port
);
393 if (composite_nomem(s
->srvaddr
, c
)) return;
395 /* resolve_nbt_name gives only ipv4 ... - send socket open request */
396 sock_ipv4_req
= dcerpc_pipe_open_socket_send(c
, s
->conn
, s
->localaddr
,
397 s
->srvaddr
, s
->target_hostname
,
400 composite_continue(c
, sock_ipv4_req
, continue_ipv4_open_socket
, c
);
404 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
405 on IPv6 and send the request on IPv4 unless IPv6 transport succeeded.
407 #if 0 /* disabled till we can resolve names to ipv6 addresses */
408 static void continue_ipv6_open_socket(struct composite_context
*ctx
)
410 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
411 struct composite_context
);
412 struct pipe_tcp_state
*s
= talloc_get_type(c
->private_data
,
413 struct pipe_tcp_state
);
414 struct composite_context
*sock_ipv4_req
;
416 /* receive result of socket open request */
417 c
->status
= dcerpc_pipe_open_socket_recv(ctx
);
418 if (NT_STATUS_IS_OK(c
->status
)) {
423 talloc_free(s
->srvaddr
);
425 /* prepare server address using host:ip and transport name */
426 s
->srvaddr
= socket_address_from_strings(s
->conn
, "ipv4", s
->address
, s
->port
);
427 if (composite_nomem(s
->srvaddr
, c
)) return;
429 /* try IPv4 if IPv6 fails */
430 sock_ipv4_req
= dcerpc_pipe_open_socket_send(c
, s
->conn
, s
->localaddr
,
431 s
->srvaddr
, s
->target_hostname
,
433 composite_continue(c
, sock_ipv4_req
, continue_ipv4_open_socket
, c
);
438 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
441 static void continue_ipv4_open_socket(struct composite_context
*ctx
)
443 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
444 struct composite_context
);
445 struct pipe_tcp_state
*s
= talloc_get_type(c
->private_data
,
446 struct pipe_tcp_state
);
448 /* receive result socket open request */
449 c
->status
= dcerpc_pipe_open_socket_recv(ctx
);
450 if (!NT_STATUS_IS_OK(c
->status
)) {
451 /* something went wrong... */
452 DEBUG(0, ("Failed to connect host %s (%s) on port %d - %s.\n",
453 s
->address
, s
->target_hostname
,
454 s
->port
, nt_errstr(c
->status
)));
456 composite_error(c
, c
->status
);
464 Send rpc pipe open request to given host:port using
467 struct composite_context
* dcerpc_pipe_open_tcp_send(struct dcerpc_connection
*conn
,
468 const char *localaddr
,
470 const char *target_hostname
,
472 struct resolve_context
*resolve_ctx
)
474 struct composite_context
*c
;
475 struct pipe_tcp_state
*s
;
476 struct composite_context
*resolve_req
;
477 struct nbt_name name
;
479 /* composite context allocation and setup */
480 c
= composite_create(conn
, conn
->event_ctx
);
481 if (c
== NULL
) return NULL
;
483 s
= talloc_zero(c
, struct pipe_tcp_state
);
484 if (composite_nomem(s
, c
)) return c
;
487 /* store input parameters in state structure */
488 s
->server
= talloc_strdup(c
, server
);
489 if (composite_nomem(s
->server
, c
)) return c
;
490 if (target_hostname
) {
491 s
->target_hostname
= talloc_strdup(c
, target_hostname
);
492 if (composite_nomem(s
->target_hostname
, c
)) return c
;
496 s
->resolve_ctx
= resolve_ctx
;
498 s
->localaddr
= socket_address_from_strings(s
, "ip", localaddr
, 0);
499 /* if there is no localaddr, we pass NULL for
500 s->localaddr, which is handled by the socket libraries as
501 meaning no local binding address specified */
504 make_nbt_name_server(&name
, server
);
505 resolve_req
= resolve_name_send(resolve_ctx
, s
, &name
, c
->event_ctx
);
506 composite_continue(c
, resolve_req
, continue_ip_resolve_name
, c
);
511 Receive result of pipe open request on tcp/ip
513 NTSTATUS
dcerpc_pipe_open_tcp_recv(struct composite_context
*c
)
516 status
= composite_wait(c
);
523 struct pipe_unix_state
{
525 struct socket_address
*srvaddr
;
526 struct dcerpc_connection
*conn
;
531 Stage 2 of dcerpc_pipe_open_unix_stream_send: receive result of pipe open
532 request on unix socket.
534 static void continue_unix_open_socket(struct composite_context
*ctx
)
536 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
537 struct composite_context
);
539 c
->status
= dcerpc_pipe_open_socket_recv(ctx
);
540 if (NT_STATUS_IS_OK(c
->status
)) {
545 composite_error(c
, c
->status
);
550 Send pipe open request on unix socket
552 struct composite_context
*dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection
*conn
,
555 struct composite_context
*c
;
556 struct composite_context
*sock_unix_req
;
557 struct pipe_unix_state
*s
;
559 /* composite context allocation and setup */
560 c
= composite_create(conn
, conn
->event_ctx
);
561 if (c
== NULL
) return NULL
;
563 s
= talloc_zero(c
, struct pipe_unix_state
);
564 if (composite_nomem(s
, c
)) return c
;
567 /* store parameters in state structure */
568 s
->path
= talloc_strdup(c
, path
);
569 if (composite_nomem(s
->path
, c
)) return c
;
572 /* prepare server address using socket path and transport name */
573 s
->srvaddr
= socket_address_from_strings(conn
, "unix", s
->path
, 0);
574 if (composite_nomem(s
->srvaddr
, c
)) return c
;
576 /* send socket open request */
577 sock_unix_req
= dcerpc_pipe_open_socket_send(c
, s
->conn
, NULL
,
581 composite_continue(c
, sock_unix_req
, continue_unix_open_socket
, c
);
587 Receive result of pipe open request on unix socket
589 NTSTATUS
dcerpc_pipe_open_unix_stream_recv(struct composite_context
*c
)
591 NTSTATUS status
= composite_wait(c
);
599 Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
601 static void continue_np_open_socket(struct composite_context
*ctx
)
603 struct composite_context
*c
= talloc_get_type(ctx
->async
.private_data
,
604 struct composite_context
);
606 c
->status
= dcerpc_pipe_open_socket_recv(ctx
);
607 if (!composite_is_ok(c
)) return;
614 Send pipe open request on ncalrpc
616 struct composite_context
* dcerpc_pipe_open_pipe_send(struct dcerpc_connection
*conn
,
617 const char *ncalrpc_dir
,
618 const char *identifier
)
622 struct composite_context
*c
;
623 struct composite_context
*sock_np_req
;
624 struct pipe_unix_state
*s
;
626 /* composite context allocation and setup */
627 c
= composite_create(conn
, conn
->event_ctx
);
628 if (c
== NULL
) return NULL
;
630 s
= talloc_zero(c
, struct pipe_unix_state
);
631 if (composite_nomem(s
, c
)) return c
;
634 /* store parameters in state structure */
635 canon
= talloc_strdup(s
, identifier
);
636 if (composite_nomem(canon
, c
)) return c
;
639 string_replace(canon
, '/', '\\');
640 s
->path
= talloc_asprintf(canon
, "%s/%s", ncalrpc_dir
, canon
);
641 if (composite_nomem(s
->path
, c
)) return c
;
643 /* prepare server address using path and transport name */
644 s
->srvaddr
= socket_address_from_strings(conn
, "unix", s
->path
, 0);
645 if (composite_nomem(s
->srvaddr
, c
)) return c
;
647 /* send socket open request */
648 sock_np_req
= dcerpc_pipe_open_socket_send(c
, s
->conn
, NULL
, s
->srvaddr
, NULL
, s
->path
, NCALRPC
);
649 composite_continue(c
, sock_np_req
, continue_np_open_socket
, c
);
655 Receive result of pipe open request on ncalrpc
657 NTSTATUS
dcerpc_pipe_open_pipe_recv(struct composite_context
*c
)
659 NTSTATUS status
= composite_wait(c
);
667 Open a rpc pipe on a named pipe - sync version
669 NTSTATUS
dcerpc_pipe_open_pipe(struct dcerpc_connection
*conn
, const char *ncalrpc_dir
, const char *identifier
)
671 struct composite_context
*c
= dcerpc_pipe_open_pipe_send(conn
, ncalrpc_dir
, identifier
);
672 return dcerpc_pipe_open_pipe_recv(c
);
675 const char *dcerpc_unix_socket_path(struct dcerpc_connection
*p
)
677 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
681 struct socket_address
*dcerpc_socket_peer_addr(struct dcerpc_connection
*p
, TALLOC_CTX
*mem_ctx
)
683 struct sock_private
*sock
= (struct sock_private
*)p
->transport
.private_data
;
684 return socket_get_peer_addr(sock
->sock
, mem_ctx
);