lib/util Rename samba_init_module_fn -> samba_module_init_fn

[garming/samba-autobuild/.git] / source4 / smbd / process_model.c

diff --git a/source4/smbd/process_model.c b/source4/smbd/process_model.c
index 3493425774905d672ff1a6752d49ec0ddc448d9b..e43e9146d856a0ade84651506c78bb89675b0c87 100644 (file)
--- a/source4/smbd/process_model.c
+++ b/source4/smbd/process_model.c
@@ -6,7 +6,7 @@
    
    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
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -15,49 +15,68 @@
    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.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-#include "events.h"
-#include "smb_server/smb_server.h"
 #include "smbd/process_model.h"
+#include "param/param.h"
+#include "lib/util/samba_module.h"
+
+/* the list of currently registered process models */
+static struct process_model {
+       const struct model_ops *ops;
+       bool initialised;
+} *models = NULL;
+static int num_models;
+
+
+/*
+  return the operations structure for a named backend of the specified type
+*/
+static struct process_model *process_model_byname(const char *name)
+{
+       int i;
+
+       for (i=0;i<num_models;i++) {
+               if (strcmp(models[i].ops->name, name) == 0) {
+                       return &models[i];
+               }
+       }
+
+       return NULL;
+}
+
 
 /*
   setup the events for the chosen process model
 */
-const struct model_ops *process_model_startup(const char *model)
+_PUBLIC_ const struct model_ops *process_model_startup(const char *model)
 {
-       const struct model_ops *ops;
+       struct process_model *m;
 
-       ops = process_model_byname(model);
-       if (!ops) {
+       m = process_model_byname(model);
+       if (m == NULL) {
                DEBUG(0,("Unknown process model '%s'\n", model));
                exit(-1);
        }
 
-       ops->model_startup();
+       if (!m->initialised) {
+               m->initialised = true;
+               m->ops->model_init();
+       }
 
-       return ops;
+       return m->ops;
 }
 
-/* the list of currently registered process models */
-static struct {
-       struct model_ops *ops;
-} *models = NULL;
-static int num_models;
-
 /*
   register a process model. 
 
   The 'name' can be later used by other backends to find the operations
   structure for this backend.  
 */
-static NTSTATUS register_process_model(const void *_ops)
+_PUBLIC_ NTSTATUS register_process_model(const struct model_ops *ops)
 {
-       const struct model_ops *ops = _ops;
-
        if (process_model_byname(ops->name) != NULL) {
                /* its already registered! */
                DEBUG(0,("PROCESS_MODEL '%s' already registered\n", 
@@ -65,36 +84,42 @@ static NTSTATUS register_process_model(const void *_ops)
                return NT_STATUS_OBJECT_NAME_COLLISION;
        }
 
-       models = Realloc(models, sizeof(models[0]) * (num_models+1));
+       models = talloc_realloc(NULL, models, struct process_model, num_models+1);
        if (!models) {
                smb_panic("out of memory in register_process_model");
        }
 
-       models[num_models].ops = smb_xmemdup(ops, sizeof(*ops));
-       models[num_models].ops->name = smb_xstrdup(ops->name);
+       models[num_models].ops = ops;
+       models[num_models].initialised = false;
 
        num_models++;
 
-       DEBUG(3,("PROCESS_MODEL '%s' registered\n", 
-                ops->name));
+       DEBUG(3,("PROCESS_MODEL '%s' registered\n", ops->name));
 
        return NT_STATUS_OK;
 }
 
-/*
-  return the operations structure for a named backend of the specified type
-*/
-const struct model_ops *process_model_byname(const char *name)
+_PUBLIC_ NTSTATUS process_model_init(struct loadparm_context *lp_ctx)
 {
-       int i;
-
-       for (i=0;i<num_models;i++) {
-               if (strcmp(models[i].ops->name, name) == 0) {
-                       return models[i].ops;
-               }
+#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+       STATIC_process_model_MODULES_PROTO;
+       samba_module_init_fn static_init[] = { STATIC_process_model_MODULES };
+       samba_module_init_fn *shared_init;
+       static bool initialised;
+
+       if (initialised) {
+               return NT_STATUS_OK;
        }
+       initialised = true;
 
-       return NULL;
+       shared_init = samba_modules_load(NULL, "process_model");
+       
+       samba_init_module_fns_run(static_init);
+       samba_init_module_fns_run(shared_init);
+
+       talloc_free(shared_init);
+
+       return NT_STATUS_OK;
 }
 
 /*
@@ -106,30 +131,8 @@ const struct process_model_critical_sizes *process_model_version(void)
 {
        static const struct process_model_critical_sizes critical_sizes = {
                PROCESS_MODEL_VERSION,
-               sizeof(struct model_ops),
-               sizeof(struct smbsrv_connection),
-               sizeof(struct event_context),
-               sizeof(struct fd_event)
+               sizeof(struct model_ops)
        };
 
        return &critical_sizes;
 }
-
-/*
-  initialise the PROCESS_MODEL subsystem
-*/
-BOOL process_model_init(void)
-{
-       NTSTATUS status;
-
-       status = register_subsystem("process_model", register_process_model); 
-       if (!NT_STATUS_IS_OK(status)) {
-               return False;
-       }
-
-       /* FIXME: Perhaps panic if a basic process model, such as simple, fails to initialise? */
-       static_init_process_model;
-
-       DEBUG(3,("PROCESS subsystem version %d initialised\n", PROCESS_MODEL_VERSION));
-       return True;
-}