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 2 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, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include "lib/events/events.h"
27 #include "lib/socket/socket.h"
28 #include "lib/stream/packet.h"
29 #include "libcli/composite/composite.h"
30 #include "librpc/rpc/dcerpc.h"
32 /* transport private information used by general socket pipe transports */
35 struct socket_context *sock;
38 struct packet_context *packet;
39 uint32_t pending_reads;
46 static void sock_dead(struct dcerpc_connection *p, NTSTATUS status)
48 struct sock_private *sock = p->transport.private;
50 if (sock && sock->sock != NULL) {
51 talloc_free(sock->fde);
52 talloc_free(sock->sock);
56 if (!NT_STATUS_IS_OK(status)) {
57 p->transport.recv_data(p, NULL, status);
63 handle socket recv errors
65 static void sock_error_handler(void *private, NTSTATUS status)
67 struct dcerpc_connection *p = talloc_get_type(private,
68 struct dcerpc_connection);
73 check if a blob is a complete packet
75 static NTSTATUS sock_complete_packet(void *private, DATA_BLOB blob, size_t *size)
77 if (blob.length < DCERPC_FRAG_LEN_OFFSET+2) {
78 return STATUS_MORE_ENTRIES;
80 *size = dcerpc_get_frag_length(&blob);
81 if (*size > blob.length) {
82 return STATUS_MORE_ENTRIES;
90 static NTSTATUS sock_process_recv(void *private, DATA_BLOB blob)
92 struct dcerpc_connection *p = talloc_get_type(private,
93 struct dcerpc_connection);
94 struct sock_private *sock = p->transport.private;
95 sock->pending_reads--;
96 if (sock->pending_reads == 0) {
97 packet_recv_disable(sock->packet);
99 p->transport.recv_data(p, &blob, NT_STATUS_OK);
104 called when a IO is triggered by the events system
106 static void sock_io_handler(struct event_context *ev, struct fd_event *fde,
107 uint16_t flags, void *private)
109 struct dcerpc_connection *p = talloc_get_type(private,
110 struct dcerpc_connection);
111 struct sock_private *sock = p->transport.private;
113 if (flags & EVENT_FD_WRITE) {
114 packet_queue_run(sock->packet);
118 if (sock->sock == NULL) {
122 if (flags & EVENT_FD_READ) {
123 packet_recv(sock->packet);
128 initiate a read request - not needed for dcerpc sockets
130 static NTSTATUS sock_send_read(struct dcerpc_connection *p)
132 struct sock_private *sock = p->transport.private;
133 sock->pending_reads++;
134 if (sock->pending_reads == 1) {
135 packet_recv_enable(sock->packet);
141 send an initial pdu in a multi-pdu sequence
143 static NTSTATUS sock_send_request(struct dcerpc_connection *p, DATA_BLOB *data,
146 struct sock_private *sock = p->transport.private;
150 if (sock->sock == NULL) {
151 return NT_STATUS_CONNECTION_DISCONNECTED;
154 blob = data_blob_talloc(sock->packet, data->data, data->length);
155 if (blob.data == NULL) {
156 return NT_STATUS_NO_MEMORY;
159 status = packet_send(sock->packet, blob);
160 if (!NT_STATUS_IS_OK(status)) {
172 shutdown sock pipe connection
174 static NTSTATUS sock_shutdown_pipe(struct dcerpc_connection *p)
176 struct sock_private *sock = p->transport.private;
178 if (sock && sock->sock) {
179 sock_dead(p, NT_STATUS_OK);
186 return sock server name
188 static const char *sock_peer_name(struct dcerpc_connection *p)
190 struct sock_private *sock = talloc_get_type(p->transport.private, struct sock_private);
191 return sock->server_name;
195 return remote name we make the actual connection (good for kerberos)
197 static const char *sock_target_hostname(struct dcerpc_connection *p)
199 struct sock_private *sock = talloc_get_type(p->transport.private, struct sock_private);
200 return sock->server_name;
204 struct pipe_open_socket_state {
205 struct dcerpc_connection *conn;
206 struct socket_context *socket_ctx;
207 struct sock_private *sock;
208 struct socket_address *server;
209 enum dcerpc_transport_t transport;
213 static void continue_socket_connect(struct composite_context *ctx)
215 struct dcerpc_connection *conn;
216 struct sock_private *sock;
217 struct composite_context *c = talloc_get_type(ctx->async.private_data,
218 struct composite_context);
219 struct pipe_open_socket_state *s = talloc_get_type(c->private_data,
220 struct pipe_open_socket_state);
222 /* make it easier to write a function calls */
226 c->status = socket_connect_recv(ctx);
227 if (!NT_STATUS_IS_OK(c->status)) {
228 DEBUG(0, ("Failed to connect host %s on port %d - %s\n",
229 s->server->addr, s->server->port,
230 nt_errstr(c->status)));
231 composite_error(c, c->status);
236 fill in the transport methods
238 conn->transport.transport = s->transport;
239 conn->transport.private = NULL;
241 conn->transport.send_request = sock_send_request;
242 conn->transport.send_read = sock_send_read;
243 conn->transport.recv_data = NULL;
245 conn->transport.shutdown_pipe = sock_shutdown_pipe;
246 conn->transport.peer_name = sock_peer_name;
247 conn->transport.target_hostname = sock_target_hostname;
249 sock->sock = s->socket_ctx;
250 sock->pending_reads = 0;
251 sock->server_name = strupper_talloc(sock, s->server->addr);
253 sock->fde = event_add_fd(conn->event_ctx, sock->sock, socket_get_fd(sock->sock),
254 0, sock_io_handler, conn);
256 conn->transport.private = sock;
258 sock->packet = packet_init(sock);
259 if (sock->packet == NULL) {
260 composite_error(c, NT_STATUS_NO_MEMORY);
265 packet_set_private(sock->packet, conn);
266 packet_set_socket(sock->packet, sock->sock);
267 packet_set_callback(sock->packet, sock_process_recv);
268 packet_set_full_request(sock->packet, sock_complete_packet);
269 packet_set_error_handler(sock->packet, sock_error_handler);
270 packet_set_event_context(sock->packet, conn->event_ctx);
271 packet_set_fde(sock->packet, sock->fde);
272 packet_set_serialise(sock->packet);
273 packet_recv_disable(sock->packet);
274 packet_set_initial_read(sock->packet, 16);
276 /* ensure we don't get SIGPIPE */
277 BlockSignals(True,SIGPIPE);
283 struct composite_context *dcerpc_pipe_open_socket_send(TALLOC_CTX *mem_ctx,
284 struct dcerpc_connection *cn,
285 struct socket_address *server,
286 enum dcerpc_transport_t transport)
289 struct composite_context *c;
290 struct pipe_open_socket_state *s;
291 struct composite_context *conn_req;
293 c = talloc_zero(mem_ctx, struct composite_context);
294 if (c == NULL) return NULL;
296 s = talloc_zero(c, struct pipe_open_socket_state);
298 composite_error(c, NT_STATUS_NO_MEMORY);
302 c->state = COMPOSITE_STATE_IN_PROGRESS;
304 c->event_ctx = cn->event_ctx;
307 s->transport = transport;
308 s->server = talloc_reference(c, server);
309 if (s->server == NULL) {
310 composite_error(c, NT_STATUS_NO_MEMORY);
314 s->sock = talloc(cn, struct sock_private);
315 if (s->sock == NULL) {
316 composite_error(c, NT_STATUS_NO_MEMORY);
320 status = socket_create(server->family, SOCKET_TYPE_STREAM, &s->socket_ctx, 0);
321 if (!NT_STATUS_IS_OK(status)) {
322 composite_error(c, status);
323 talloc_free(s->sock);
326 talloc_steal(s->sock, s->socket_ctx);
328 conn_req = socket_connect_send(s->socket_ctx, NULL, s->server, 0, c->event_ctx);
329 if (conn_req == NULL) {
330 composite_error(c, NT_STATUS_NO_MEMORY);
334 composite_continue(c, conn_req, continue_socket_connect, c);
341 NTSTATUS dcerpc_pipe_open_socket_recv(struct composite_context *c)
343 NTSTATUS status = composite_wait(c);
350 open a rpc connection using the generic socket library
352 NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *conn,
353 struct socket_address *server,
354 enum dcerpc_transport_t transport)
356 struct composite_context *c;
358 c = dcerpc_pipe_open_socket_send(conn, conn, server, transport);
359 return dcerpc_pipe_open_socket_recv(c);
363 struct pipe_tcp_state {
366 struct socket_address *srvaddr;
367 struct dcerpc_connection *conn;
371 void continue_ipv6_open_socket(struct composite_context *ctx);
372 void continue_ipv4_open_socket(struct composite_context *ctx);
376 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
377 on IPv6 and send the request on IPv4 unless IPv6 transport succeeded.
379 void continue_ipv6_open_socket(struct composite_context *ctx)
381 struct composite_context *c = talloc_get_type(ctx->async.private_data,
382 struct composite_context);
383 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
384 struct pipe_tcp_state);
385 struct composite_context *sock_ipv4_req;
387 /* receive result of socket open request */
388 c->status = dcerpc_pipe_open_socket_recv(ctx);
389 if (NT_STATUS_IS_OK(c->status)) return;
391 talloc_free(s->srvaddr);
393 /* prepare server address using host:ip and transport name */
394 s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->server, s->port);
396 composite_error(c, NT_STATUS_NO_MEMORY);
400 /* try IPv4 if IPv6 fails */
401 sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
402 if (sock_ipv4_req == NULL) {
403 composite_error(c, NT_STATUS_NO_MEMORY);
407 composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
412 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
415 void continue_ipv4_open_socket(struct composite_context *ctx)
417 struct composite_context *c = talloc_get_type(ctx->async.private_data,
418 struct composite_context);
419 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
420 struct pipe_tcp_state);
422 /* receive result socket open request */
423 c->status = dcerpc_pipe_open_socket_recv(ctx);
424 if (NT_STATUS_IS_OK(c->status)) {
429 /* something went wrong... */
430 DEBUG(0, ("Failed to connect host %s on port %d - %s.\n",
431 s->server, s->port, nt_errstr(c->status)));
433 composite_error(c, c->status);
438 Send rpc pipe open request to given host:port using
441 struct composite_context* dcerpc_pipe_open_tcp_send(struct dcerpc_connection *conn,
442 const char* server, uint32_t port)
444 struct composite_context *c;
445 struct composite_context *sock_ipv6_req;
446 struct pipe_tcp_state *s;
448 /* composite context allocation and setup */
449 c = talloc_zero(conn, struct composite_context);
450 if (c == NULL) return NULL;
452 s = talloc_zero(c, struct pipe_tcp_state);
454 composite_error(c, NT_STATUS_NO_MEMORY);
458 c->state = COMPOSITE_STATE_IN_PROGRESS;
460 c->event_ctx = conn->event_ctx;
462 /* store input parameters in state structure */
463 s->server = talloc_strdup(c, server);
467 /* prepare server address using host ip:port and transport name */
468 s->srvaddr = socket_address_from_strings(s->conn, "ipv6", s->server, s->port);
470 composite_error(c, NT_STATUS_NO_MEMORY);
474 /* try IPv6 first - send socket open request */
475 sock_ipv6_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
476 if (sock_ipv6_req == NULL) {
477 composite_error(c, NT_STATUS_NO_MEMORY);
481 composite_continue(c, sock_ipv6_req, continue_ipv6_open_socket, c);
488 Receive result of pipe open request on tcp/ip
490 NTSTATUS dcerpc_pipe_open_tcp_recv(struct composite_context *c)
493 status = composite_wait(c);
501 Open rpc pipe on tcp/ip transport - sync version
503 NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *conn, const char *server,
506 struct composite_context *c;
508 c = dcerpc_pipe_open_tcp_send(conn, server, port);
509 return dcerpc_pipe_open_tcp_recv(c);
513 struct pipe_unix_state {
515 struct socket_address *srvaddr;
516 struct dcerpc_connection *conn;
521 Stage 2 of dcerpc_pipe_open_unix_stream_send: receive result of pipe open
522 request on unix socket.
524 void continue_unix_open_socket(struct composite_context *ctx)
526 struct composite_context *c = talloc_get_type(ctx->async.private_data,
527 struct composite_context);
529 c->status = dcerpc_pipe_open_socket_recv(ctx);
530 if (NT_STATUS_IS_OK(c->status)) {
535 composite_error(c, c->status);
540 Send pipe open request on unix socket
542 struct composite_context *dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection *conn,
545 struct composite_context *c;
546 struct composite_context *sock_unix_req;
547 struct pipe_unix_state *s;
549 /* composite context allocation and setup */
550 c = talloc_zero(conn, struct composite_context);
551 if (c == NULL) return NULL;
553 s = talloc_zero(c, struct pipe_unix_state);
555 composite_error(c, NT_STATUS_NO_MEMORY);
559 c->state = COMPOSITE_STATE_IN_PROGRESS;
561 c->event_ctx = conn->event_ctx;
563 /* store parameters in state structure */
564 s->path = talloc_strdup(c, path);
567 /* prepare server address using socket path and transport name */
568 s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
569 if (s->srvaddr == NULL) {
570 composite_error(c, NT_STATUS_NO_MEMORY);
574 /* send socket open request */
575 sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
576 if (sock_unix_req == NULL) {
577 composite_error(c, NT_STATUS_NO_MEMORY);
581 composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
589 Receive result of pipe open request on unix socket
591 NTSTATUS dcerpc_pipe_open_unix_stream_recv(struct composite_context *c)
593 NTSTATUS status = composite_wait(c);
601 Open a rpc pipe on a unix socket - sync version
603 NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *conn, const char *path)
605 struct composite_context *c = dcerpc_pipe_open_unix_stream_send(conn, path);
606 return dcerpc_pipe_open_unix_stream_recv(c);
610 struct pipe_np_state {
612 struct socket_address *srvaddr;
613 struct dcerpc_connection *conn;
618 Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
620 void continue_np_open_socket(struct composite_context *ctx)
622 struct composite_context *c = talloc_get_type(ctx->async.private_data,
623 struct composite_context);
625 c->status = dcerpc_pipe_open_socket_recv(ctx);
626 if (NT_STATUS_IS_OK(c->status)) {
631 composite_error(c, c->status);
636 Send pipe open request on ncalrpc
638 struct composite_context* dcerpc_pipe_open_pipe_send(struct dcerpc_connection *conn,
639 const char *identifier)
643 struct composite_context *c;
644 struct composite_context *sock_np_req;
645 struct pipe_np_state *s;
647 /* composite context allocation and setup */
648 c = talloc_zero(conn, struct composite_context);
649 if (c == NULL) return NULL;
651 s = talloc_zero(c, struct pipe_np_state);
653 composite_error(c, NT_STATUS_NO_MEMORY);
657 c->state = COMPOSITE_STATE_IN_PROGRESS;
659 c->event_ctx = conn->event_ctx;
661 /* store parameters in state structure */
662 canon = talloc_strdup(c, identifier);
665 string_replace(canon, '/', '\\');
666 s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
668 /* prepare server address using path and transport name */
669 s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
670 if (s->srvaddr == NULL) {
671 composite_error(c, NT_STATUS_NO_MEMORY);
675 /* send socket open request */
676 sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
677 if (sock_np_req == NULL) {
678 composite_error(c, NT_STATUS_NO_MEMORY);
682 composite_continue(c, sock_np_req, continue_np_open_socket, c);
691 Receive result of pipe open request on ncalrpc
693 NTSTATUS dcerpc_pipe_open_pipe_recv(struct composite_context *c)
695 NTSTATUS status = composite_wait(c);
703 Open a rpc pipe on a named pipe - sync version
705 NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *conn, const char *identifier)
707 struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, identifier);
708 return dcerpc_pipe_open_pipe_recv(c);