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"
31 #include "libcli/resolve/resolve.h"
33 /* transport private information used by general socket pipe transports */
36 struct socket_context *sock;
39 struct packet_context *packet;
40 uint32_t pending_reads;
47 static void sock_dead(struct dcerpc_connection *p, NTSTATUS status)
49 struct sock_private *sock = p->transport.private;
54 talloc_free(sock->fde);
59 talloc_free(sock->fde);
61 talloc_free(sock->sock);
66 packet_recv_disable(sock->packet);
67 packet_set_fde(sock->packet, NULL);
68 packet_set_socket(sock->packet, NULL);
71 if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL, status)) {
72 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
75 if (NT_STATUS_EQUAL(NT_STATUS_OK, status)) {
76 status = NT_STATUS_END_OF_FILE;
79 if (!NT_STATUS_IS_OK(status)) {
80 p->transport.recv_data(p, NULL, status);
86 handle socket recv errors
88 static void sock_error_handler(void *private, NTSTATUS status)
90 struct dcerpc_connection *p = talloc_get_type(private,
91 struct dcerpc_connection);
96 check if a blob is a complete packet
98 static NTSTATUS sock_complete_packet(void *private, DATA_BLOB blob, size_t *size)
100 if (blob.length < DCERPC_FRAG_LEN_OFFSET+2) {
101 return STATUS_MORE_ENTRIES;
103 *size = dcerpc_get_frag_length(&blob);
104 if (*size > blob.length) {
105 return STATUS_MORE_ENTRIES;
111 process recv requests
113 static NTSTATUS sock_process_recv(void *private, DATA_BLOB blob)
115 struct dcerpc_connection *p = talloc_get_type(private,
116 struct dcerpc_connection);
117 struct sock_private *sock = p->transport.private;
118 sock->pending_reads--;
119 if (sock->pending_reads == 0) {
120 packet_recv_disable(sock->packet);
122 p->transport.recv_data(p, &blob, NT_STATUS_OK);
127 called when a IO is triggered by the events system
129 static void sock_io_handler(struct event_context *ev, struct fd_event *fde,
130 uint16_t flags, void *private)
132 struct dcerpc_connection *p = talloc_get_type(private,
133 struct dcerpc_connection);
134 struct sock_private *sock = p->transport.private;
136 if (flags & EVENT_FD_WRITE) {
137 packet_queue_run(sock->packet);
141 if (sock->sock == NULL) {
145 if (flags & EVENT_FD_READ) {
146 packet_recv(sock->packet);
151 initiate a read request - not needed for dcerpc sockets
153 static NTSTATUS sock_send_read(struct dcerpc_connection *p)
155 struct sock_private *sock = p->transport.private;
156 sock->pending_reads++;
157 if (sock->pending_reads == 1) {
158 packet_recv_enable(sock->packet);
164 send an initial pdu in a multi-pdu sequence
166 static NTSTATUS sock_send_request(struct dcerpc_connection *p, DATA_BLOB *data,
169 struct sock_private *sock = p->transport.private;
173 if (sock->sock == NULL) {
174 return NT_STATUS_CONNECTION_DISCONNECTED;
177 blob = data_blob_talloc(sock->packet, data->data, data->length);
178 if (blob.data == NULL) {
179 return NT_STATUS_NO_MEMORY;
182 status = packet_send(sock->packet, blob);
183 if (!NT_STATUS_IS_OK(status)) {
195 shutdown sock pipe connection
197 static NTSTATUS sock_shutdown_pipe(struct dcerpc_connection *p, NTSTATUS status)
199 struct sock_private *sock = p->transport.private;
201 if (sock && sock->sock) {
202 sock_dead(p, status);
209 return sock server name
211 static const char *sock_peer_name(struct dcerpc_connection *p)
213 struct sock_private *sock = talloc_get_type(p->transport.private, struct sock_private);
214 return sock->server_name;
218 return remote name we make the actual connection (good for kerberos)
220 static const char *sock_target_hostname(struct dcerpc_connection *p)
222 struct sock_private *sock = talloc_get_type(p->transport.private, struct sock_private);
223 return sock->server_name;
227 struct pipe_open_socket_state {
228 struct dcerpc_connection *conn;
229 struct socket_context *socket_ctx;
230 struct sock_private *sock;
231 struct socket_address *server;
232 const char *target_hostname;
233 enum dcerpc_transport_t transport;
237 static void continue_socket_connect(struct composite_context *ctx)
239 struct dcerpc_connection *conn;
240 struct sock_private *sock;
241 struct composite_context *c = talloc_get_type(ctx->async.private_data,
242 struct composite_context);
243 struct pipe_open_socket_state *s = talloc_get_type(c->private_data,
244 struct pipe_open_socket_state);
246 /* make it easier to write a function calls */
250 c->status = socket_connect_recv(ctx);
251 if (!NT_STATUS_IS_OK(c->status)) {
252 DEBUG(0, ("Failed to connect host %s on port %d - %s\n",
253 s->server->addr, s->server->port,
254 nt_errstr(c->status)));
255 composite_error(c, c->status);
260 fill in the transport methods
262 conn->transport.transport = s->transport;
263 conn->transport.private = NULL;
265 conn->transport.send_request = sock_send_request;
266 conn->transport.send_read = sock_send_read;
267 conn->transport.recv_data = NULL;
269 conn->transport.shutdown_pipe = sock_shutdown_pipe;
270 conn->transport.peer_name = sock_peer_name;
271 conn->transport.target_hostname = sock_target_hostname;
273 sock->sock = s->socket_ctx;
274 sock->pending_reads = 0;
275 sock->server_name = strupper_talloc(sock, s->target_hostname);
277 sock->fde = event_add_fd(conn->event_ctx, sock->sock, socket_get_fd(sock->sock),
278 EVENT_FD_READ, sock_io_handler, conn);
280 conn->transport.private = sock;
282 sock->packet = packet_init(sock);
283 if (sock->packet == NULL) {
284 composite_error(c, NT_STATUS_NO_MEMORY);
289 packet_set_private(sock->packet, conn);
290 packet_set_socket(sock->packet, sock->sock);
291 packet_set_callback(sock->packet, sock_process_recv);
292 packet_set_full_request(sock->packet, sock_complete_packet);
293 packet_set_error_handler(sock->packet, sock_error_handler);
294 packet_set_event_context(sock->packet, conn->event_ctx);
295 packet_set_fde(sock->packet, sock->fde);
296 packet_set_serialise(sock->packet);
297 packet_set_initial_read(sock->packet, 16);
299 /* ensure we don't get SIGPIPE */
300 BlockSignals(True,SIGPIPE);
306 struct composite_context *dcerpc_pipe_open_socket_send(TALLOC_CTX *mem_ctx,
307 struct dcerpc_connection *cn,
308 struct socket_address *server,
309 const char *target_hostname,
310 enum dcerpc_transport_t transport)
312 struct composite_context *c;
313 struct pipe_open_socket_state *s;
314 struct composite_context *conn_req;
316 c = composite_create(mem_ctx, cn->event_ctx);
317 if (c == NULL) return NULL;
319 s = talloc_zero(c, struct pipe_open_socket_state);
320 if (composite_nomem(s, c)) return c;
324 s->transport = transport;
325 s->server = talloc_reference(c, server);
326 if (composite_nomem(s->server, c)) return c;
327 s->target_hostname = talloc_reference(s, target_hostname);
329 s->sock = talloc(cn, struct sock_private);
330 if (composite_nomem(s->sock, c)) return c;
332 c->status = socket_create(server->family, SOCKET_TYPE_STREAM, &s->socket_ctx, 0);
333 if (!composite_is_ok(c)) return c;
335 talloc_steal(s->sock, s->socket_ctx);
337 conn_req = socket_connect_send(s->socket_ctx, NULL, s->server, 0, c->event_ctx);
338 composite_continue(c, conn_req, continue_socket_connect, c);
343 NTSTATUS dcerpc_pipe_open_socket_recv(struct composite_context *c)
345 NTSTATUS status = composite_wait(c);
352 open a rpc connection using the generic socket library
354 NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *conn,
355 struct socket_address *server,
356 const char *target_hostname,
357 enum dcerpc_transport_t transport)
359 struct composite_context *c;
361 c = dcerpc_pipe_open_socket_send(conn, conn, server, target_hostname, transport);
362 return dcerpc_pipe_open_socket_recv(c);
366 struct pipe_tcp_state {
368 const char *target_hostname;
371 struct socket_address *srvaddr;
372 struct dcerpc_connection *conn;
376 #if 0 /* disabled till we can resolve names to ipv6 addresses */
377 static void continue_ipv6_open_socket(struct composite_context *ctx);
379 static void continue_ipv4_open_socket(struct composite_context *ctx);
380 static void continue_ip_resolve_name(struct composite_context *ctx);
382 static void continue_ip_resolve_name(struct composite_context *ctx)
384 struct composite_context *c = talloc_get_type(ctx->async.private_data,
385 struct composite_context);
386 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
387 struct pipe_tcp_state);
388 struct composite_context *sock_ipv4_req;
390 c->status = resolve_name_recv(ctx, s, &s->address);
391 if (!composite_is_ok(c)) return;
393 /* prepare server address using host ip:port and transport name */
394 s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->address, s->port);
395 if (composite_nomem(s->srvaddr, c)) return;
397 /* resolve_nbt_name gives only ipv4 ... - send socket open request */
398 sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn,
399 s->srvaddr, s->target_hostname,
401 composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
405 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
406 on IPv6 and send the request on IPv4 unless IPv6 transport succeeded.
408 #if 0 /* disabled till we can resolve names to ipv6 addresses */
409 static void continue_ipv6_open_socket(struct composite_context *ctx)
411 struct composite_context *c = talloc_get_type(ctx->async.private_data,
412 struct composite_context);
413 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
414 struct pipe_tcp_state);
415 struct composite_context *sock_ipv4_req;
417 /* receive result of socket open request */
418 c->status = dcerpc_pipe_open_socket_recv(ctx);
419 if (NT_STATUS_IS_OK(c->status)) {
424 talloc_free(s->srvaddr);
426 /* prepare server address using host:ip and transport name */
427 s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->address, s->port);
428 if (composite_nomem(s->srvaddr, c)) return;
430 /* try IPv4 if IPv6 fails */
431 sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn,
432 s->srvaddr, s->target_hostname,
434 composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
439 Stage 2 of dcerpc_pipe_open_tcp_send: receive result of pipe open request
442 static void continue_ipv4_open_socket(struct composite_context *ctx)
444 struct composite_context *c = talloc_get_type(ctx->async.private_data,
445 struct composite_context);
446 struct pipe_tcp_state *s = talloc_get_type(c->private_data,
447 struct pipe_tcp_state);
449 /* receive result socket open request */
450 c->status = dcerpc_pipe_open_socket_recv(ctx);
451 if (!NT_STATUS_IS_OK(c->status)) {
452 /* something went wrong... */
453 DEBUG(0, ("Failed to connect host %s (%s) on port %d - %s.\n",
454 s->address, s->target_hostname,
455 s->port, nt_errstr(c->status)));
457 composite_error(c, c->status);
466 Send rpc pipe open request to given host:port using
469 struct composite_context* dcerpc_pipe_open_tcp_send(struct dcerpc_connection *conn,
471 const char *target_hostname,
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;
497 make_nbt_name_server(&name, server);
498 resolve_req = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order());
499 composite_continue(c, resolve_req, continue_ip_resolve_name, c);
504 Receive result of pipe open request on tcp/ip
506 NTSTATUS dcerpc_pipe_open_tcp_recv(struct composite_context *c)
509 status = composite_wait(c);
517 Open rpc pipe on tcp/ip transport - sync version
519 NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *conn, const char *server,
520 const char *target_hostname,
523 struct composite_context *c;
525 c = dcerpc_pipe_open_tcp_send(conn, server, target_hostname, port);
526 return dcerpc_pipe_open_tcp_recv(c);
530 struct pipe_unix_state {
532 struct socket_address *srvaddr;
533 struct dcerpc_connection *conn;
538 Stage 2 of dcerpc_pipe_open_unix_stream_send: receive result of pipe open
539 request on unix socket.
541 void continue_unix_open_socket(struct composite_context *ctx)
543 struct composite_context *c = talloc_get_type(ctx->async.private_data,
544 struct composite_context);
546 c->status = dcerpc_pipe_open_socket_recv(ctx);
547 if (NT_STATUS_IS_OK(c->status)) {
552 composite_error(c, c->status);
557 Send pipe open request on unix socket
559 struct composite_context *dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection *conn,
562 struct composite_context *c;
563 struct composite_context *sock_unix_req;
564 struct pipe_unix_state *s;
566 /* composite context allocation and setup */
567 c = composite_create(conn, conn->event_ctx);
568 if (c == NULL) return NULL;
570 s = talloc_zero(c, struct pipe_unix_state);
571 if (composite_nomem(s, c)) return c;
574 /* store parameters in state structure */
575 s->path = talloc_strdup(c, path);
576 if (composite_nomem(s->path, c)) return c;
579 /* prepare server address using socket path and transport name */
580 s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
581 if (composite_nomem(s->srvaddr, c)) return c;
583 /* send socket open request */
584 sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn,
587 composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
593 Receive result of pipe open request on unix socket
595 NTSTATUS dcerpc_pipe_open_unix_stream_recv(struct composite_context *c)
597 NTSTATUS status = composite_wait(c);
605 Open a rpc pipe on a unix socket - sync version
607 NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *conn, const char *path)
609 struct composite_context *c = dcerpc_pipe_open_unix_stream_send(conn, path);
610 return dcerpc_pipe_open_unix_stream_recv(c);
614 struct pipe_np_state {
616 struct socket_address *srvaddr;
617 struct dcerpc_connection *conn;
622 Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
624 void continue_np_open_socket(struct composite_context *ctx)
626 struct composite_context *c = talloc_get_type(ctx->async.private_data,
627 struct composite_context);
629 c->status = dcerpc_pipe_open_socket_recv(ctx);
630 if (!composite_is_ok(c)) return;
637 Send pipe open request on ncalrpc
639 struct composite_context* dcerpc_pipe_open_pipe_send(struct dcerpc_connection *conn,
640 const char *identifier)
644 struct composite_context *c;
645 struct composite_context *sock_np_req;
646 struct pipe_np_state *s;
648 /* composite context allocation and setup */
649 c = composite_create(conn, conn->event_ctx);
650 if (c == NULL) return NULL;
652 s = talloc_zero(c, struct pipe_np_state);
653 if (composite_nomem(s, c)) return c;
656 /* store parameters in state structure */
657 canon = talloc_strdup(s, identifier);
658 if (composite_nomem(canon, c)) return c;
661 string_replace(canon, '/', '\\');
662 s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
663 if (composite_nomem(s->full_path, c)) return c;
665 /* prepare server address using path and transport name */
666 s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
667 if (composite_nomem(s->srvaddr, c)) return c;
669 /* send socket open request */
670 sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NULL, NCALRPC);
671 composite_continue(c, sock_np_req, continue_np_open_socket, c);
677 Receive result of pipe open request on ncalrpc
679 NTSTATUS dcerpc_pipe_open_pipe_recv(struct composite_context *c)
681 NTSTATUS status = composite_wait(c);
689 Open a rpc pipe on a named pipe - sync version
691 NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *conn, const char *identifier)
693 struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, identifier);
694 return dcerpc_pipe_open_pipe_recv(c);