r1486: commit the start of the generic server infastructure

the idea is to have services as modules (smb, dcerpc, swat, ...)

the process_model don't know about the service it self anymore.

TODO:
- the smbsrv should use the smbsrv_send function
- the service subsystem init should be done like for other modules
- we need to have a generic socket subsystem, which handle stream, datagram,
  and virtuell other sockets( e.g. for the ntvfs_ipc module to connect to the dcerpc server
  , or for smb or dcerpc or whatever to connect to a server wide auth service)
- and other fixes...

NOTE: process model pthread seems to be broken( but also before this patch!)

metze
(This used to be commit bbe5e00715ca4013ff0dbc345aa97adc6b5c2458)

1 files changed, 135 insertions, 215 deletions

diff --git a/source4/rpc_server/dcerpc_tcp.c b/source4/rpc_server/dcerpc_tcp.c
index 83a9140dd1..c506cf16cf 100644
--- a/source4/rpc_server/dcerpc_tcp.c
+++ b/source4/rpc_server/dcerpc_tcp.c
@@ -23,39 +23,12 @@
 
 #include "includes.h"
 
-struct rpc_server_context {
-	struct dcesrv_ep_description *ep_description;
+struct dcesrv_socket_context {
 	const struct dcesrv_endpoint *endpoint;
-	const struct model_ops *model_ops;
-	struct dcesrv_connection *dce_conn;
-	struct dcesrv_context dcesrv_context;
-	int socket_fd;
-	struct event_context *events;	
+	struct dcesrv_context *dcesrv_ctx;	
 };
 
 /*
-  a callback from the process model termination routine 
-*/
-void rpc_server_terminate(void *rr)
-{
-	struct rpc_server_context *r = rr;
-
-	dcesrv_endpoint_disconnect(r->dce_conn);
-	close(r->socket_fd);
-	event_remove_fd_all(r->events, r->socket_fd);
-	free(r);
-}
-
-/*
-  called when a rpc session needs to be shutdown
-*/
-static void terminate_rpc_session(struct rpc_server_context *r, const char *reason)
-{
-	r->model_ops->terminate_rpc_connection(r, reason);
-}
-
-
-/*
   write_fn callback for dcesrv_output()
 */
 static ssize_t dcerpc_write_fn(void *private, const void *buf, size_t count)
@@ -69,45 +42,128 @@ static ssize_t dcerpc_write_fn(void *private, const void *buf, size_t count)
 	return ret;
 }
 
+void dcesrv_terminate_connection(struct dcesrv_connection *dce_conn, const char *reason)
+{
+	server_terminate_connection(dce_conn->srv_conn, reason);
+}
+
 /*
-  called when a RPC socket becomes writable
+  add a socket address to the list of events, one event per dcerpc endpoint
 */
-static void dcerpc_write_handler(struct event_context *ev, struct fd_event *fde, 
-				 time_t t, uint16_t flags)
+static void add_socket_rpc(struct server_service *service, 
+		       const struct model_ops *model_ops,
+		       struct socket_context *socket_ctx,
+		       struct dcesrv_context *dce_ctx, 
+		       struct in_addr *ifip)
 {
-	struct rpc_server_context *r = fde->private;
-	NTSTATUS status;
+	struct dcesrv_endpoint *e;
 
-	status = dcesrv_output(r->dce_conn, fde, dcerpc_write_fn);
-	if (NT_STATUS_IS_ERR(status)) {
-		/* TODO: destroy fd_event? */
+	for (e=dce_ctx->endpoint_list;e;e=e->next) {
+		if (e->ep_description.type == ENDPOINT_TCP) {
+			struct server_socket *sock;
+			struct dcesrv_socket_context *dcesrv_sock;
+
+			sock = service_setup_socket(service,model_ops,socket_ctx,ifip, &e->ep_description.info.tcp_port);
+			if (!sock) {
+				DEBUG(0,("service_setup_socket(port=%u) failed\n",e->ep_description.info.tcp_port));
+				continue;
+			}
+
+			dcesrv_sock = talloc_p(sock->mem_ctx, struct dcesrv_socket_context);
+			if (!dcesrv_sock) {
+				DEBUG(0,("talloc_p(sock->mem_ctx, struct dcesrv_socket_context) failed\n"));
+				continue;
+			}
+
+			/* remeber the enpoint of this socket */
+			dcesrv_sock->endpoint		= e;
+			dcesrv_sock->dcesrv_ctx		= dce_ctx;
+			
+			sock->private_data = dcesrv_sock;
+		}
 	}
+}
 
-	if (!r->dce_conn->call_list || !r->dce_conn->call_list->replies) {
-		fde->flags &= ~EVENT_FD_WRITE;
+/****************************************************************************
+ Open the listening sockets for RPC over TCP
+****************************************************************************/
+void dcesrv_tcp_init(struct server_service *service, const struct model_ops *model_ops, struct dcesrv_context *dce_ctx)
+{
+	DEBUG(1,("dcesrv_tcp_init\n"));
+
+	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(service, model_ops, NULL, dce_ctx,  ifip);
+		}
+	} else {
+		struct in_addr *ifip;
+		TALLOC_CTX *mem_ctx = talloc_init("open_sockets_smbd");
+		if (!mem_ctx) {
+			smb_panic("No memory");
+		}
+
+		ifip = interpret_addr2(mem_ctx, lp_socket_address());
+		add_socket_rpc(service, model_ops, NULL, dce_ctx,  ifip);
+		talloc_destroy(mem_ctx);
 	}
+
+	return;	
 }
 
-/*
-  called when a RPC socket becomes readable
-*/
-static void dcerpc_read_handler(struct event_context *ev, struct fd_event *fde, 
-				time_t t, uint16_t flags)
+void dcesrv_tcp_accept(struct server_connection *conn)
+{
+	NTSTATUS status;
+	struct dcesrv_socket_context *dcesrv_sock = conn->server_socket->private_data;
+	struct dcesrv_connection *dcesrv_conn = NULL;
+
+	DEBUG(5,("dcesrv_tcp_accept\n"));
+
+
+
+	status = dcesrv_endpoint_connect(dcesrv_sock->dcesrv_ctx, dcesrv_sock->endpoint, &dcesrv_conn);
+	if (!NT_STATUS_IS_OK(status)) {
+		DEBUG(0,("dcesrv_tcp_accept: dcesrv_endpoint_connect failed: %s\n", 
+			nt_errstr(status)));
+		return;
+	}
+
+	dcesrv_conn->srv_conn = conn;
+
+	conn->private_data = dcesrv_conn;
+
+	/* TODO: this should to the generic code
+	 *       but the smb server can't handle it yet
+	 *	 --metze
+	 */ 
+	set_blocking(conn->socket->fde->fd, False);
+
+	return;	
+}
+
+void dcesrv_tcp_recv(struct server_connection *conn, time_t t, uint16_t flags)
 {
-	struct rpc_server_context *r = fde->private;
+	struct dcesrv_connection *dce_conn = conn->private_data;
 	DATA_BLOB blob;
 	ssize_t ret;
 
+	DEBUG(10,("dcesrv_tcp_recv\n"));
+
 	blob = data_blob(NULL, 0x4000);
 	if (!blob.data) {
-		terminate_rpc_session(r, "out of memory");
+		dcesrv_terminate_connection(dce_conn, "eof on socket");
 		return;
 	}
 
-	ret = read(fde->fd, blob.data, blob.length);
+	ret = read(conn->socket->fde->fd, blob.data, blob.length);
 	if (ret == 0 || (ret == -1 && errno != EINTR)) {
 		data_blob_free(&blob);
-		terminate_rpc_session(r, "eof on socket");
+		dcesrv_terminate_connection(dce_conn, "eof on socket");
 		return;
 	}
 	if (ret == -1) {
@@ -117,197 +173,61 @@ static void dcerpc_read_handler(struct event_context *ev, struct fd_event *fde,
 
 	blob.length = ret;
 
-	dcesrv_input(r->dce_conn, &blob);
+	dcesrv_input(dce_conn, &blob);
 
 	data_blob_free(&blob);
 
-	if (r->dce_conn->call_list && r->dce_conn->call_list->replies) {
-		fde->flags |= EVENT_FD_WRITE;
+	if (dce_conn->call_list && dce_conn->call_list->replies) {
+		conn->socket->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_t 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);
-	}
+	return;	
 }
-	
-/*
-  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)
+
+void dcesrv_tcp_send(struct server_connection *conn, time_t t, uint16_t flags)
 {
-	struct fd_event fde;
-	struct rpc_server_context *r = private;
+	struct dcesrv_connection *dce_conn = conn->private_data;
 	NTSTATUS status;
 
-	r = memdup(r, sizeof(struct rpc_server_context));
-
-	r->events = ev;
-	r->socket_fd = fd;
+	DEBUG(10,("dcesrv_tcp_send\n"));
 
-	set_socket_options(fd,"SO_KEEPALIVE");
-	set_socket_options(fd, lp_socket_options());
-
-	status = dcesrv_endpoint_connect(&r->dcesrv_context, r->endpoint, &r->dce_conn);
-	if (!NT_STATUS_IS_OK(status)) {
-		close(fd);
-		free(r);
-		DEBUG(0,("init_rpc_session: connection to endpoint failed: %s\n", 
-			nt_errstr(status)));
-		return;
+	status = dcesrv_output(dce_conn, conn->socket->fde, dcerpc_write_fn);
+	if (NT_STATUS_IS_ERR(status)) {
+		/* TODO: destroy fd_event? */
 	}
 
-	r->dce_conn->dce_ctx = &r->dcesrv_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 = r;
-	fde.flags = EVENT_FD_READ;
+	if (!dce_conn->call_list || !dce_conn->call_list->replies) {
+		conn->socket->fde->flags &= ~EVENT_FD_WRITE;
+	}
 
-	event_add_fd(ev, &fde);
+	return;	
 }
 
-
-/*
-  setup a single rpc listener
- */
-static void setup_listen_rpc(struct event_context *events,
-			     const struct model_ops *model_ops, 
-			     struct in_addr *ifip, uint32_t *port,
-			     struct rpc_server_context *r,
-			     const struct dcesrv_endpoint *endpoint)
+void dcesrv_tcp_idle(struct server_connection *conn, time_t t)
 {
-	struct fd_event fde;
-	int i;
-
-	if (*port == 0) {
-		fde.fd = -1;
-		for (i=DCERPC_TCP_LOW_PORT;i<= DCERPC_TCP_HIGH_PORT;i++) {
-			fde.fd = open_socket_in(SOCK_STREAM, i, 0, ifip->s_addr, True);			
-			if (fde.fd != -1) break;
-		}
-		if (fde.fd != -1) {
-			*port = i;
-		}
-	} else {
-		fde.fd = open_socket_in(SOCK_STREAM, *port, 0, ifip->s_addr, True);
-	}
+	DEBUG(10,("dcesrv_tcp_idle\n"));
+	conn->event.idle->next_event = t + 5;
 
-	if (fde.fd == -1) {
-		DEBUG(0,("Failed to open socket on %s:%u - %s\n",
-			 inet_ntoa(*ifip), *port, strerror(errno)));
-		return;
-	}
-
-	/* each listening socket has separate state, so must use a different context */
-	r = memdup(r, sizeof(struct rpc_server_context));
-	if (!r) {
-		smb_panic("out of memory");
-	}
-
-	r->ep_description = malloc(sizeof(struct dcesrv_ep_description));
-	if (!r->ep_description) {
-		smb_panic("out of memory");
-	}
-	r->ep_description->type = ENDPOINT_TCP;
-	r->ep_description->info.tcp_port = *port;
-
-	r->endpoint = endpoint;
-
-	/* 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;
-	}
-
-	/* 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);
+	return;	
 }
 
-/*
-  add a socket address to the list of events, one event per dcerpc endpoint
-*/
-static void add_socket_rpc(struct event_context *events, 
-			   const struct model_ops *model_ops, 
-			   struct in_addr *ifip)
+void dcesrv_tcp_close(struct server_connection *conn, const char *reason)
 {
-	struct dcesrv_endpoint *e;
-	struct rpc_server_context *r;
+	struct dcesrv_connection *dce_conn = conn->private_data;
 
-	r = malloc(sizeof(struct rpc_server_context));
-	if (!r) {
-		smb_panic("out of memory");
-	}
+	DEBUG(5,("dcesrv_tcp_close: %s\n",reason));
 
-	r->dcesrv_context.endpoint_list = NULL;
-	dcesrv_init_context(&r->dcesrv_context);
-	r->ep_description = NULL;
-	r->model_ops = model_ops;
-	r->dce_conn = NULL;
-	r->socket_fd = -1;
-	r->events = NULL;
-	
-	for (e=r->dcesrv_context.endpoint_list;e;e=e->next) {
-		if (e->ep_description.type == ENDPOINT_TCP) {
-			setup_listen_rpc(events, model_ops, ifip, 
-					 &e->ep_description.info.tcp_port, 
-					 r, e);
-		}
-	}
+	close(conn->event.fde->fd);
+	event_remove_fd_all(conn->event.ctx, conn->socket->fde->fd);
+	event_remove_timed(conn->event.ctx, conn->event.idle);
 
-	free(r);
+	talloc_destroy(dce_conn->mem_ctx);
+
+	return;
 }
 
-/****************************************************************************
- Open the listening sockets for RPC over TCP
-****************************************************************************/
-void open_sockets_rpc(struct event_context *events,
-		      const struct model_ops *model_ops)
+void dcesrv_tcp_exit(struct server_service *service, const char *reason)
 {
-	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);
-	} 
+	DEBUG(1,("dcesrv_tcp_exit: %s\n",reason));
+	return;
 }