Clean up initialization a little bit more

5 files changed, 95 insertions, 43 deletions

diff --git a/include/libstate.h b/include/libstate.h
index 6b4c2cac1..a7972b7b3 100644
--- a/include/libstate.h
+++ b/include/libstate.h
@@ -35,11 +35,13 @@ class Library_State
 
       void set_prng(RandomNumberGenerator*);
       void randomize(byte[], u32bit);
-      void add_entropy_source(EntropySource*, bool = false);
+      void add_entropy_source(EntropySource*, bool = true);
       void add_entropy(const byte[], u32bit);
       void add_entropy(EntropySource&, bool);
       u32bit seed_prng(bool, u32bit);
 
+      void load(class Modules&);
+
       void set_timer(class Timer*);
       u64bit system_clock() const;
 
diff --git a/include/modules.h b/include/modules.h
index 48aeb11fb..81de52faf 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -6,6 +6,9 @@
 #ifndef BOTAN_MODULE_FACTORIES_H__
 #define BOTAN_MODULE_FACTORIES_H__
 
+#include <string>
+#include <vector>
+
 namespace Botan {
 
 /*************************************************
@@ -14,14 +17,14 @@ namespace Botan {
 class Modules
    {
    public:
-      void load(class Library_State&) const;
+      virtual class Mutex_Factory* mutex_factory() const = 0;
+      virtual class Timer* timer() const = 0;
 
-      virtual class Mutex_Factory* mutex_factory() const { return 0; }
-      virtual class Timer* timer() const { return 0; }
+      virtual std::string default_allocator() const = 0;
 
-      virtual void set_allocators(class Library_State&, bool) const {}
-      virtual void set_entropy_sources(class Library_State&) const {}
-      virtual void set_engines(class Library_State&, bool) const {}
+      virtual std::vector<class Allocator*> allocators() const = 0;
+      virtual std::vector<class EntropySource*> entropy_sources() const = 0;
+      virtual std::vector<class Engine*> engines() const = 0;
 
       virtual ~Modules() {}
    };
@@ -35,9 +38,15 @@ class Builtin_Modules : public Modules
       class Mutex_Factory* mutex_factory() const;
       class Timer* timer() const;
 
-      void set_allocators(class Library_State&, bool) const;
-      void set_entropy_sources(class Library_State&) const;
-      void set_engines(class Library_State&, bool) const;
+      std::string default_allocator() const;
+
+      std::vector<class Allocator*> allocators() const;
+      std::vector<class EntropySource*> entropy_sources() const;
+      std::vector<class Engine*> engines() const;
+
+      Builtin_Modules(bool sl) : should_lock(sl) {}
+   private:
+      const bool should_lock;
    };
 
 }
diff --git a/src/init_def.cpp b/src/init_def.cpp
index 6b2e5e66b..38d683dea 100644
--- a/src/init_def.cpp
+++ b/src/init_def.cpp
@@ -6,7 +6,7 @@
 #include <botan/init.h>
 #include <botan/libstate.h>
 #include <botan/modules.h>
-#include <botan/conf.h>
+#include <botan/config.h>
 #include <botan/defalloc.h>
 #include <botan/fips140.h>
 #include <botan/x931_rng.h>
@@ -38,7 +38,7 @@ namespace Init {
 void initialize(const std::string& arg_string)
    {
    InitializerOptions args(arg_string);
-   Builtin_Modules modules;
+   Builtin_Modules modules(false);
 
    Mutex_Factory* mutex_factory = 0;
 
@@ -52,18 +52,13 @@ void initialize(const std::string& arg_string)
    set_global_state(new Library_State(mutex_factory));
    global_state().set_default_policy();
 
-   global_state().set_timer(modules.timer());
-
-   modules.set_allocators(global_state(), false);
+   global_state().load(modules);
 
    if(args.config_file() != "")
       Config::load(args.config_file(), global_state());
 
-   modules.set_engines(global_state(), args.use_engines());
-
    global_state().set_transcoder(new Default_Charset_Transcoder);
    global_state().set_prng(new ANSI_X931_RNG);
-   modules.set_entropy_sources(global_state());
 
    const u32bit min_entropy = Config::get_u32bit("rng/min_entropy");
 
diff --git a/src/libstate.cpp b/src/libstate.cpp
index 92dfd2913..36d6299ad 100644
--- a/src/libstate.cpp
+++ b/src/libstate.cpp
@@ -4,6 +4,7 @@
 *************************************************/
 
 #include <botan/libstate.h>
+#include <botan/modules.h>
 #include <botan/engine.h>
 #include <botan/x509stat.h>
 #include <botan/stl_util.h>
@@ -321,6 +322,28 @@ X509_GlobalState& Library_State::x509_state()
    }
 
 /*************************************************
+* Load modules                                   *
+*************************************************/
+void Library_State::load(Modules& modules)
+   {
+   set_timer(modules.timer());
+
+   std::vector<Allocator*> allocators = modules.allocators();
+
+   for(u32bit j = 0; j != allocators.size(); j++)
+      add_allocator(allocators[j],
+                    allocators[j]->type() == modules.default_allocator());
+
+   std::vector<Engine*> engines = modules.engines();
+   for(u32bit j = 0; j != engines.size(); ++j)
+      add_engine(engines[j]);
+
+   std::vector<EntropySource*> sources = modules.entropy_sources();
+   for(u32bit j = 0; j != sources.size(); ++j)
+      add_entropy_source(sources[j]);
+   }
+
+/*************************************************
 * Library_State Constructor                      *
 *************************************************/
 Library_State::Library_State(Mutex_Factory* mutex_factory)
diff --git a/src/modules.cpp b/src/modules.cpp
index ab9f3b68f..1216fc3b9 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -103,83 +103,106 @@ Timer* Builtin_Modules::timer() const
 #elif defined(BOTAN_EXT_TIMER_WIN32)
    return new Win32_Timer;
 #else
-   return 0;
+   return new Timer;
 #endif
    }
 
 /*************************************************
-* Set any usable allocators                      *
+* Find any usable allocators                     *
 *************************************************/
-void Builtin_Modules::set_allocators(Library_State& state,
-                                     bool secure_mem) const
+std::vector<Allocator*> Builtin_Modules::allocators() const
    {
-   state.add_allocator(new Malloc_Allocator, !secure_mem);
+   std::vector<Allocator*> allocators;
 
-   state.add_allocator(new Locking_Allocator, secure_mem);
+#if defined(BOTAN_EXT_ALLOC_MMAP)
+   allocators.push_back(new MemoryMapping_Allocator);
+#endif
 
+   allocators.push_back(new Locking_Allocator);
+   allocators.push_back(new Malloc_Allocator);
+
+   return allocators;
+   }
+
+/*************************************************
+* Return the default allocator                   *
+*************************************************/
+std::string Builtin_Modules::default_allocator() const
+   {
+   if(should_lock)
+      {
 #if defined(BOTAN_EXT_ALLOC_MMAP)
-   state.add_allocator(new MemoryMapping_Allocator, secure_mem);
+      return "mmap";
+#else
+      return "locking";
 #endif
+      }
+   else
+      return "malloc";
    }
 
 /*************************************************
 * Register any usable entropy sources            *
 *************************************************/
-void Builtin_Modules::set_entropy_sources(Library_State& state) const
+std::vector<EntropySource*> Builtin_Modules::entropy_sources() const
    {
-   state.add_entropy_source(new File_EntropySource);
+   std::vector<EntropySource*> sources;
+
+   sources.push_back(new File_EntropySource);
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_AEP)
-   state.add_entropy_source(new AEP_EntropySource);
+   sources.push_back(new AEP_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_EGD)
-   state.add_entropy_source(new EGD_EntropySource);
+   sources.push_back(new EGD_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_CAPI)
-   state.add_entropy_source(new Win32_CAPI_EntropySource);
+   sources.push_back(new Win32_CAPI_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_WIN32)
-   state.add_entropy_source(new Win32_EntropySource);
+   sources.push_back(new Win32_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_UNIX)
-   state.add_entropy_source(new Unix_EntropySource);
+   sources.push_back(new Unix_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_BEOS)
-   state.add_entropy_source(new BeOS_EntropySource);
+   sources.push_back(new BeOS_EntropySource);
 #endif
 
 #if defined(BOTAN_EXT_ENTROPY_SRC_FTW)
-   state.add_entropy_source(new FTW_EntropySource);
+   sources.push_back(new FTW_EntropySource);
 #endif
+
+   return sources;
    }
 
 /*************************************************
 * Find any usable engines                        *
 *************************************************/
-void Builtin_Modules::set_engines(Library_State& state,
-                                  bool use_engines) const
+std::vector<Engine*> Builtin_Modules::engines() const
    {
-   if(use_engines)
-      {
+   std::vector<Engine*> engines;
+
 #if defined(BOTAN_EXT_ENGINE_AEP)
-      state.add_engine(new AEP_Engine);
+   engines.push_back(new AEP_Engine);
 #endif
 
 #if defined(BOTAN_EXT_ENGINE_GNU_MP)
-      state.add_engine(new GMP_Engine);
+   engines.push_back(new GMP_Engine);
 #endif
 
 #if defined(BOTAN_EXT_ENGINE_OPENSSL)
-      state.add_engine(new OpenSSL_Engine);
+   engines.push_back(new OpenSSL_Engine);
 #endif
-      }
 
-   state.add_engine(new Default_Engine);
+   engines.push_back(new Default_Engine);
+
+   return engines;
    }
 
 }