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, 77 insertions, 42 deletions

diff --git a/source4/smbd/process_single.c b/source4/smbd/process_single.c
index 9c92d8569a..b65418cd01 100644
--- a/source4/smbd/process_single.c
+++ b/source4/smbd/process_single.c
@@ -3,6 +3,7 @@
    process model: process (1 process handles all client connections)
    Copyright (C) Andrew Tridgell 2003
    Copyright (C) James J Myers 2003 <myersjj@samba.org>
+   Copyright (C) Stefan (metze) Metzmacher 2004
    
    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
@@ -21,10 +22,11 @@
 
 #include "includes.h"
 
+
 /*
   called when the process model is selected
 */
-static void model_startup(void)
+static void single_start_server(void)
 {
 	smbd_process_init();
 }
@@ -32,67 +34,102 @@ static void model_startup(void)
 /*
   called when a listening socket becomes readable
 */
-static void accept_connection(struct event_context *ev, struct fd_event *fde, time_t t, uint16_t flags)
+static void single_accept_connection(struct event_context *ev, struct fd_event *srv_fde, time_t t, uint16_t flags)
 {
 	int accepted_fd;
 	struct sockaddr addr;
 	socklen_t in_addrlen = sizeof(addr);
-	struct model_ops *model_ops = fde->private;
-	
+	struct fd_event fde;
+	struct timed_event idle;
+	struct server_socket *server_socket = srv_fde->private;
+	struct server_connection *conn;
+	TALLOC_CTX *mem_ctx;
+
 	/* accept an incoming connection. */
-	accepted_fd = accept(fde->fd,&addr,&in_addrlen);
+	accepted_fd = accept(srv_fde->fd,&addr,&in_addrlen);
 	if (accepted_fd == -1) {
 		DEBUG(0,("accept_connection_single: accept: %s\n",
 			 strerror(errno)));
 		return;
 	}
 
-	/* create a smb server context and add it to out event
-	   handling */
-	init_smbsession(ev, model_ops, accepted_fd, smbd_read_handler); 
+	mem_ctx = talloc_init("server_service_connection");
+	if (!mem_ctx) {
+		DEBUG(0,("talloc_init(server_service_connection) failed\n"));
+		return;
+	}
 
-	/* return to event handling */
-}
+	conn = talloc_p(mem_ctx, struct server_connection);
+	if (!conn) {
+		DEBUG(0,("talloc_p(mem_ctx, struct server_service_connection) failed\n"));
+		talloc_destroy(mem_ctx);
+		return;
+	}
 
+	ZERO_STRUCTP(conn);
+	conn->mem_ctx = mem_ctx;
 
-/*
-  called when a rpc listening socket becomes readable
-*/
-static void accept_rpc_connection(struct event_context *ev, struct fd_event *fde, time_t t, uint16_t flags)
-{
-	int accepted_fd;
-	struct sockaddr addr;
-	socklen_t in_addrlen = sizeof(addr);
-	
-	/* accept an incoming connection. */
-	accepted_fd = accept(fde->fd,&addr,&in_addrlen);
-	if (accepted_fd == -1) {
-		DEBUG(0,("accept_connection_single: accept: %s\n",
-			 strerror(errno)));
+	fde.private 	= conn;
+	fde.fd		= accepted_fd;
+	fde.flags	= EVENT_FD_READ;
+	fde.handler	= server_io_handler;
+
+	idle.private 	= conn;
+	idle.next_event	= t + 300;
+	idle.handler	= server_idle_handler;
+
+	conn->event.ctx		= ev;
+	conn->event.fde		= &fde;
+	conn->event.idle	= &idle;
+	conn->event.idle_time	= 300;
+
+	conn->server_socket	= server_socket;
+	conn->service		= server_socket->service;
+
+	/* TODO: we need a generic socket subsystem */
+	conn->socket		= talloc_p(conn->mem_ctx, struct socket_context);
+	if (!conn->socket) {
+		DEBUG(0,("talloc_p(conn->mem_ctx, struct socket_context) failed\n"));
+		talloc_destroy(mem_ctx);
 		return;
 	}
+	conn->socket->private_data	= NULL;
+	conn->socket->ops		= NULL;
+	conn->socket->client_addr	= NULL;
+	conn->socket->pkt_count		= 0;
+	conn->socket->fde		= conn->event.fde;
 
-	init_rpc_session(ev, fde->private, accepted_fd); 
-}
+	/* create a smb server context and add it to out event
+	   handling */
+	server_socket->service->ops->accept_connection(conn);
 
-/* called when a SMB connection goes down */
-static void terminate_connection(struct smbsrv_connection *server, const char *reason) 
-{
-	server_terminate(server);
+	/* accpect_connection() of the service may changed idle.next_event */
+	conn->event.fde		= event_add_fd(ev,&fde);
+	conn->event.idle	= event_add_timed(ev,&idle);
+
+	conn->socket->fde	= conn->event.fde;
+
+	DLIST_ADD(server_socket->connection_list,conn);
+
+	/* return to event handling */
+	return;
 }
 
-/* called when a rpc connection goes down */
-static void terminate_rpc_connection(void *r, const char *reason) 
+
+
+/* called when a SMB connection goes down */
+static void single_terminate_connection(struct server_connection *conn, const char *reason) 
 {
-	rpc_server_terminate(r);
+	DEBUG(0,("single_terminate_connection: reason[%s]\n",reason));
+	conn->service->ops->close_connection(conn,reason);
 }
 
-static int get_id(struct smbsrv_request *req)
+static int single_get_id(struct smbsrv_request *req)
 {
 	return (int)req->smb_conn->pid;
 }
 
-static void single_exit_server(struct smbsrv_connection *smb, const char *reason)
+static void single_exit_server(struct server_context *srv_ctx, const char *reason)
 {
 	DEBUG(1,("single_exit_server: reason[%s]\n",reason));
 }
@@ -111,13 +148,11 @@ NTSTATUS process_model_single_init(void)
 	ops.name = "single";
 
 	/* fill in all the operations */
-	ops.model_startup = model_startup;
-	ops.accept_connection = accept_connection;
-	ops.accept_rpc_connection = accept_rpc_connection;
-	ops.terminate_connection = terminate_connection;
-	ops.terminate_rpc_connection = terminate_rpc_connection;
-	ops.exit_server = single_exit_server;
-	ops.get_id = get_id;
+	ops.model_startup		= single_start_server;
+	ops.accept_connection		= single_accept_connection;
+	ops.terminate_connection	= single_terminate_connection;
+	ops.exit_server			= single_exit_server;
+	ops.get_id			= single_get_id;
 
 	/* register ourselves with the PROCESS_MODEL subsystem. */
 	ret = register_backend("process_model", &ops);