propagate from branch 'net.randombit.botan' (head 14c1d4dc8696d2705a70ec3d2403e01d2ca95265)

            to branch 'net.randombit.botan.c++0x' (head c567fa7310ba082a837562092728c4b4b882bf82)

4 files changed, 44 insertions, 123 deletions

diff --git a/src/libstate/info.txt b/src/libstate/info.txt
index d8e9869ac..cb584f4d8 100644
--- a/src/libstate/info.txt
+++ b/src/libstate/info.txt
@@ -38,8 +38,6 @@ hash
 kdf
 mac
 mode_pad
-mutex
-noop_mutex
 pk_pad
 pubkey
 rng
diff --git a/src/libstate/init.cpp b/src/libstate/init.cpp
index b908de6c7..0d9a2420c 100644
--- a/src/libstate/init.cpp
+++ b/src/libstate/init.cpp
@@ -1,12 +1,11 @@
 /**
 * Default Initialization Function
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/init.h>
-#include <botan/parsing.h>
 #include <botan/libstate.h>
 
 namespace Botan {
@@ -14,36 +13,8 @@ namespace Botan {
 /*
 * Library Initialization
 */
-void LibraryInitializer::initialize(const std::string& arg_string)
+void LibraryInitializer::initialize(const std::string&)
    {
-   bool thread_safe = false;
-
-   const std::vector<std::string> arg_list = split_on(arg_string, ' ');
-   for(u32bit j = 0; j != arg_list.size(); ++j)
-      {
-      if(arg_list[j].size() == 0)
-         continue;
-
-      std::string name, value;
-
-      if(arg_list[j].find('=') == std::string::npos)
-         {
-         name = arg_list[j];
-         value = "true";
-         }
-      else
-         {
-         std::vector<std::string> name_and_value = split_on(arg_list[j], '=');
-         name = name_and_value[0];
-         value = name_and_value[1];
-         }
-
-      bool is_on =
-         (value == "1" || value == "true" || value == "yes" || value == "on");
-
-      if(name == "thread_safe")
-         thread_safe = is_on;
-      }
 
    try
       {
@@ -55,7 +26,7 @@ void LibraryInitializer::initialize(const std::string& arg_string)
       */
       set_global_state(new Library_State);
 
-      global_state().initialize(thread_safe);
+      global_state().initialize();
       }
    catch(...)
       {
diff --git a/src/libstate/libstate.cpp b/src/libstate/libstate.cpp
index 6aa3c5119..4fdf1cd30 100644
--- a/src/libstate/libstate.cpp
+++ b/src/libstate/libstate.cpp
@@ -6,26 +6,14 @@
 */
 
 #include <botan/libstate.h>
-#include <botan/charset.h>
-#include <botan/engine.h>
 #include <botan/init.h>
 #include <botan/selftest.h>
 
 #include <botan/internal/defalloc.h>
 #include <botan/internal/default_engine.h>
-#include <botan/internal/mutex.h>
-#include <botan/internal/mux_noop.h>
 #include <botan/internal/stl_util.h>
 #include <algorithm>
 
-#if defined(BOTAN_HAS_MUTEX_PTHREAD)
-  #include <botan/internal/mux_pthr.h>
-#elif defined(BOTAN_HAS_MUTEX_WIN32)
-  #include <botan/internal/mux_win32.h>
-#elif defined(BOTAN_HAS_MUTEX_QT)
-  #include <botan/internal/mux_qt.h>
-#endif
-
 #if defined(BOTAN_HAS_ALLOC_MMAP)
   #include <botan/internal/mmap_mem.h>
 #endif
@@ -92,25 +80,17 @@ void set_global_state(Library_State* new_state)
 */
 Library_State* swap_global_state(Library_State* new_state)
    {
-   Library_State* old_state = global_lib_state;
+   auto old_state = global_lib_state;
    global_lib_state = new_state;
    return old_state;
    }
 
 /*
-* Get a new mutex object
-*/
-Mutex* Library_State::get_mutex() const
-   {
-   return mutex_factory->make();
-   }
-
-/*
 * Get an allocator by its name
 */
-Allocator* Library_State::get_allocator(const std::string& type) const
+Allocator* Library_State::get_allocator(const std::string& type)
    {
-   Mutex_Holder lock(allocator_lock);
+   std::lock_guard<std::mutex> lock(allocator_lock);
 
    if(type != "")
       return search_map<std::string, Allocator*>(alloc_factory, type, 0);
@@ -134,7 +114,7 @@ Allocator* Library_State::get_allocator(const std::string& type) const
 */
 void Library_State::add_allocator(Allocator* allocator)
    {
-   Mutex_Holder lock(allocator_lock);
+   std::lock_guard<std::mutex> lock(allocator_lock);
 
    allocator->init();
 
@@ -147,11 +127,11 @@ void Library_State::add_allocator(Allocator* allocator)
 */
 void Library_State::set_default_allocator(const std::string& type)
    {
-   Mutex_Holder lock(allocator_lock);
-
    if(type == "")
       return;
 
+   std::lock_guard<std::mutex> lock(allocator_lock);
+
    this->set("conf", "base/default_allocator", type);
    cached_default_allocator = 0;
    }
@@ -160,9 +140,9 @@ void Library_State::set_default_allocator(const std::string& type)
 * Get a configuration value
 */
 std::string Library_State::get(const std::string& section,
-                               const std::string& key) const
+                               const std::string& key)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    return search_map<std::string, std::string>(config,
                                                section + "/" + key, "");
@@ -172,9 +152,9 @@ std::string Library_State::get(const std::string& section,
 * See if a particular option has been set
 */
 bool Library_State::is_set(const std::string& section,
-                           const std::string& key) const
+                           const std::string& key)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    return search_map(config, section + "/" + key, false, true);
    }
@@ -185,12 +165,11 @@ bool Library_State::is_set(const std::string& section,
 void Library_State::set(const std::string& section, const std::string& key,
                         const std::string& value, bool overwrite)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    std::string full_key = section + "/" + key;
 
-   std::map<std::string, std::string>::const_iterator i =
-      config.find(full_key);
+   auto i = config.find(full_key);
 
    if(overwrite || i == config.end() || i->second == "")
       config[full_key] = value;
@@ -207,7 +186,7 @@ void Library_State::add_alias(const std::string& key, const std::string& value)
 /*
 * Dereference an alias to a fixed name
 */
-std::string Library_State::deref_alias(const std::string& key) const
+std::string Library_State::deref_alias(const std::string& key)
    {
    std::string result = key;
    while(is_set("alias", result))
@@ -227,7 +206,7 @@ void Library_State::set_option(const std::string& key,
 /*
 * Get an option value
 */
-std::string Library_State::option(const std::string& key) const
+std::string Library_State::option(const std::string& key)
    {
    return get("conf", key);
    }
@@ -245,73 +224,54 @@ Algorithm_Factory& Library_State::algorithm_factory()
 /*
 * Load a set of modules
 */
-void Library_State::initialize(bool thread_safe)
+void Library_State::initialize()
    {
-   if(mutex_factory)
+   if(m_algorithm_factory)
       throw Invalid_State("Library_State has already been initialized");
 
-   if(!thread_safe)
-      {
-      mutex_factory = new Noop_Mutex_Factory;
-      }
-   else
-      {
-#if defined(BOTAN_HAS_MUTEX_PTHREAD)
-      mutex_factory = new Pthread_Mutex_Factory;
-#elif defined(BOTAN_HAS_MUTEX_WIN32)
-      mutex_factory = new Win32_Mutex_Factory;
-#elif defined(BOTAN_HAS_MUTEX_QT)
-      mutex_factory Qt_Mutex_Factory;
-#else
-      throw Invalid_State("Could not find a thread-safe mutex object to use");
-#endif
-      }
-
-   allocator_lock = mutex_factory->make();
-   config_lock = mutex_factory->make();
-
    cached_default_allocator = 0;
 
    add_allocator(new Malloc_Allocator);
-   add_allocator(new Locking_Allocator(mutex_factory->make()));
+   add_allocator(new Locking_Allocator);
 
 #if defined(BOTAN_HAS_ALLOC_MMAP)
-   add_allocator(new MemoryMapping_Allocator(mutex_factory->make()));
+   add_allocator(new MemoryMapping_Allocator);
 #endif
 
    set_default_allocator("locking");
 
    load_default_config();
 
-   std::vector<Engine*> engines;
+   std::vector<Engine*> engines = {
 
 #if defined(BOTAN_HAS_ENGINE_GNU_MP)
-   engines.push_back(new GMP_Engine);
+      new GMP_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_OPENSSL)
-   engines.push_back(new OpenSSL_Engine);
+      new OpenSSL_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_AES_ISA)
-   engines.push_back(new AES_ISA_Engine);
+   new AES_ISA_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_SIMD)
-   engines.push_back(new SIMD_Engine);
+      new SIMD_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_AMD64_ASSEMBLER)
-   engines.push_back(new AMD64_Assembler_Engine);
+      new AMD64_Assembler_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_IA32_ASSEMBLER)
-   engines.push_back(new IA32_Assembler_Engine);
+      new IA32_Assembler_Engine,
 #endif
 
-   engines.push_back(new Default_Engine);
+      new Default_Engine
+   };
 
-   m_algorithm_factory = new Algorithm_Factory(engines, *mutex_factory);
+   m_algorithm_factory = new Algorithm_Factory(engines);
 
    if(!passes_self_tests(algorithm_factory()))
       throw Self_Test_Failure("Startup self tests failed");
@@ -322,8 +282,6 @@ void Library_State::initialize(bool thread_safe)
 */
 Library_State::Library_State()
    {
-   mutex_factory = 0;
-   allocator_lock = config_lock = 0;
    cached_default_allocator = 0;
    m_algorithm_factory = 0;
    }
@@ -334,6 +292,7 @@ Library_State::Library_State()
 Library_State::~Library_State()
    {
    delete m_algorithm_factory;
+   m_algorithm_factory = 0;
 
    cached_default_allocator = 0;
 
@@ -342,10 +301,6 @@ Library_State::~Library_State()
       allocators[j]->destroy();
       delete allocators[j];
       }
-
-   delete allocator_lock;
-   delete mutex_factory;
-   delete config_lock;
    }
 
 }
diff --git a/src/libstate/libstate.h b/src/libstate/libstate.h
index a0421953e..e9a08b74b 100644
--- a/src/libstate/libstate.h
+++ b/src/libstate/libstate.h
@@ -12,6 +12,7 @@
 #include <botan/allocate.h>
 #include <botan/algo_factory.h>
 
+#include <mutex>
 #include <string>
 #include <vector>
 #include <map>
@@ -27,11 +28,14 @@ class BOTAN_DLL Library_State
       Library_State();
       ~Library_State();
 
-      void initialize(bool thread_safe);
+      Library_State(const Library_State&) = delete;
+      Library_State& operator=(const Library_State&) = delete;
+
+      void initialize();
 
       Algorithm_Factory& algorithm_factory();
 
-      Allocator* get_allocator(const std::string& = "") const;
+      Allocator* get_allocator(const std::string& = "");
       void add_allocator(Allocator*);
       void set_default_allocator(const std::string&);
 
@@ -42,7 +46,7 @@ class BOTAN_DLL Library_State
       * @result the value of the parameter
       */
       std::string get(const std::string& section,
-                      const std::string& key) const;
+                      const std::string& key);
 
       /**
       * Check whether a certain parameter is set
@@ -52,7 +56,7 @@ class BOTAN_DLL Library_State
       * @result true if the parameters value is set,
       * false otherwise
       */
-      bool is_set(const std::string& section, const std::string& key) const;
+      bool is_set(const std::string& section, const std::string& key);
 
       /**
       * Set a configuration parameter.
@@ -70,7 +74,7 @@ class BOTAN_DLL Library_State
       * referred to as option).
       * @param key the desired keys name
       */
-      std::string option(const std::string& key) const;
+      std::string option(const std::string& key);
 
       /**
       * Set an option.
@@ -91,21 +95,14 @@ class BOTAN_DLL Library_State
       * @param alias the alias to resolve.
       * @return what the alias stands for
       */
-      std::string deref_alias(const std::string&) const;
-
-      class Mutex* get_mutex() const;
+      std::string deref_alias(const std::string&);
    private:
       void load_default_config();
 
-      Library_State(const Library_State&) {}
-      Library_State& operator=(const Library_State&) { return (*this); }
-
-      class Mutex_Factory* mutex_factory;
-
+      std::mutex config_lock;
       std::map<std::string, std::string> config;
-      class Mutex* config_lock;
 
-      class Mutex* allocator_lock;
+      std::mutex allocator_lock;
       std::map<std::string, Allocator*> alloc_factory;
       mutable Allocator* cached_default_allocator;
       std::vector<Allocator*> allocators;