merging in ENGINE-781

Adapter.cc

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include "status_to_string.hh"
 #include "pEpLog.hh"
+#include "passphrase_cache.hh"
 
 using namespace std;
 
@@ -82,6 +83,11 @@ namespace pEp {
             return 0;
         }
 
+        PEP_STATUS _ensure_passphrase(PEP_SESSION session, const char *fpr)
+        {
+            return passphrase_cache.ensure_passphrase(session, fpr);
+        }
+
         // threshold: max waiting time in seconds
         SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold)
         {
@@ -120,7 +126,7 @@ namespace pEp {
 
                 case init:
                     if (!_session)
-                        status = ::init(&_session, _messageToSend, _inject_sync_event);
+                        status = ::init(&_session, _messageToSend, _inject_sync_event, _ensure_passphrase);
                     break;
 
                 default:

Adapter.hh

@@ -24,6 +24,7 @@ namespace pEp {
 
     namespace Adapter {
         int _inject_sync_event(SYNC_EVENT ev, void *management);
+        PEP_STATUS _ensure_passphrase(PEP_SESSION session, const char *fpr);
 
         template<class T = void>
         void startup(

Makefile

@@ -28,8 +28,6 @@ DEPENDS=$(subst .cc,.d,$(SOURCE))
 
 all: $(TARGET)
 
--include Makefile.protocols
-
 %.d: %.cc
 	@set -e; rm -f $@; \
 	$(CXX) -MM $(CPPFLAGS) $(CXXFLAGS) $< > $@.$$$$; \

Makefile.conf

@@ -6,8 +6,8 @@
 HERE:=$(dir $(lastword $(MAKEFILE_LIST)))
 
 
-PREFIX=$(HOME)
-CXXFLAGS=-std=c++11 -fPIC -O0 $(ENGINE_INC)
+PREFIX?=$(HOME)
+CXXFLAGS+=-std=c++11 -fPIC -O0
 
 # Build target
 BUILD_FOR:=$(shell uname)
@@ -29,8 +29,8 @@ else
 endif
 
 ######### Engine #########
-ENGINE_LIB_PATH=$(HOME)/lib
-ENGINE_INC_PATH=$(HOME)/include
+ENGINE_LIB_PATH=$(PREFIX)/lib
+ENGINE_INC_PATH=$(PREFIX)/include
 
 ######### Overrides #########
 -include $(HERE)/local.conf
@@ -47,3 +47,9 @@ endif
 ifdef BUILD_CONFIG
     include $(BUILD_CONFIG)
 endif
+
+ifndef ENGINE_TEST
+	ENGINE_TEST = \"$(HOME)/dev/pEpEngine/test\"
+endif
+
+CXXFLAGS += $(ENGINE_INC)

passphrase_cache.cc

@@ -153,5 +153,21 @@ namespace pEp {
             return PEP_WRONG_PASSPHRASE;
         }
 	}
+
+    PEP_STATUS PassphraseCache::ensure_passphrase(PEP_SESSION session, std::string fpr)
+    {
+        PEP_STATUS status;
+
+        for_each_passphrase([&](std::string passphrase) {
+            status = ::config_passphrase(session, passphrase.c_str());
+            if (status)
+                return true;
+
+            status = ::probe_encrypt(session, fpr.c_str());
+            return status == PEP_STATUS_OK;
+        });
+
+        return status;
+    }
 };
 

passphrase_cache.hh

@@ -73,6 +73,7 @@ namespace pEp {
         static const char *latest_passphrase(PassphraseCache& _cache);
         using passphrase_callee = std::function<bool(std::string)>;
         bool for_each_passphrase(const passphrase_callee& callee);
+        PEP_STATUS ensure_passphrase(PEP_SESSION session, std::string fpr);
 
     protected:
         void cleanup();

passphrase_cache.hxx

@@ -1,4 +1,3 @@
-#pragma once
 #include "passphrase_cache.hh"
 
 namespace pEp {

test/Makefile

@@ -2,28 +2,15 @@ include ../Makefile.conf
 
 LDFLAGS=-L../ $(ENGINE_LIB)
 LDLIBS=-lstdc++ -lpEpEngine -lpEpAdapter
-CXXFLAGS+=-I../
+CXXFLAGS+=-I../ $(ENGINE_INC) -std=c++11 -DENGINE_TEST=$(ENGINE_TEST)
 
-.PHONY=all, test_adapter, test_adapter_cxx, test_library
+SRC=$(wildcard test_*.cc)
+TST=$(subst .cc,,$(SRC))
 
-all: test_adapter test_adapter_cxx test_library test_passphrase_cache test_semaphore test_message_cache
+all: $(TST)
 
-test_adapter: test_adapter.cc ../libpEpAdapter.a
-
-test_adapter_cxx: test_adapter_cxx.cc ../libpEpAdapter.a
-
-test_library: test_library.cc ../libpEpAdapter.a
-
-test_passphrase_cache: test_passphrase_cache.cc ../libpEpAdapter.a
-
-test_semaphore: test_semaphore.cc ../libpEpAdapter.a
-
-test_message_cache: test_message_cache.cc ../libpEpAdapter.a
+%: %.cc ../libpEpAdapter.a
 
 clean:	
-	rm -vf test_adapter
-	rm -rvf test_adapter.dSYM
-	rm -vf test_adapter_cxx
-	rm -rvf test_adapter_cxx.dSYM
-	rm -vf test_library
-	rm -rvf test_library.dSYM
+	rm -f $(TST)
+	rm -Rf *.dSYM

test/test_adapter.cc

@@ -5,6 +5,7 @@
 #include <iostream>
 #include <assert.h>
 #include <unistd.h>
+#include <sys/param.h>
 #include <pEp/keymanagement.h>
 #include "pEpLog.hh"
 
@@ -25,6 +26,15 @@ PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handsha
 
 int main()
 {
+    char path[MAXPATHLEN+1];
+    const char *templ = "/tmp/test_adapter.XXXXXXXXXXXX";
+    strcpy(path, templ);
+    char *tmpdir = mkdtemp(path);
+    assert(tmpdir);
+    chdir(tmpdir);
+    setenv("HOME", path, 1);
+    cerr << "test directory: " << path << endl;
+
     // Create new identity
     pEpLog("updating or creating identity for me");
     pEp_identity *me = new_identity("alice@peptest.ch", NULL, "23", "Who the F* is Alice");

test/test_ensure_passphrase.cc

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <unistd.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+
+#include "Adapter.hh"
+#include "passphrase_cache.hh"
+#include "status_to_string.hh"
+
+#include <pEp/message_api.h>
+#include <pEp/keymanagement.h>
+#include <pEp/key_reset.h>
+
+using namespace pEp;
+using namespace pEp::Adapter;
+using namespace std;
+
+void import_key_from_file(string filename)
+{
+    ifstream f(filename, ifstream::in);
+    string key{istreambuf_iterator<char>(f), istreambuf_iterator<char>()};
+    ::identity_list *il = NULL;
+    PEP_STATUS status = ::import_key(session(), key.c_str(), key.length(), &il);
+    assert(status == PEP_KEY_IMPORTED);
+    ::free_identity_list(il);
+}
+
+void test()
+{
+    passphrase_cache.add("erwin");
+    passphrase_cache.add("cathy");
+    passphrase_cache.add("bob");
+
+    const char* bob_filename = ENGINE_TEST "/test_keys/bob-primary-with-password-bob-subkey-without.pgp";
+    const char* bob_fpr = "5C76378A62B04CF3F41BEC8D4940FC9FA1878736";
+
+    const char* erwin_filename = ENGINE_TEST "/test_keys/erwin_normal_encrypted.pgp";
+    const char* erwin_fpr = "CBA968BC01FCEB89F04CCF155C5E9E3F0420A570";
+
+    import_key_from_file(bob_filename);
+    import_key_from_file(erwin_filename);
+
+    pEp_identity* bob = ::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog");
+    PEP_STATUS status = ::set_own_key(session(), bob, bob_fpr);
+    assert(status == PEP_STATUS_OK);
+
+    pEp_identity* erwin = ::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin");
+    status = ::set_own_key(session(), erwin, erwin_fpr);
+    assert(status == PEP_STATUS_OK);
+
+    status = ::key_reset_all_own_keys(session());
+    assert(status == PEP_STATUS_OK);
+
+    ::free_identity(bob);
+    ::free_identity(erwin);
+
+    session(Adapter::release);
+}
+
+int main()
+{
+    char path[MAXPATHLEN+1];
+    const char *templ = "/tmp/test_ensure_passphrase.XXXXXXXXXXXX";
+    strcpy(path, templ);
+    char *tmpdir = mkdtemp(path);
+    assert(tmpdir);
+    chdir(tmpdir);
+    setenv("HOME", path, 1);
+    cerr << "test directory: " << path << endl;
+
+    test();
+    return 0;
+}
+

test/test_library.cc

@@ -1,6 +1,3 @@
-// small unittest program for libpEpAdapter
-// TODO: use Gtest or the like for more modular unit tests!
-
 #include "pc_container.hh"
 #include <cstdio>
 #include <cstdlib>

test/test_message_cache.cc

@@ -1,18 +1,26 @@
 #include <iostream>
 #include <cassert>
+#include <sys/param.h>
+#include <unistd.h>
 #include "message_cache.hh"
+#include "Adapter.hh"
 
 using namespace std;
 using namespace pEp;
 
 int main()
 {
-    PEP_SESSION session;
-    PEP_STATUS status = ::init(&session, nullptr, nullptr);
-    assert(status == PEP_STATUS_OK);
+    char path[MAXPATHLEN+1];
+    const char *templ = "/tmp/test_message_cache.XXXXXXXXXXXX";
+    strcpy(path, templ);
+    char *tmpdir = mkdtemp(path);
+    assert(tmpdir);
+    chdir(tmpdir);
+    setenv("HOME", path, 1);
+    cerr << "test directory: " << path << endl;
 
     pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice");
-    ::myself(session, alice);
+    ::myself(pEp::Adapter::session(), alice);
 
     char *mime = strdup("From: Alice <alice@mail.com>\n"
                         "To: Bob <bob@mail.com>\n"
@@ -24,20 +32,20 @@ int main()
 
     ::message *src = nullptr;
     bool has_possible_pEp_msg;
-    status = MessageCache::cache_mime_decode_message(mime, strlen(mime), &src, &has_possible_pEp_msg);
+    PEP_STATUS status = MessageCache::cache_mime_decode_message(mime, strlen(mime), &src, &has_possible_pEp_msg);
     assert(status == PEP_STATUS_OK);
 
-    status = ::myself(session, src->from);
+    status = ::myself(pEp::Adapter::session(), src->from);
     assert(status == PEP_STATUS_OK);
 
-    ::update_identity(session, src->to->ident);
+    ::update_identity(pEp::Adapter::session(), src->to->ident);
     assert(status == PEP_STATUS_OK);
 
     pEp_identity *bob = identity_dup(src->to->ident);
 
     src->dir = PEP_dir_outgoing;
     ::message *dst = nullptr;
-    status = MessageCache::cache_encrypt_message(session, src, nullptr, &dst, PEP_enc_PEP, 0);
+    status = MessageCache::cache_encrypt_message(pEp::Adapter::session(), src, nullptr, &dst, PEP_enc_PEP, 0);
     assert(status != PEP_ILLEGAL_VALUE);
 
     assert(src->longmsg == nullptr);
@@ -68,7 +76,7 @@ int main()
     PEP_decrypt_flags_t flags = 0;
     stringlist_t *keylist = nullptr;
 
-    status = MessageCache::cache_decrypt_message(session, src, &dst, &keylist, &rating, &flags);
+    status = MessageCache::cache_decrypt_message(pEp::Adapter::session(), src, &dst, &keylist, &rating, &flags);
     assert(status != PEP_ILLEGAL_VALUE);
 
     assert(src->longmsg == nullptr);
@@ -90,7 +98,8 @@ int main()
     ::free_message(dst);
     ::free_identity(bob);
     ::free_identity(alice);
-    ::release(session);
+
+    pEp::Adapter::session(pEp::Adapter::release);
     return 0;
 }
 

test/test_passphrase_cache.cc

@@ -1,7 +1,9 @@
 #include <iostream>
 #include <unistd.h>
 #include <assert.h>
+#include <sys/param.h>
 
+#include "Adapter.hh"
 #include "passphrase_cache.hh"
 #include "status_to_string.hh"
 
@@ -21,10 +23,14 @@ extern "C" {
 
 int main()
 {
-    PEP_SESSION session;
-    PEP_STATUS status = ::init(&session, NULL, NULL);
-    assert(status == PEP_STATUS_OK);
-    assert(session);
+    char path[MAXPATHLEN+1];
+    const char *templ = "/tmp/test_passphrase_cache.XXXXXXXXXXXX";
+    strcpy(path, templ);
+    char *tmpdir = mkdtemp(path);
+    assert(tmpdir);
+    chdir(tmpdir);
+    setenv("HOME", path, 1);
+    std::cerr << "test directory: " << path << std::endl;
 
     const char *str = "23";
     char *bytes = NULL;
@@ -45,9 +51,9 @@ int main()
     std::cout << "expected: two passphrases but reverse order\n";
     cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return false;});
 
-    status = cache.api(api_test1, session, "23", bytes, n, (::stringlist_t *) NULL);
+    PEP_STATUS status = cache.api(api_test1, pEp::Adapter::session(), "23", bytes, n, (::stringlist_t *) NULL);
     assert(status == PEP_WRONG_PASSPHRASE);
-    status = cache.api(api_test2, session, n, str, bytes, sl);
+    status = cache.api(api_test2, pEp::Adapter::session(), n, str, bytes, sl);
     assert(status == PEP_STATUS_OK);
 
     cache.add("hello");
@@ -74,12 +80,12 @@ int main()
     std::cout << "expected: no passphrase\n";
     cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return false;});
 
-    status = cache.api(api_test1, session, str, bytes, n, sl);
+    status = cache.api(api_test1, pEp::Adapter::session(), str, bytes, n, sl);
     assert(status == PEP_WRONG_PASSPHRASE);
-    status = cache.api(api_test2, session, 23, str, bytes, sl);
+    status = cache.api(api_test2, pEp::Adapter::session(), 23, str, bytes, sl);
     assert(status == PEP_STATUS_OK);
 
-    ::release(session);
+    pEp::Adapter::session(pEp::Adapter::release);
     return 0;
 }