...

passphrase_cache.cc

@@ -2,20 +2,29 @@
 #include "passphrase_cache.hh"
 
 namespace pEp {
+    PassphraseCache::cache_entry::cache_entry(std::string p, time_point t) :
+            passphrase{p, 0, PassphraseCache::cache_entry::max_len}, tp{t}
+    { }
+
     PassphraseCache::PassphraseCache(int max_size, duration timeout) :
-            _max_size(max_size), _timeout(timeout), _which(_cache.end())
+            _max_size{max_size}, _timeout{timeout}, _which{_cache.end()}
     { }
 
     PassphraseCache::PassphraseCache(const PassphraseCache& second) :
-            _cache(second._cache), _max_size(second._max_size),
-            _timeout(second._timeout), _which(_cache.end())
+            _cache{second._cache}, _max_size{second._max_size},
+            _timeout{second._timeout}, _which{_cache.end()}
     {
         cleanup();
     }
 
-    PassphraseCache PassphraseCache::operator=(const PassphraseCache& second)
+    PassphraseCache& PassphraseCache::operator=(const PassphraseCache& second)
     {
-        return second;
+        _cache = second._cache;
+        _max_size = second._max_size;
+        _timeout = second._timeout;
+        _which = _cache.end();
+        cleanup();
+        return *this;
     }
 
     const char *PassphraseCache::add(std::string passphrase)
@@ -88,10 +97,11 @@ namespace pEp {
         static bool new_copy = true;
         if (new_copy) {
             _copy = cache;
+            assert(_copy._cache.size() == cache._cache.size());
             new_copy = false;
         }
         try {
-            ::config_passphrase(session, _copy.latest_passphrase());
+            ::config_passphrase(session, cache.latest_passphrase());
             return PEP_STATUS_OK;
         }
         catch (pEp::PassphraseCache::Empty&) {

passphrase_cache.hh

@@ -16,8 +16,7 @@ namespace pEp {
 
         struct cache_entry {
             static const size_t max_len = 250 * 4;
-            cache_entry(std::string p, time_point t) :
-                passphrase(p, 0, max_len), tp(t) { }
+            cache_entry(std::string p, time_point t);
 
             std::string passphrase;
             time_point tp;
@@ -42,7 +41,7 @@ namespace pEp {
         PassphraseCache(int max_size=20, duration timeout = std::chrono::minutes(10));
         ~PassphraseCache() { }
         PassphraseCache(const PassphraseCache& second);
-        PassphraseCache operator=(const PassphraseCache& second);
+        PassphraseCache& operator=(const PassphraseCache& second);
 
         // adding a passphrase to the cache, which will timeout
 

test/test_passphrase_cache.cc

@@ -49,8 +49,9 @@ int main()
     status = cache.api(api_test2, session, n, str, bytes, sl);
     assert(status == PEP_STATUS_OK);
 
-    std::cout << "expected: two passphrases in order\n";
-
+    cache.add("hello");
+    cache.add("world");
+    std::cout << "expected: two passphrases in reverse order\n";
     pEp::PassphraseCache _cache = cache;
     try {
         while (1) {
@@ -59,6 +60,12 @@ int main()
     }
     catch (std::underflow_error&) { }
 
+    std::cout << "two times PEP_STATUS_OK (0), one time PEP_WRONG_PASSPHRASE (2561) \n";
+    do {
+        status = pEp::PassphraseCache::messageToSend(cache, session);
+        std::cout << status << "\n";
+    } while (status == PEP_STATUS_OK);
+
     sleep(2);
 
     std::cout << "expected: no passphrase\n";