dcerpc over tcp in the samba4 server now works to some extent. It

needs quite a bit more work to get it finished. The biggest missing
feature is the lack of NTLMSSP which is needed for basic
authentication over tcp
(This used to be commit 9fb0f0369356909c99389e2cbc525be27c08793c)

1 files changed, 256 insertions, 0 deletions

diff --git a/source4/rpc_server/dcerpc_tcp.c b/source4/rpc_server/dcerpc_tcp.c
new file mode 100644
index 0000000000..110789dba6
--- /dev/null
+++ b/source4/rpc_server/dcerpc_tcp.c
@@ -0,0 +1,256 @@
+/* 
+   Unix SMB/CIFS implementation.
+
+   server side dcerpc over tcp code
+
+   Copyright (C) Andrew Tridgell 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+struct rpc_listen {
+	struct dce_endpoint *e;
+	struct model_ops *model_ops;
+};
+
+
+/*
+  called when a RPC socket becomes writable
+*/
+static void dcerpc_write_handler(struct event_context *ev, struct fd_event *fde, 
+				 time_t t, uint16 flags)
+{
+	struct dcesrv_state *dce = fde->private;
+	DATA_BLOB blob;
+	NTSTATUS status;
+
+	blob = data_blob(NULL, 0x4000);
+	if (!blob.data) {
+		smb_panic("out of memory in rpc write handler");
+	}
+
+	status = dcesrv_output(dce, &blob);
+	if (!NT_STATUS_IS_OK(status)) {
+		fde->flags &= ~EVENT_FD_WRITE;
+	} else {
+		write_data(fde->fd, blob.data, blob.length);
+	}
+
+	data_blob_free(&blob);
+}
+
+/*
+  called when a RPC socket becomes readable
+*/
+static void dcerpc_read_handler(struct event_context *ev, struct fd_event *fde, 
+				time_t t, uint16 flags)
+{
+	struct dcesrv_state *dce = fde->private;
+	DATA_BLOB blob;
+	ssize_t ret;
+
+	blob = data_blob(NULL, 0x4000);
+	if (!blob.data) {
+		smb_panic("out of memory in rpc read handler");
+	}
+
+	ret = read(fde->fd, blob.data, blob.length);
+	if (ret == 0) {
+		smb_panic("need a shutdown routine");
+	}
+	if (ret == -1 && errno != EINTR) {
+		smb_panic("need a shutdown routine");
+	}
+	if (ret == -1) {
+		return;
+	}
+
+	dcesrv_input(dce, &blob);
+
+	data_blob_free(&blob);
+
+	fde->flags |= EVENT_FD_WRITE;
+}
+
+
+
+
+/*
+  called when a RPC socket becomes readable
+*/
+static void dcerpc_io_handler(struct event_context *ev, struct fd_event *fde, 
+				time_t t, uint16 flags)
+{
+	if (flags & EVENT_FD_WRITE) {
+		dcerpc_write_handler(ev, fde, t, flags);
+	}
+
+	if (flags & EVENT_FD_READ) {
+		dcerpc_read_handler(ev, fde, t, flags);
+	}
+}
+	
+/*
+  initialise a server_context from a open socket and register a event handler
+  for reading from that socket
+*/
+void init_rpc_session(struct event_context *ev, void *private, int fd)
+{
+	struct dcesrv_context context;
+	struct dcesrv_state *dce;
+	struct fd_event fde;
+	struct rpc_listen *r = private;
+	struct dcesrv_endpoint endpoint;
+
+	set_socket_options(fd,"SO_KEEPALIVE");
+	set_socket_options(fd, lp_socket_options());
+
+	context.endpoint_list = NULL;
+	dcesrv_init(&context);
+
+	endpoint.type = ENDPOINT_TCP;
+	endpoint.info.tcp_port = 0;
+
+	dcesrv_endpoint_connect_ops(&context, &endpoint, r->e->endpoint_ops, &dce);
+
+	dce->dce = talloc_p(dce->mem_ctx, struct dcesrv_context);
+	*dce->dce = context;
+
+	set_blocking(fd, False);
+
+	/* setup a event handler for this socket. We are initially
+	   only interested in reading from the socket */
+	fde.fd = fd;
+	fde.handler = dcerpc_io_handler;
+	fde.private = dce;
+	fde.flags = EVENT_FD_READ;
+
+	event_add_fd(ev, &fde);
+}
+
+
+/*
+  setup a single rpc listener
+ */
+static void setup_listen_rpc(struct event_context *events,
+			     struct model_ops *model_ops, 
+			     struct in_addr *ifip, unsigned port,
+			     struct dce_endpoint *e)
+{
+	struct fd_event fde;
+	struct rpc_listen *r;
+
+	fde.fd = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
+	if (fde.fd == -1) {
+		DEBUG(0,("Failed to open socket on %s:%u - %s\n",
+			 inet_ntoa(*ifip), port, strerror(errno)));
+		return;
+	}
+
+	/* ready to listen */
+	set_socket_options(fde.fd, "SO_KEEPALIVE"); 
+	set_socket_options(fde.fd, lp_socket_options());
+      
+	if (listen(fde.fd, SMBD_LISTEN_BACKLOG) == -1) {
+		DEBUG(0,("Failed to listen on %s:%d - %s\n",
+			 inet_ntoa(*ifip), port, strerror(errno)));
+		close(fde.fd);
+		return;
+	}
+
+	r = malloc(sizeof(*r));
+	if (!r) {
+		return;
+	}
+
+	r->e = e;
+	r->model_ops = model_ops;
+
+	/* we are only interested in read events on the listen socket */
+	fde.flags = EVENT_FD_READ;
+	fde.private = r;
+	fde.handler = model_ops->accept_rpc_connection;
+	
+	event_add_fd(events, &fde);
+}
+
+/*
+  add a socket address to the list of events, one event per dcerpc endpoint
+*/
+static void add_socket_rpc(struct event_context *events, 
+			   struct model_ops *model_ops, 
+			   struct in_addr *ifip)
+{
+	struct dcesrv_context dce;
+	TALLOC_CTX *mem_ctx;
+	
+	mem_ctx = talloc_init("add_socket_rpc");
+	if (!mem_ctx) {
+		smb_panic("out of memory in add_socket_rpc");
+	}
+	
+	dce.endpoint_list = NULL;
+
+	dcesrv_init(&dce);
+
+	while (dce.endpoint_list) {
+		struct dce_endpoint *e = dce.endpoint_list;
+		struct dcesrv_ep_iface *ifaces;
+		int count, i;
+
+		count = e->endpoint_ops->lookup_endpoints(mem_ctx, &ifaces);
+		for (i=0;i<count;i++) {
+			if (ifaces[i].endpoint.type == ENDPOINT_TCP) {
+				setup_listen_rpc(events, model_ops, ifip, 
+						 ifaces[i].endpoint.info.tcp_port,
+						 e);
+				break;
+			}
+		}
+
+		DLIST_REMOVE(dce.endpoint_list, e);
+	}
+
+	talloc_destroy(mem_ctx);
+}
+
+/****************************************************************************
+ Open the listening sockets for RPC over TCP
+****************************************************************************/
+void open_sockets_rpc(struct event_context *events,
+		      struct model_ops *model_ops)
+{
+	if (lp_interfaces() && lp_bind_interfaces_only()) {
+		int num_interfaces = iface_count();
+		int i;
+		for(i = 0; i < num_interfaces; i++) {
+			struct in_addr *ifip = iface_n_ip(i);
+			if (ifip == NULL) {
+				continue;
+			}
+			add_socket_rpc(events, model_ops, ifip);
+		}
+	} else {
+		TALLOC_CTX *mem_ctx = talloc_init("open_sockets_smbd");		
+		struct in_addr *ifip = interpret_addr2(mem_ctx, lp_socket_address());
+		if (!mem_ctx) {
+			smb_panic("No memory");
+		}
+		add_socket_rpc(events, model_ops, ifip);
+		talloc_destroy(mem_ctx);
+	} 
+}