waf: Remove lib prefix from libraries manually.

[kai/samba.git] / source4 / smbd / process_model.c

diff --git a/source4/smbd/process_model.c b/source4/smbd/process_model.c
index 06127d136459fae0f719ecc95f913cca5c8e0df7..d3f234eb41c921155bafdf33c2f9659ab4f4a842 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,16 +15,35 @@
    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 "smbd/process_model.h"
+#include "param/param.h"
 
+static const struct model_ops *process_model_byname(const char *name);
+
+/*
+  setup the events for the chosen process model
+*/
+_PUBLIC_ const struct model_ops *process_model_startup(struct tevent_context *ev, const char *model)
+{
+       const struct model_ops *ops;
+
+       ops = process_model_byname(model);
+       if (!ops) {
+               DEBUG(0,("Unknown process model '%s'\n", model));
+               exit(-1);
+       }
+
+       ops->model_init(ev);
+
+       return ops;
+}
 
 /* the list of currently registered process models */
-static struct {
-       const char *name;
+static struct process_model {
        struct model_ops *ops;
 } *models = NULL;
 static int num_models;
@@ -35,37 +54,60 @@ static int num_models;
   The 'name' can be later used by other backends to find the operations
   structure for this backend.  
 */
-BOOL register_process_model(const char *name, struct model_ops *ops)
+_PUBLIC_ NTSTATUS register_process_model(const void *_ops)
 {
-       if (process_model_byname(name) != NULL) {
+       const struct model_ops *ops = _ops;
+
+       if (process_model_byname(ops->name) != NULL) {
                /* its already registered! */
-               DEBUG(2,("process_model '%s' already registered\n", 
-                        name));
-               return False;
+               DEBUG(0,("PROCESS_MODEL '%s' already registered\n", 
+                        ops->name));
+               return NT_STATUS_OBJECT_NAME_COLLISION;
        }
 
-       models = Realloc(models, sizeof(models[0]) * (num_models+1));
+       models = realloc_p(models, struct process_model, num_models+1);
        if (!models) {
                smb_panic("out of memory in register_process_model");
        }
 
-       models[num_models].name = smb_xstrdup(name);
        models[num_models].ops = smb_xmemdup(ops, sizeof(*ops));
+       models[num_models].ops->name = smb_xstrdup(ops->name);
 
        num_models++;
 
-       return True;
+       DEBUG(3,("PROCESS_MODEL '%s' registered\n", 
+                ops->name));
+
+       return NT_STATUS_OK;
+}
+
+_PUBLIC_ NTSTATUS process_model_init(struct loadparm_context *lp_ctx)
+{
+       extern NTSTATUS process_model_thread_init(void);
+       extern NTSTATUS process_model_standard_init(void);
+       extern NTSTATUS process_model_prefork_init(void);
+       extern NTSTATUS process_model_onefork_init(void);
+       extern NTSTATUS process_model_single_init(void);
+       init_module_fn static_init[] = { STATIC_process_model_MODULES };
+       init_module_fn *shared_init = load_samba_modules(NULL, lp_ctx, "process_model");
+
+       run_init_functions(static_init);
+       run_init_functions(shared_init);
+
+       talloc_free(shared_init);
+       
+       return NT_STATUS_OK;
 }
 
 /*
   return the operations structure for a named backend of the specified type
 */
-struct model_ops *process_model_byname(const char *name)
+static const struct model_ops *process_model_byname(const char *name)
 {
        int i;
 
        for (i=0;i<num_models;i++) {
-               if (strcmp(models[i].name, name) == 0) {
+               if (strcmp(models[i].ops->name, name) == 0) {
                        return models[i].ops;
                }
        }
@@ -73,13 +115,17 @@ struct model_ops *process_model_byname(const char *name)
        return NULL;
 }
 
-
-/* initialise the builtin process models */
-void process_model_init(void)
+/*
+  return the PROCESS_MODEL module version, and the size of some critical types
+  This can be used by process model modules to either detect compilation errors, or provide
+  multiple implementations for different smbd compilation options in one module
+*/
+const struct process_model_critical_sizes *process_model_version(void)
 {
-       process_model_standard_init();
-       process_model_single_init();
-#ifdef WITH_PTHREADS
-       process_model_thread_init();
-#endif
+       static const struct process_model_critical_sizes critical_sizes = {
+               PROCESS_MODEL_VERSION,
+               sizeof(struct model_ops)
+       };
+
+       return &critical_sizes;
 }