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 = p->transport.private;
191 return sock->server_name;
195 struct pipe_open_socket_state {
196 struct dcerpc_connection *conn;
197 struct socket_context *socket_ctx;
198 struct sock_private *sock;
199 struct socket_address *server;
200 enum dcerpc_transport_t transport;
204 static void continue_socket_connect(struct composite_context *ctx)
206 struct dcerpc_connection *conn;
207 struct sock_private *sock;
208 struct composite_context *c = talloc_get_type(ctx->async.private_data,
209 struct composite_context);
210 struct pipe_open_socket_state *s = talloc_get_type(c->private_data,
211 struct pipe_open_socket_state);
213 /* make it easier to write a function calls */
217 c->status = socket_connect_recv(ctx);
218 if (!NT_STATUS_IS_OK(c->status)) {
219 DEBUG(0, ("Failed to connect host %s on port %d - %s\n",
220 s->server->addr, s->server->port,
221 nt_errstr(c->status)));
222 composite_error(c, c->status);
227 fill in the transport methods
229 conn->transport.transport = s->transport;
230 conn->transport.private = NULL;
232 conn->transport.send_request = sock_send_request;
233 conn->transport.send_read = sock_send_read;
234 conn->transport.recv_data = NULL;
236 conn->transport.shutdown_pipe = sock_shutdown_pipe;
237 conn->transport.peer_name = sock_peer_name;
239 sock->sock = s->socket_ctx;
240 sock->pending_reads = 0;
241 sock->server_name = strupper_talloc(sock, s->server->addr);
243 sock->fde = event_add_fd(conn->event_ctx, sock->sock, socket_get_fd(sock->sock),
244 0, sock_io_handler, conn);
246 conn->transport.private = sock;
248 sock->packet = packet_init(sock);
249 if (sock->packet == NULL) {
250 composite_error(c, NT_STATUS_NO_MEMORY);
255 packet_set_private(sock->packet, conn);
256 packet_set_socket(sock->packet, sock->sock);
257 packet_set_callback(sock->packet, sock_process_recv);
258 packet_set_full_request(sock->packet, sock_complete_packet);
259 packet_set_error_handler(sock->packet, sock_error_handler);
260 packet_set_event_context(sock->packet, conn->event_ctx);
261 packet_set_fde(sock->packet, sock->fde);
262 packet_set_serialise(sock->packet);
263 packet_recv_disable(sock->packet);
264 packet_set_initial_read(sock->packet, 16);
266 /* ensure we don't get SIGPIPE */
267 BlockSignals(True,SIGPIPE);
273 struct composite_context *dcerpc_pipe_open_socket_send(TALLOC_CTX *mem_ctx,
274 struct dcerpc_connection *cn,
275 struct socket_address *server,
276 enum dcerpc_transport_t transport)
279 struct composite_context *c;
280 struct pipe_open_socket_state *s;
281 struct composite_context *conn_req;
283 c = talloc_zero(mem_ctx, struct composite_context);
284 if (c == NULL) return NULL;
286 s = talloc_zero(c, struct pipe_open_socket_state);
288 composite_error(c, NT_STATUS_NO_MEMORY);
292 c->state = COMPOSITE_STATE_IN_PROGRESS;
294 c->event_ctx = cn->event_ctx;
297 s->transport = transport;
298 s->server = talloc_reference(c, server);
299 if (s->server == NULL) {
300 composite_error(c, NT_STATUS_NO_MEMORY);
304 s->sock = talloc(cn, struct sock_private);
305 if (s->sock == NULL) {
306 composite_error(c, NT_STATUS_NO_MEMORY);
310 status = socket_create(server->family, SOCKET_TYPE_STREAM, &s->socket_ctx, 0);
311 if (!NT_STATUS_IS_OK(status)) {
312 composite_error(c, status);
313 talloc_free(s->sock);
316 talloc_steal(s->sock, s->socket_ctx);
318 conn_req = socket_connect_send(s->socket_ctx, NULL, s->server, 0, c->event_ctx);
319 if (conn_req == NULL) {
320 composite_error(c, NT_STATUS_NO_MEMORY);
324 composite_continue(c, conn_req, continue_socket_connect, c);
331 NTSTATUS dcerpc_pipe_open_socket_recv(struct composite_context *c)
333 NTSTATUS status = composite_wait(c);
340 open a rpc connection using the generic socket library
342 NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *conn,
343 struct socket_address *server,
344 enum dcerpc_transport_t transport)
346 struct composite_context *c;
348 c = dcerpc_pipe_open_socket_send(conn, conn, server, transport);
349 return dcerpc_pipe_open_socket_recv(c);
353 struct pipe_tcp_state {
356 struct socket_address *srvaddr;
357 struct dcerpc_connection *conn;
361 void continue_ipv6_open_socket(struct composite_context *ctx);
362 void continue_ipv4_open_socket(struct composite_context *ctx);
366 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
367 on IPv6 and send the request on IPv4 unless IPv6 transport succeeded.
369 void continue_ipv6_open_socket(struct composite_context *ctx)
371 struct composite_context *c = talloc_get_type(ctx->async.private_data,
372 struct composite_context);
373 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
374 struct pipe_tcp_state);
375 struct composite_context *sock_ipv4_req;
377 /* receive result of socket open request */
378 c->status = dcerpc_pipe_open_socket_recv(ctx);
379 if (NT_STATUS_IS_OK(c->status)) return;
381 talloc_free(s->srvaddr);
383 /* prepare server address using host:ip and transport name */
384 s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->server, s->port);
386 composite_error(c, NT_STATUS_NO_MEMORY);
390 /* try IPv4 if IPv6 fails */
391 sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
392 if (sock_ipv4_req == NULL) {
393 composite_error(c, NT_STATUS_NO_MEMORY);
397 composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
402 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
405 void continue_ipv4_open_socket(struct composite_context *ctx)
407 struct composite_context *c = talloc_get_type(ctx->async.private_data,
408 struct composite_context);
409 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
410 struct pipe_tcp_state);
412 /* receive result socket open request */
413 c->status = dcerpc_pipe_open_socket_recv(ctx);
414 if (NT_STATUS_IS_OK(c->status)) {
419 /* something went wrong... */
420 DEBUG(0, ("Failed to connect host %s on port %d - %s.\n",
421 s->server, s->port, nt_errstr(c->status)));
423 composite_error(c, c->status);
428 Send rpc pipe open request to given host:port using
431 struct composite_context* dcerpc_pipe_open_tcp_send(struct dcerpc_connection *conn,
432 const char* server, uint32_t port)
434 struct composite_context *c;
435 struct composite_context *sock_ipv6_req;
436 struct pipe_tcp_state *s;
438 /* composite context allocation and setup */
439 c = talloc_zero(conn, struct composite_context);
440 if (c == NULL) return NULL;
442 s = talloc_zero(c, struct pipe_tcp_state);
444 composite_error(c, NT_STATUS_NO_MEMORY);
448 c->state = COMPOSITE_STATE_IN_PROGRESS;
450 c->event_ctx = conn->event_ctx;
452 /* store input parameters in state structure */
453 s->server = talloc_strdup(c, server);
457 /* prepare server address using host ip:port and transport name */
458 s->srvaddr = socket_address_from_strings(s->conn, "ipv6", s->server, s->port);
460 composite_error(c, NT_STATUS_NO_MEMORY);
464 /* try IPv6 first - send socket open request */
465 sock_ipv6_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
466 if (sock_ipv6_req == NULL) {
467 composite_error(c, NT_STATUS_NO_MEMORY);
471 composite_continue(c, sock_ipv6_req, continue_ipv6_open_socket, c);
478 Receive result of pipe open request on tcp/ip
480 NTSTATUS dcerpc_pipe_open_tcp_recv(struct composite_context *c)
483 status = composite_wait(c);
491 Open rpc pipe on tcp/ip transport - sync version
493 NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *conn, const char *server,
496 struct composite_context *c;
498 c = dcerpc_pipe_open_tcp_send(conn, server, port);
499 return dcerpc_pipe_open_tcp_recv(c);
503 struct pipe_unix_state {
505 struct socket_address *srvaddr;
506 struct dcerpc_connection *conn;
511 Stage 2 of dcerpc_pipe_open_unix_stream_send: receive result of pipe open
512 request on unix socket.
514 void continue_unix_open_socket(struct composite_context *ctx)
516 struct composite_context *c = talloc_get_type(ctx->async.private_data,
517 struct composite_context);
519 c->status = dcerpc_pipe_open_socket_recv(ctx);
520 if (NT_STATUS_IS_OK(c->status)) {
525 composite_error(c, c->status);
530 Send pipe open request on unix socket
532 struct composite_context *dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection *conn,
535 struct composite_context *c;
536 struct composite_context *sock_unix_req;
537 struct pipe_unix_state *s;
539 /* composite context allocation and setup */
540 c = talloc_zero(conn, struct composite_context);
541 if (c == NULL) return NULL;
543 s = talloc_zero(c, struct pipe_unix_state);
545 composite_error(c, NT_STATUS_NO_MEMORY);
549 c->state = COMPOSITE_STATE_IN_PROGRESS;
551 c->event_ctx = conn->event_ctx;
553 /* store parameters in state structure */
554 s->path = talloc_strdup(c, path);
557 /* prepare server address using socket path and transport name */
558 s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
559 if (s->srvaddr == NULL) {
560 composite_error(c, NT_STATUS_NO_MEMORY);
564 /* send socket open request */
565 sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
566 if (sock_unix_req == NULL) {
567 composite_error(c, NT_STATUS_NO_MEMORY);
571 composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
579 Receive result of pipe open request on unix socket
581 NTSTATUS dcerpc_pipe_open_unix_stream_recv(struct composite_context *c)
583 NTSTATUS status = composite_wait(c);
591 Open a rpc pipe on a unix socket - sync version
593 NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *conn, const char *path)
595 struct composite_context *c = dcerpc_pipe_open_unix_stream_send(conn, path);
596 return dcerpc_pipe_open_unix_stream_recv(c);
600 struct pipe_np_state {
602 struct socket_address *srvaddr;
603 struct dcerpc_connection *conn;
608 Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
610 void continue_np_open_socket(struct composite_context *ctx)
612 struct composite_context *c = talloc_get_type(ctx->async.private_data,
613 struct composite_context);
615 c->status = dcerpc_pipe_open_socket_recv(ctx);
616 if (NT_STATUS_IS_OK(c->status)) {
621 composite_error(c, c->status);
626 Send pipe open request on ncalrpc
628 struct composite_context* dcerpc_pipe_open_pipe_send(struct dcerpc_connection *conn,
629 const char *identifier)
633 struct composite_context *c;
634 struct composite_context *sock_np_req;
635 struct pipe_np_state *s;
637 /* composite context allocation and setup */
638 c = talloc_zero(conn, struct composite_context);
639 if (c == NULL) return NULL;
641 s = talloc_zero(c, struct pipe_np_state);
643 composite_error(c, NT_STATUS_NO_MEMORY);
647 c->state = COMPOSITE_STATE_IN_PROGRESS;
649 c->event_ctx = conn->event_ctx;
651 /* store parameters in state structure */
652 canon = talloc_strdup(c, identifier);
655 string_replace(canon, '/', '\\');
656 s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
658 /* prepare server address using path and transport name */
659 s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
660 if (s->srvaddr == NULL) {
661 composite_error(c, NT_STATUS_NO_MEMORY);
665 /* send socket open request */
666 sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
667 if (sock_np_req == NULL) {
668 composite_error(c, NT_STATUS_NO_MEMORY);
672 composite_continue(c, sock_np_req, continue_np_open_socket, c);
681 Receive result of pipe open request on ncalrpc
683 NTSTATUS dcerpc_pipe_open_pipe_recv(struct composite_context *c)
685 NTSTATUS status = composite_wait(c);
693 Open a rpc pipe on a named pipe - sync version
695 NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *conn, const char *identifier)
697 struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, identifier);
698 return dcerpc_pipe_open_pipe_recv(c);