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)
288 struct composite_context *c;
289 struct pipe_open_socket_state *s;
290 struct composite_context *conn_req;
292 c = composite_create(mem_ctx, cn->event_ctx);
293 if (c == NULL) return NULL;
295 s = talloc_zero(c, struct pipe_open_socket_state);
296 if (composite_nomem(s, c)) return c;
300 s->transport = transport;
301 s->server = talloc_reference(c, server);
302 if (composite_nomem(s->server, c)) return c;
304 s->sock = talloc(cn, struct sock_private);
305 if (composite_nomem(s->sock, c)) return c;
307 c->status = socket_create(server->family, SOCKET_TYPE_STREAM, &s->socket_ctx, 0);
308 if (!composite_is_ok(c)) return c;
310 talloc_steal(s->sock, s->socket_ctx);
312 conn_req = socket_connect_send(s->socket_ctx, NULL, s->server, 0, c->event_ctx);
313 composite_continue(c, conn_req, continue_socket_connect, c);
318 NTSTATUS dcerpc_pipe_open_socket_recv(struct composite_context *c)
320 NTSTATUS status = composite_wait(c);
327 open a rpc connection using the generic socket library
329 NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *conn,
330 struct socket_address *server,
331 enum dcerpc_transport_t transport)
333 struct composite_context *c;
335 c = dcerpc_pipe_open_socket_send(conn, conn, server, transport);
336 return dcerpc_pipe_open_socket_recv(c);
340 struct pipe_tcp_state {
343 struct socket_address *srvaddr;
344 struct dcerpc_connection *conn;
348 void continue_ipv6_open_socket(struct composite_context *ctx);
349 void continue_ipv4_open_socket(struct composite_context *ctx);
353 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
354 on IPv6 and send the request on IPv4 unless IPv6 transport succeeded.
356 void continue_ipv6_open_socket(struct composite_context *ctx)
358 struct composite_context *c = talloc_get_type(ctx->async.private_data,
359 struct composite_context);
360 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
361 struct pipe_tcp_state);
362 struct composite_context *sock_ipv4_req;
364 /* receive result of socket open request */
365 c->status = dcerpc_pipe_open_socket_recv(ctx);
366 if (NT_STATUS_IS_OK(c->status)) {
371 talloc_free(s->srvaddr);
373 /* prepare server address using host:ip and transport name */
374 s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->server, s->port);
375 if (composite_nomem(s->srvaddr, c)) return;
377 /* try IPv4 if IPv6 fails */
378 sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
379 composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
384 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
387 void continue_ipv4_open_socket(struct composite_context *ctx)
389 struct composite_context *c = talloc_get_type(ctx->async.private_data,
390 struct composite_context);
391 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
392 struct pipe_tcp_state);
394 /* receive result socket open request */
395 c->status = dcerpc_pipe_open_socket_recv(ctx);
396 if (!NT_STATUS_IS_OK(c->status)) {
397 /* something went wrong... */
398 DEBUG(0, ("Failed to connect host %s on port %d - %s.\n",
399 s->server, s->port, nt_errstr(c->status)));
401 composite_error(c, c->status);
410 Send rpc pipe open request to given host:port using
413 struct composite_context* dcerpc_pipe_open_tcp_send(struct dcerpc_connection *conn,
414 const char* server, uint32_t port)
416 struct composite_context *c;
417 struct composite_context *sock_ipv6_req;
418 struct pipe_tcp_state *s;
420 /* composite context allocation and setup */
421 c = composite_create(conn, conn->event_ctx);
422 if (c == NULL) return NULL;
424 s = talloc_zero(c, struct pipe_tcp_state);
425 if (composite_nomem(s, c)) return c;
428 /* store input parameters in state structure */
429 s->server = talloc_strdup(c, server);
433 /* prepare server address using host ip:port and transport name */
434 s->srvaddr = socket_address_from_strings(s->conn, "ipv6", s->server, s->port);
435 if (composite_nomem(s->srvaddr, c)) return c;
437 /* try IPv6 first - send socket open request */
438 sock_ipv6_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
439 composite_continue(c, sock_ipv6_req, continue_ipv6_open_socket, c);
445 Receive result of pipe open request on tcp/ip
447 NTSTATUS dcerpc_pipe_open_tcp_recv(struct composite_context *c)
450 status = composite_wait(c);
458 Open rpc pipe on tcp/ip transport - sync version
460 NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *conn, const char *server,
463 struct composite_context *c;
465 c = dcerpc_pipe_open_tcp_send(conn, server, port);
466 return dcerpc_pipe_open_tcp_recv(c);
470 struct pipe_unix_state {
472 struct socket_address *srvaddr;
473 struct dcerpc_connection *conn;
478 Stage 2 of dcerpc_pipe_open_unix_stream_send: receive result of pipe open
479 request on unix socket.
481 void continue_unix_open_socket(struct composite_context *ctx)
483 struct composite_context *c = talloc_get_type(ctx->async.private_data,
484 struct composite_context);
486 c->status = dcerpc_pipe_open_socket_recv(ctx);
487 if (NT_STATUS_IS_OK(c->status)) {
492 composite_error(c, c->status);
497 Send pipe open request on unix socket
499 struct composite_context *dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection *conn,
502 struct composite_context *c;
503 struct composite_context *sock_unix_req;
504 struct pipe_unix_state *s;
506 /* composite context allocation and setup */
507 c = composite_create(conn, conn->event_ctx);
508 if (c == NULL) return NULL;
510 s = talloc_zero(c, struct pipe_unix_state);
511 if (composite_nomem(s, c)) return c;
514 /* store parameters in state structure */
515 s->path = talloc_strdup(c, path);
516 if (composite_nomem(s->path, c)) return c;
519 /* prepare server address using socket path and transport name */
520 s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
521 if (composite_nomem(s->srvaddr, c)) return c;
523 /* send socket open request */
524 sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
525 composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
531 Receive result of pipe open request on unix socket
533 NTSTATUS dcerpc_pipe_open_unix_stream_recv(struct composite_context *c)
535 NTSTATUS status = composite_wait(c);
543 Open a rpc pipe on a unix socket - sync version
545 NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *conn, const char *path)
547 struct composite_context *c = dcerpc_pipe_open_unix_stream_send(conn, path);
548 return dcerpc_pipe_open_unix_stream_recv(c);
552 struct pipe_np_state {
554 struct socket_address *srvaddr;
555 struct dcerpc_connection *conn;
560 Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
562 void continue_np_open_socket(struct composite_context *ctx)
564 struct composite_context *c = talloc_get_type(ctx->async.private_data,
565 struct composite_context);
567 c->status = dcerpc_pipe_open_socket_recv(ctx);
568 if (!composite_is_ok(c)) return;
575 Send pipe open request on ncalrpc
577 struct composite_context* dcerpc_pipe_open_pipe_send(struct dcerpc_connection *conn,
578 const char *identifier)
582 struct composite_context *c;
583 struct composite_context *sock_np_req;
584 struct pipe_np_state *s;
586 /* composite context allocation and setup */
587 c = composite_create(conn, conn->event_ctx);
588 if (c == NULL) return NULL;
590 s = talloc_zero(c, struct pipe_np_state);
591 if (composite_nomem(s, c)) return c;
594 /* store parameters in state structure */
595 canon = talloc_strdup(s, identifier);
596 if (composite_nomem(canon, c)) return c;
599 string_replace(canon, '/', '\\');
600 s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
601 if (composite_nomem(s->full_path, c)) return c;
603 /* prepare server address using path and transport name */
604 s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
605 if (composite_nomem(s->srvaddr, c)) return c;
607 /* send socket open request */
608 sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
609 composite_continue(c, sock_np_req, continue_np_open_socket, c);
615 Receive result of pipe open request on ncalrpc
617 NTSTATUS dcerpc_pipe_open_pipe_recv(struct composite_context *c)
619 NTSTATUS status = composite_wait(c);
627 Open a rpc pipe on a named pipe - sync version
629 NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *conn, const char *identifier)
631 struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, identifier);
632 return dcerpc_pipe_open_pipe_recv(c);