From 45a85bdd353418828df8017a9d7eb7c14f6f0cd3 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 13 Jul 2004 21:04:56 +0000 Subject: 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) --- source4/smbd/process_single.c | 119 +++++++++++++++++++++++++++--------------- 1 file changed, 77 insertions(+), 42 deletions(-) (limited to 'source4/smbd/process_single.c') 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 + 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); -- cgit