.clang-format

+BasedOnStyle: LLVM
+Language: Cpp
+Standard: c++14
+DerivePointerAlignment: true
+SortIncludes: false
+ReflowComments: false
+PointerAlignment: Left
+AlignAfterOpenBracket: AlwaysBreak
+AlignOperands: AlignAfterOperator
+BreakConstructorInitializers: AfterColon
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+ExperimentalAutoDetectBinPacking: true
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterFunction: true
+ColumnLimit: 100
+AllowAllConstructorInitializersOnNextLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+PenaltyBreakBeforeFirstCallParameter: 0
+PenaltyReturnTypeOnItsOwnLine: 1000000
+PenaltyBreakAssignment: 1000000
+PenaltyExcessCharacter: 10
+IndentCaseLabels: true
+IndentWidth: 4
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+SpaceAfterTemplateKeyword: false
+AccessModifierOffset: -4
+AllowShortBlocksOnASingleLine: Always
+IndentPPDirectives: BeforeHash
+Cpp11BracedListStyle: false
\ No newline at end of file

DEPENDENCIES

 # 1st Party Dependencies
 ## Prefer git tags instead of SHA hashes when possible.
 
-pEpEngine=Release_2.1.18
+pEpEngine=Release_2.1.23
 sequoia=365d00a08bec6a5a48d48a7c7893d78c27092b59

Makefile

@@ -3,45 +3,22 @@
 # This file may be used under the terms of the GNU General Public License version 3
 # see LICENSE.txt
 
-include Makefile.conf
+.PHONY: src test install uninstall clean
 
-TARGET=libpEpAdapter.a
+all: src
 
-.PHONY: install uninstall clean
+src:
+	$(MAKE) -C src
 
-SOURCE=$(wildcard *.cc)
-HEADERS=$(wildcard *.hh *.hxx)
-OBJECTS=$(subst .cc,.o,$(SOURCE))
-DEPENDS=$(subst .cc,.d,$(SOURCE))
-CXXFLAGS+= -MMD -MP
-
-all: $(TARGET)
-
-ifneq ($(MAKECMDGOALS),clean)
-    -include $(DEPENDS)
-endif
-
-lib: $(TARGET)
-
-all: lib
-
-test: lib
+test: src
 	$(MAKE) -C test
 
-$(TARGET): $(OBJECTS)
-	$(AR) -rc $@ $^
-
 clean:
-	rm -vf $(TARGET) $(OBJECTS) $(DEPENDS)
-	rm -f *.d.*
+	$(MAKE) -C src clean
 	$(MAKE) -C test clean
 
-install: $(TARGET)
-	mkdir -p $(PREFIX)/include/pEp
-	mkdir -p $(PREFIX)/lib
-	cp -v $(HEADERS) $(PREFIX)/include/pEp/
-	cp -v $(TARGET) $(PREFIX)/lib/
+install:
+	$(MAKE) -C src install
 
 uninstall:
-	cd $(PREFIX)/include/pEp && rm -vf $(HEADERS)
-	cd $(PREFIX)/lib && rm -vf $(TARGET)
+	$(MAKE) -C src uninstall
\ No newline at end of file

Makefile.conf

@@ -5,6 +5,7 @@
 
 HERE:=$(dir $(lastword $(MAKEFILE_LIST)))
 
+TARGET=libpEpAdapter.a
 
 # Defaults
 DEBUG=1
@@ -12,7 +13,7 @@ PREFIX?=$(HOME)
 ENGINE_LIB_PATH=$(PREFIX)/lib
 ENGINE_INC_PATH=$(PREFIX)/include
 
-CXXFLAGS+=-std=c++11 -fPIC
+CXXFLAGS+=-std=c++14 -fPIC
 
 # Build target
 BUILD_FOR:=$(shell uname)

adapter_group.cc

+// This file is under GNU General Public License 3.0
+// see LICENSE.txt
+#include <pEp/group.h>
+#include "adapter_group.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*************************************************************************************************
+* Group management functions
+*************************************************************************************************/
+
+DYNAMIC_API PEP_STATUS adapter_group_create(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager,
+        member_list *memberlist,
+        pEp_group **group
+)
+{
+    return ::group_create(session, group_identity, manager, memberlist, group);
+}
+
+DYNAMIC_API PEP_STATUS adapter_group_join(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *as_member
+)
+{
+    return ::group_join(session, group_identity, as_member);
+}
+
+DYNAMIC_API PEP_STATUS adapter_group_dissolve(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager
+)
+{
+    return ::group_dissolve(session, group_identity, manager);
+}
+
+DYNAMIC_API PEP_STATUS adapter_group_invite_member(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *group_member
+)
+{
+    return ::group_invite_member(session, group_identity, group_member);
+}
+
+PEP_STATUS adapter_group_remove_member(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *group_member
+)
+{
+    return ::group_remove_member(session, group_identity, group_member);
+}
+
+DYNAMIC_API PEP_STATUS adapter_group_rating(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager,
+        PEP_rating *rating
+)
+{
+    return ::group_rating(session, group_identity, manager, rating);
+}
+
+/*************************************************************************************************
+ * Group query functions
+ *************************************************************************************************/
+
+
+DYNAMIC_API PEP_STATUS group_query_groups(
+        PEP_SESSION session,
+        identity_list **groups
+)
+{
+    return PEP_STATUS_OK;
+}
+
+DYNAMIC_API PEP_STATUS group_query_manager(
+        PEP_SESSION session,
+        const pEp_identity *const group,
+        pEp_identity **manager
+)
+{
+    return PEP_STATUS_OK;
+}
+
+DYNAMIC_API PEP_STATUS group_query_members(
+        PEP_SESSION session,
+        const pEp_identity *const group,
+        identity_list **members
+)
+{
+    return PEP_STATUS_OK;
+}
+
+#ifdef __cplusplus
+}
+#endif
+

adapter_group.h

+// This file is under GNU General Public License 3.0
+// see LICENSE.txt
+
+#ifndef LIBPEPADAPTER_GROUP_HH
+#define LIBPEPADAPTER_GROUP_HH
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************************************
+ * Group management functions
+ *************************************************************************************************/
+
+/**
+ *  <!--       adapter_group_create()       -->
+ *
+ *  @brief      Create a group in the database with the input group_identity and manager and invite new members to the group
+ *              if this is an own group (for the external API, this is always the case).
+ *
+ *              This function sets up the actual database structures for a group and invites new members to the group.
+ *
+ *              For the external API, it is used when creating an own group. The group is represented by the
+ *              incoming group_identity, which contains the user_id and address for the group.
+ *              If no key is present for the former, it will be generated - if there is already
+ *              a default key for the group_identity in the database, that will be used instead.
+ *              The manager
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      manager             the pEp_identity object representing the group's manager. Must contain
+ *                                      a user_id and address, and there must be a default key for the manager
+ *                                      present in the database
+ *  @param[in]      memberlist          list of group members
+ *  @param[in,out]  group               Optional reference for pointer to group object
+ *                                      representing the created group.
+ *                                      (When input is NULL, no object is created)
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ *  TODO: member_list *memberlist -> change to identity_list
+ *
+ */
+DYNAMIC_API PEP_STATUS adapter_group_create(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager,
+        member_list *memberlist,
+        pEp_group **group
+);
+
+/**
+ *  <!--       adapter_group_join()       -->
+ *
+ *  @brief          Join a group for which we have received an invitation, marking
+ *                  our own membership in the database for the group and sending the manager
+ *                  a confirmation of the acceptance of the invitation
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      as_member           the pEp_identity object representing the own identity we want to use to
+ *                                      join the group. This must match the identity which was invited to the group.
+ *                                      Must contain a user_id and address.
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ *
+ */
+DYNAMIC_API PEP_STATUS adapter_group_join(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *as_member
+);
+
+/**
+ *  <!--       adapter_group_dissolve()       -->
+ *
+ *  @brief          Dissolve a group, revoke its key, notify all members of the dissolution and
+ *                  revocation, and mark the group as inactive in the database
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      manager             the pEp_identity object representing the group's manager. Must contain
+ *                                      a user_id and address, and there must be a default key for the manager
+ *                                      present in the database
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ *  @warning        For recipients to accept the dissolution, the sender/manager key used must be a key that they
+ *                  have a trust entry for.
+ */
+DYNAMIC_API PEP_STATUS adapter_group_dissolve(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager
+);
+
+/**
+ *  <!--       adapter_group_invite_member()       -->
+ *
+ *  @brief      Invite a member to an extant group, marking the member as invited in the database and
+ *              sending out an invitation to said member
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      group_member        the pEp_identity object representing the member to invite. Must contain
+ *                                      a user_id and address, and there must be a default key for the member
+ *                                      present in the database
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ *  @note           This generates a GroupCreate message even though the group already exists - this is because
+ *                  this is the accepted message format for invitations to potential members
+ *
+ */
+DYNAMIC_API PEP_STATUS adapter_group_invite_member(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *group_member
+);
+
+/**
+ *  <!--       adapter_group_remove_member()       -->
+ *
+ *  @brief      Remove a member from a group, deleting the member from the member list and executing a key
+ *              reset on the group identity
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      group_member        the pEp_identity object representing the member to remove. Must contain
+ *                                      a user_id and address
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ *  @todo           Revamp implementation and execute key reset
+ *
+ */
+PEP_STATUS adapter_group_remove_member(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *group_member
+);
+
+/**
+ *  <!--       adapter_group_rating()       -->
+ *
+ *  @brief      Get the rating for this group - if the caller is the manager, this will return the aggregate rating
+ *              of group members. For members, this will return the rating of the group_identity
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group_identity      the pEp_identity object representing the group. Must contain at least
+ *                                      a user_id and address
+ *  @param[in]      manager             the pEp_identity object representing the member to remove. Must contain
+ *                                      a user_id and address
+ *  @param[out]     rating              the group rating
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      FIXME
+ *
+ */
+DYNAMIC_API PEP_STATUS adapter_group_rating(
+        PEP_SESSION session,
+        pEp_identity *group_identity,
+        pEp_identity *manager,
+        PEP_rating *rating
+);
+
+
+
+/*************************************************************************************************
+ * Group query functions
+ *************************************************************************************************/
+
+/**
+ *  <!--       group_query_groups()       -->
+ *
+ *  @brief          queries the list manager which groups currently exist.
+ *
+ *  @param[in]      session             associated session object
+ *  @param[out]     groups              list of pEp_identity representing
+ *                                      all group identities that currently exist.
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      ownership of all parameters goes to the caller
+ *
+ */
+
+DYNAMIC_API PEP_STATUS group_query_groups(
+        PEP_SESSION session,
+        identity_list **groups
+);
+
+/**
+ *  <!--       group_query_manager()       -->
+ *
+ *  @brief          queries the list manager for the group manager of a given group.
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group               pEp_Identity representing the group identity in question
+ *  @param[out]     manager             pEp_identity representing the group manager for "group"
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      ownership of all parameters goes to the caller
+ *
+ */
+
+DYNAMIC_API PEP_STATUS group_query_manager(
+        PEP_SESSION session,
+        const pEp_identity *const group,
+        pEp_identity **manager
+);
+
+/**
+ *  <!--       group_query_members()       -->
+ *
+ *  @brief          queries the list manager for all members of a given group.
+ *
+ *  @param[in]      session             associated session object
+ *  @param[in]      group               pEp_Identity representing the group identity in question
+ *  @param[out]     members             list of pEp_identity representing all the members of "group"
+ *
+ *  @retval         PEP_STATUS_OK       on success
+ *                  error               on failure
+ *
+ *  @ownership      ownership of all parameters goes to the caller
+ *
+ */
+
+DYNAMIC_API PEP_STATUS group_query_members(
+        PEP_SESSION session,
+        const pEp_identity *const group,
+        identity_list **members
+);
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  //LIBPEPADAPTER_GROUP_HH
\ No newline at end of file

call_with_lock.hh

-// This file is under GNU General Public License 3.0
-// see LICENSE.txt
-
-#ifndef LIBPEPADAPTER_CALL_WITH_LOCK_HH
-#define LIBPEPADAPTER_CALL_WITH_LOCK_HH
-
-#include <mutex>
-
-namespace pEp
-{
-	extern std::mutex call_with_lock_mutex;
-
-	// TODO: use && and std::forward<> to avoid copying of the arguments.
-	// It is not relevant, yet, because at the moment we use this function template only
-	// for init() and release() which have cheap-to-copy pointer parameters only
-	template<class R, class... Args>
-	R call_with_lock( R(*fn)(Args...), Args... args)
-	{
-		std::lock_guard<std::mutex> L(call_with_lock_mutex);
-		return fn(args...);
-	}
-
-
-}
-
-#endif // LIBPEPADAPTER_CALL_WITH_LOCK_HH

pEpLog.cc

-// This file is under GNU General Public License 3.0
-// see LICENSE.txt
-
-#include "pEpLog.hh"
-#include <iostream>
-#include <sstream>
-#include <mutex>
-#include <atomic>
-
-
-namespace pEp {
-namespace Adapter {
-namespace pEpLog {
-
-std::mutex mtx;
-
-std::atomic_bool is_enabled{false};
-
-void set_enabled(bool enabled) {
-    is_enabled.store(enabled);
-}
-
-bool get_enabled() {
-    return is_enabled.load();
-}
-
-void log(std::string msg) {
-    if (is_enabled.load()) {
-        std::lock_guard<std::mutex> l(mtx);
-    #ifdef ANDROID
-        __android_log_print(ANDROID_LOG_DEBUG, "pEpDebugLog", "%s", msg.c_str());
-    #else
-        std::cout << msg << std::endl; //std::endl also flushes
-    #endif
-    }
-}
-
-} // pEpLog
-} // Adapter
-} // pEp

Adapter.cc → src/Adapter.cc

@@ -14,87 +14,169 @@ using namespace std;
 thread_local pEp::Adapter::Session pEp::Adapter::session;
 
 namespace pEp {
-    void throw_status(PEP_STATUS status)
+    void throw_status(::PEP_STATUS status)
     {
-        if (status == PEP_STATUS_OK)
+        if (status == ::PEP_STATUS_OK) {
             return;
-        if (status >= 0x400 && status <= 0x4ff)
+        }
+        if (status >= 0x400 && status <= 0x4ff) {
             return;
-        if (status == PEP_STATEMACHINE_CANNOT_SEND)
+        }
+        if (status == ::PEP_STATEMACHINE_CANNOT_SEND) {
             return;
-        if (status == PEP_OUT_OF_MEMORY)
+        }
+        if (status == ::PEP_OUT_OF_MEMORY) {
             throw bad_alloc();
-        if (status == PEP_ILLEGAL_VALUE)
+        }
+        if (status == ::PEP_ILLEGAL_VALUE) {
             throw invalid_argument("illegal value");
+        }
 
-		string _status = status_to_string(status);
+        string _status = status_to_string(status);
         throw RuntimeError(_status, status);
     }
 
-    RuntimeError::RuntimeError(const std::string& _text, PEP_STATUS _status)
-        : std::runtime_error(_text.c_str()), text(_text),  status(_status)
+    RuntimeError::RuntimeError(const std::string &_text, ::PEP_STATUS _status)
+        : std::runtime_error(_text.c_str()), text(_text), status(_status)
     {
-
     }
 
     namespace Adapter {
-        messageToSend_t _messageToSend = nullptr;
-        notifyHandshake_t _notifyHandshake = nullptr;
+        // private
+        SyncModes _sync_mode = SyncModes::Async;
+        ::messageToSend_t _messageToSend = nullptr;
+        ::notifyHandshake_t _notifyHandshake = nullptr;
+        bool _adapter_manages_sync_thread = false;
+        ::inject_sync_event_t _inject_action = _queue_sync_event;
         std::thread _sync_thread;
+        ::utility::locked_queue<SYNC_EVENT, ::free_Sync_event> sync_evt_q;
+        std::mutex mut;
 
-        ::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > sync_evt_q;
-        std::mutex m;
-
+        // private
         std::thread::id sync_thread_id()
         {
             return _sync_thread.get_id();
         }
 
-        int _inject_sync_event(SYNC_EVENT ev, void *management)
+        // public
+        void sync_initialize(
+            SyncModes mode,
+            ::messageToSend_t messageToSend,
+            ::notifyHandshake_t notifyHandshake,
+            bool adapter_manages_sync_thread)
+        {
+            _messageToSend = messageToSend;
+            _notifyHandshake = notifyHandshake;
+            _adapter_manages_sync_thread = adapter_manages_sync_thread;
+            set_sync_mode(mode);
+            return;
+        }
+
+        // public
+        void set_sync_mode(SyncModes mode)
+        {
+//            std::lock_guard<mutex> lock(mut);
+            _sync_mode = mode;
+            if (_sync_mode == SyncModes::Sync) {
+                // init sesssion with inject_sync = process
+                // stop sync
+                session(release);
+                _inject_action = _process_sync_event;
+                session(init);
+                ::register_sync_callbacks(session(), nullptr, _notifyHandshake, _retrieve_next_sync_event);
+                if(!_adapter_manages_sync_thread) {
+                    shutdown();
+                } else {
+                    // The adapter need to shutdown sync thread
+                }
+            }
+            if (_sync_mode == SyncModes::Async) {
+                // init session with inject_sync = queue
+                // start sync thread
+                session(release);
+                _inject_action = _queue_sync_event;
+                session(init);
+                if(!_adapter_manages_sync_thread) {
+                    if (!is_sync_running()) {
+                        startup<void>(_messageToSend, _notifyHandshake, nullptr, nullptr);
+                    }
+                } else {
+                    // The adapter need to do sync thread start up
+                }
+            }
+            if (_sync_mode == SyncModes::Off) {
+                // init sesssion with inject_sync = null
+                // stop sync thread
+                if(!_adapter_manages_sync_thread) {
+                    shutdown();
+                } else {
+                    // Adapter needs to shutdown sync thread
+                }
+                session(release);
+                _inject_action = _queue_sync_event;
+                session(init);
+            }
+            return;
+        }
+
+        // private
+        int _process_sync_event(::SYNC_EVENT ev, void *management)
+        {
+            if (ev != nullptr) {
+                ::do_sync_protocol_step(session(), nullptr, ev);
+                return 0;
+            } else {
+                return 0;
+            }
+        }
+
+        // private
+        int _queue_sync_event(::SYNC_EVENT ev, void *management)
         {
             try {
                 if (ev == nullptr) {
                     sync_evt_q.clear();
                     sync_evt_q.push_back(ev);
-                }
-                else {
+                } else {
                     sync_evt_q.push_front(ev);
                 }
-            }
-            catch (exception&) {
+            } catch (exception &) {
                 return 1;
             }
             return 0;
         }
 
-        PEP_STATUS _ensure_passphrase(PEP_SESSION session, const char *fpr)
+        // private
+        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)
+        // public
+        ::SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold)
         {
-            SYNC_EVENT syncEvent = nullptr;
+            ::SYNC_EVENT syncEvent = nullptr;
             const bool success = sync_evt_q.try_pop_front(syncEvent, std::chrono::seconds(threshold));
 
             if (!success) {
-                return new_sync_timeout_event();
+                return ::new_sync_timeout_event();
             }
 
             return syncEvent;
         }
 
+        // public
         bool on_sync_thread()
         {
             return _sync_thread.get_id() == this_thread::get_id();
         }
 
-        PEP_SESSION Session::operator()(session_action action)
+        // public
+        ::PEP_SESSION Session::operator()(session_action action)
         {
-            std::lock_guard<mutex> lock(m);
+            std::lock_guard<mutex> lock(mut);
 
-            PEP_STATUS status = PEP_STATUS_OK;
+            ::PEP_STATUS status = ::PEP_STATUS_OK;
 
             switch (action) {
                 case release:
@@ -105,43 +187,49 @@ namespace pEp {
 
                 case init:
                     if (!_session.get()) {
-                        PEP_SESSION session_;
-                        status = ::init(&session_, _messageToSend, _inject_sync_event, _ensure_passphrase);
+                        ::PEP_SESSION session_;
+                        status = ::init(&session_, _messageToSend, _inject_action, _ensure_passphrase);
                         throw_status(status);
                         _session = SessionPtr{session_, ::release};
                     }
                     break;
-
                 default:
-                    status = PEP_ILLEGAL_VALUE;
+                    status = ::PEP_ILLEGAL_VALUE;
             }
 
             throw_status(status);
             return _session.get();
         }
 
+        // public
         void shutdown()
         {
-        	pEpLog("called");
+            pEpLog("called");
             if (_sync_thread.joinable()) {
-            	pEpLog("sync_is_running - injecting null event");
-                _inject_sync_event(nullptr, nullptr);
+                pEpLog("sync_is_running - injecting null event");
+                _queue_sync_event(nullptr, nullptr);
                 _sync_thread.join();
             }
         }
 
+        // public
         bool is_sync_running()
         {
-            return _sync_thread.joinable();
+            if(!_adapter_manages_sync_thread) {
+                return _sync_thread.joinable();
+            } else {
+                return false;
+            }
         }
 
+        // public
+        // Works even if adapter is managing sync thread, BUT must be using this queue
         bool in_shutdown()
         {
             SYNC_EVENT ev;
             try {
                 ev = sync_evt_q.back();
-            }
-            catch (std::underflow_error&) {
+            } catch (std::underflow_error &) {
                 return false;
             }
             if (ev) {
@@ -149,6 +237,6 @@ namespace pEp {
             } else {
                 return true;
             }
-       }
-    }
-}
+        }
+    } // namespace Adapter
+} // namespace pEp

Adapter.hh → src/Adapter.hh

@@ -5,10 +5,10 @@
 #define LIBPEPADAPTER_ADAPTER_HH
 
 #include <functional>
+#include <memory>
+#include <stdexcept>
 #include <string>
 #include <thread>
-#include <stdexcept>
-#include <memory>
 
 #include <pEp/sync_api.h>
 
@@ -17,26 +17,43 @@ namespace pEp {
     // throws std::bad_alloc if status==PEP_OUT_OF_MEMORY,
     // throws std::invalid_argument if status==PEP_ILLEGAL_VALUE,
     // throws RuntimeError when 'status' represents another exceptional value.
-    void throw_status(PEP_STATUS status);
+    void throw_status(::PEP_STATUS status);
 
     struct RuntimeError : std::runtime_error {
-        RuntimeError(const std::string& _text, PEP_STATUS _status);
+        RuntimeError(const std::string &_text, ::PEP_STATUS _status);
         std::string text;
-        PEP_STATUS status;
+        ::PEP_STATUS status;
     };
 
     namespace Adapter {
-        int _inject_sync_event(SYNC_EVENT ev, void *management);
-        PEP_STATUS _ensure_passphrase(PEP_SESSION session, const char *fpr);
+        // public
+        enum class SyncModes
+        {
+            Off,
+            Sync,
+            Async
+        };
+
+        void sync_initialize(
+            SyncModes mode,
+            ::messageToSend_t messageToSend,
+            ::notifyHandshake_t notifyHandshake,
+            bool adapter_manages_sync_thread);
+
+        void set_sync_mode(SyncModes mode);
+
+        int _queue_sync_event(::SYNC_EVENT ev, void *management);
+        int _process_sync_event(::SYNC_EVENT ev, void *management);
+
+        ::PEP_STATUS _ensure_passphrase(::PEP_SESSION session, const char *fpr);
 
         template<class T = void>
         void startup(
             messageToSend_t messageToSend,
             notifyHandshake_t notifyHandshake,
             T *obj = nullptr,
-            std::function< void (T *) > _startup = nullptr,
-            std::function< void (T *) > _shutdown = nullptr
-        );
+            std::function<void(T *)> _startup = nullptr,
+            std::function<void(T *)> _shutdown = nullptr);
 
         // returns 'true' when called from the "sync" thread, 'false' otherwise.
         bool on_sync_thread();
@@ -44,9 +61,10 @@ namespace pEp {
         // returns the thread id of the sync thread
         std::thread::id sync_thread_id();
 
-        enum session_action {
+        enum session_action
+        {
             init,
-            release
+            release,
         };
 
         class Session {
@@ -59,15 +77,15 @@ namespace pEp {
 
         extern thread_local Session session;
 
-        // injects a NULL event into sync_event_queue to denote sync thread to shutdown,
-        // and joins & removes the sync thread
+        // injects a NULL event into sync_event_queue to denote sync thread to
+        // shutdown, and joins & removes the sync thread
         void shutdown();
 
         bool is_sync_running();
         bool in_shutdown();
-    }
-}
+    } // namespace Adapter
+} // namespace pEp
 
 #include "Adapter.hxx"
 
-#endif  //LIBPEPADAPTER_ADAPTER_HH
+#endif // LIBPEPADAPTER_ADAPTER_HH
\ No newline at end of file

Adapter.hxx → src/Adapter.hxx

@@ -14,43 +14,63 @@ namespace pEp {
     namespace Adapter {
         using std::function;
 
-        extern messageToSend_t _messageToSend;
-        extern notifyHandshake_t _notifyHandshake;
+        extern ::messageToSend_t _messageToSend;
+        extern ::notifyHandshake_t _notifyHandshake;
         extern std::thread _sync_thread;
 
-        extern ::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > sync_evt_q;
-        extern std::mutex m;
+        extern ::utility::locked_queue<::SYNC_EVENT, ::free_Sync_event> sync_evt_q;
+        extern std::mutex mut;
 
-        SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold);
+        ::SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold);
 
         static std::exception_ptr _ex;
         static std::atomic_bool register_done{false};
 
-        template< class T >
-        void sync_thread(T *obj, function< void(T *) > _startup, function< void(T *) > _shutdown)
+        /*
+         * Sync Thread
+         * 1. Execute registered startup function
+         * 2. Create session for the sync thread (registers: messageToSend, inject_sync_event, ensure_passphrase)
+         * 3. register_sync_callbacks() (registers: _notifyHandshake, _retrieve_next_sync_event)
+         * 4. Enter Sync Event Dispatching Loop (do_sync_protocol())
+         * 5. unregister_sync_callbacks()
+         * 6. Release the session
+         * 7. Execute registered shutdown function
+         */
+        // private
+        template<class T>
+        void sync_thread(T *obj, function<void(T *)> _startup, function<void(T *)> _shutdown)
         {
             pEpLog("called");
             _ex = nullptr;
             assert(_messageToSend);
             assert(_notifyHandshake);
+
+            // 1. Execute registered startup function
             if (obj && _startup) {
                 _startup(obj);
             }
 
-            pEpLog("creating session");
+            pEpLog("creating session for the sync thread");
+            // 2. Create session for the sync thread
             session();
 
+            // 3. register_sync_callbacks()
             {
-                //TODO: Do we need to use a passphraseWrap here???
+                // TODO: Do we need to use a passphraseWrap here???
                 pEpLog("register_sync_callbacks()");
-                PEP_STATUS status = register_sync_callbacks(session(), nullptr,
-                    _notifyHandshake, _retrieve_next_sync_event);
+                ::PEP_STATUS status = ::register_sync_callbacks(
+                    session(),
+                    nullptr,
+                    _notifyHandshake,
+                    _retrieve_next_sync_event);
+
                 pEpLog("register_sync_callbacks() return:" << status);
+                // Convert status into exception and store it
+                // set register_done AFTER that
                 try {
                     throw_status(status);
                     register_done.store(true);
-                }
-                catch (...) {
+                } catch (...) {
                     _ex = std::current_exception();
                     register_done.store(true);
                     return;
@@ -58,24 +78,38 @@ namespace pEp {
             }
 
             pEpLog("sync protocol loop started");
-            do_sync_protocol(session(), (void *)obj);
+            // 4. Enter Sync Event Dispatching Loop (do_sync_protocol())
+            ::do_sync_protocol(session(), (void *)obj);
             pEpLog("sync protocol loop ended");
+
+            // 5. unregister_sync_callbacks()
             unregister_sync_callbacks(session());
 
+            // 6. Release the session
+            // TODO: Maybe do that AFTER shutdown?
             session(release);
 
+            // 7. Execute registered shutdown function
             if (obj && _shutdown) {
                 _shutdown(obj);
             }
         }
 
-        template< class T >
+        /*
+         * Sync Thread Startup
+         * 1. ensure session for the main thread (registers: messageToSend, _queue_sync_event, _ensure_passphrase)
+         * 2. Start the sync thread
+         * 3. Defer execution until sync thread register_sync_callbacks() has returned
+         * 4. Throw pending exception from the sync thread
+         */
+        // private
+        template<class T>
         void startup(
-            messageToSend_t messageToSend,
-            notifyHandshake_t notifyHandshake,
+            ::messageToSend_t messageToSend,
+            ::notifyHandshake_t notifyHandshake,
             T *obj,
-            function< void(T *) > _startup,
-            function< void(T *) > _shutdown)
+            function<void(T *)> _startup,
+            function<void(T *)> _shutdown)
         {
             pEpLog("called");
             if (messageToSend) {
@@ -85,26 +119,30 @@ namespace pEp {
             if (notifyHandshake) {
                 _notifyHandshake = notifyHandshake;
             }
-            pEpLog("creating session");
-            session();
+            pEpLog("ensure session for the main thread");
+            // 1. re-initialize session for the main thread (registers: messageToSend, _queue_sync_event, _ensure_passphrase)
+            session(release);
+            session(init);
 
             if (!_sync_thread.joinable()) {
                 register_done.store(false);
                 pEpLog("creating sync-thread");
-
+                // 2. Start the sync thread
                 _sync_thread = std::thread(sync_thread<T>, obj, _startup, _shutdown);
+                // 3. Defer execution until sync thread register_sync_callbacks() has returned
                 while (register_done.load() == false) {
                     pEpLog("waiting for sync-thread to init...");
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                 }
 
+                // 4. Throw pending exception from the sync thread
                 if (_ex) {
                     pEpLog("exception pending, rethrowing");
                     std::rethrow_exception(_ex);
                 }
             }
         }
-    }
-}
+    } // namespace Adapter
+} // namespace pEp
 
 #endif //LIBPEPADAPTER_ADAPTER_HXX
\ No newline at end of file

src/Makefile

+# Copyright 2018, pEp Foundation
+# This file is part of lib pEp Adapter
+# This file may be used under the terms of the GNU General Public License version 3
+# see LICENSE.txt
+
+include ../Makefile.conf
+
+SOURCE=$(wildcard *.cc)
+HEADERS=$(wildcard *.hh *.hxx)
+OBJECTS=$(subst .cc,.o,$(SOURCE))
+DEPENDS=$(subst .cc,.d,$(SOURCE))
+CXXFLAGS+= -MMD -MP
+
+ifneq ($(MAKECMDGOALS),clean)
+    -include $(DEPENDS)
+endif
+
+.PHONY: install uninstall clean
+
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(AR) -rc $@ $^
+
+clean:
+	rm -vf $(TARGET) $(OBJECTS) $(DEPENDS)
+	rm -f *.d.*
+
+install: $(TARGET)
+	mkdir -p $(PREFIX)/include/pEp
+	mkdir -p $(PREFIX)/lib
+	cp -v $(HEADERS) $(PREFIX)/include/pEp/
+	cp -v $(TARGET) $(PREFIX)/lib/
+
+uninstall:
+	cd $(PREFIX)/include/pEp && rm -vf $(HEADERS)
+	cd $(PREFIX)/lib && rm -vf $(TARGET)

Semaphore.hh → src/Semaphore.hh

@@ -19,7 +19,7 @@ namespace pEp {
         std::atomic_bool _stop;
 
     public:
-        Semaphore() : _stop(false) { }
+        Semaphore() : _stop(false) {}
 
         void stop()
         {
@@ -34,7 +34,7 @@ namespace pEp {
                 return;
             }
 
-            while(_stop.load()) {
+            while (_stop.load()) {
                 cv.wait(lock);
             }
         }
@@ -46,8 +46,6 @@ namespace pEp {
             cv.notify_all();
         }
     };
-}
+} // namespace pEp
 
 #endif // LIBPEPADAPTER_SEMAPHORE_HH
-
-

call_with_lock.cc → src/call_with_lock.cc

@@ -3,7 +3,6 @@
 
 #include "call_with_lock.hh"
 
-namespace pEp
-{
-	std::mutex call_with_lock_mutex;
+namespace pEp {
+    std::mutex call_with_lock_mutex;
 }

src/call_with_lock.hh

+// This file is under GNU General Public License 3.0
+// see LICENSE.txt
+
+#ifndef LIBPEPADAPTER_CALL_WITH_LOCK_HH
+#define LIBPEPADAPTER_CALL_WITH_LOCK_HH
+
+#include <mutex>
+
+namespace pEp {
+    extern std::mutex call_with_lock_mutex;
+
+    // TODO: use && and std::forward<> to avoid copying of the arguments.
+    // It is not relevant, yet, because at the moment we use this function
+    // template only for init() and release() which have cheap-to-copy pointer
+    // parameters only
+    template<class R, class... Args>
+    R call_with_lock(R (*fn)(Args...), Args... args)
+    {
+        std::lock_guard<std::mutex> L(call_with_lock_mutex);
+        return fn(args...);
+    }
+
+
+} // namespace pEp
+
+#endif // LIBPEPADAPTER_CALL_WITH_LOCK_HH

callback_dispatcher.cc → src/callback_dispatcher.cc

@@ -14,18 +14,19 @@ namespace pEp {
         return callback_dispatcher._messageToSend(msg);
     }
 
-    PEP_STATUS CallbackDispatcher::notifyHandshake(::pEp_identity *me,
-            ::pEp_identity *partner, ::sync_handshake_signal signal)
+    PEP_STATUS CallbackDispatcher::notifyHandshake(
+        ::pEp_identity *me,
+        ::pEp_identity *partner,
+        ::sync_handshake_signal signal)
     {
         return callback_dispatcher._notifyHandshake(me, partner, signal);
     }
 
     void CallbackDispatcher::add(
-            ::messageToSend_t messageToSend,
-            ::notifyHandshake_t notifyHandshake,
-            proc on_startup,
-            proc shutdown
-        )
+        ::messageToSend_t messageToSend,
+        ::notifyHandshake_t notifyHandshake,
+        proc on_startup,
+        proc shutdown)
     {
         assert(messageToSend);
         if (!messageToSend) {
@@ -77,10 +78,12 @@ namespace pEp {
         pEpLog("called");
         callback_dispatcher.semaphore.go();
 
-        pEp::Adapter::startup<CallbackDispatcher>(CallbackDispatcher::messageToSend,
-                CallbackDispatcher::notifyHandshake, &callback_dispatcher,
-                &CallbackDispatcher::on_startup,
-                &CallbackDispatcher::on_shutdown);
+        pEp::Adapter::startup<CallbackDispatcher>(
+            CallbackDispatcher::messageToSend,
+            CallbackDispatcher::notifyHandshake,
+            &callback_dispatcher,
+            &CallbackDispatcher::on_startup,
+            &CallbackDispatcher::on_shutdown);
 
         pEpLog("all targets signal: SYNC_NOTIFY_START");
         for (auto target : callback_dispatcher.targets) {
@@ -143,8 +146,10 @@ namespace pEp {
         return PEP_STATUS_OK;
     }
 
-    PEP_STATUS CallbackDispatcher::_notifyHandshake(::pEp_identity *me,
-            ::pEp_identity *partner, ::sync_handshake_signal signal)
+    PEP_STATUS CallbackDispatcher::_notifyHandshake(
+        ::pEp_identity *me,
+        ::pEp_identity *partner,
+        ::sync_handshake_signal signal)
     {
         for (auto target : targets) {
             if (target.notifyHandshake) {
@@ -169,5 +174,4 @@ namespace pEp {
 
         return PEP_STATUS_OK;
     }
-};
-
+}; // namespace pEp

callback_dispatcher.hh → src/callback_dispatcher.hh

@@ -34,8 +34,7 @@ namespace pEp {
             ::messageToSend_t messageToSend,
             ::notifyHandshake_t notifyHandshake,
             proc on_startup = nullptr,
-            proc on_shutdown = nullptr
-        );
+            proc on_shutdown = nullptr);
         void remove(::messageToSend_t messageToSend);
 
         static void start_sync();
@@ -45,8 +44,8 @@ namespace pEp {
         static PEP_STATUS notifyHandshake(
             ::pEp_identity *me,
             ::pEp_identity *partner,
-            ::sync_handshake_signal signal
-        );
+            ::sync_handshake_signal signal);
+
     protected:
         void on_startup();
         void on_shutdown();
@@ -55,13 +54,12 @@ namespace pEp {
         PEP_STATUS _notifyHandshake(
             ::pEp_identity *me,
             ::pEp_identity *partner,
-            ::sync_handshake_signal signal
-        );
+            ::sync_handshake_signal signal);
 
-        friend const char *PassphraseCache::add(const std::string& passphrase);
+        friend const char *PassphraseCache::add(const std::string &passphrase);
     };
 
     extern CallbackDispatcher callback_dispatcher;
-}
+} // namespace pEp
 
 #endif // LIBPEPADAPTER_CALLBACK_DISPATCHER_HH

constant_time_algo.cc → src/constant_time_algo.cc

@@ -3,19 +3,17 @@
 
 #include "constant_time_algo.hh"
 
-namespace pEp
-{
-    bool constant_time_equal(const std::string& a, const std::string& b)
+namespace pEp {
+    bool constant_time_equal(const std::string &a, const std::string &b)
     {
-        if(a.size() != b.size())
+        if (a.size() != b.size())
             return false;
-        
+
         unsigned d = 0;
-        for(std::size_t idx = 0; idx<a.size(); ++idx)
-        {
-            d |= ( static_cast<unsigned>(a[idx]) ^ static_cast<unsigned>(b[idx]) );
+        for (std::size_t idx = 0; idx < a.size(); ++idx) {
+            d |= (static_cast<unsigned>(a[idx]) ^ static_cast<unsigned>(b[idx]));
         }
-        
+
         // if d is still 0, the strings are equal.
         return d == 0;
     }

constant_time_algo.hh → src/constant_time_algo.hh

@@ -6,14 +6,13 @@
 
 #include <string>
 
-namespace pEp
-{
+namespace pEp {
     // Returns false if a.size() != b.size().
     // Compares always _all_ characters of 'a' and 'b' so runtime does not
     // depends on the character position where the strings differ.
     // Use this function instead of operator== if timing sidechannel attack
     // might be a security problem.
-    bool constant_time_equal(const std::string& a, const std::string& b);
+    bool constant_time_equal(const std::string &a, const std::string &b);
 
 } // end of namespace pEp
 

locked_queue.hh → src/locked_queue.hh

@@ -8,17 +8,15 @@
 #include <condition_variable>
 #include <mutex>
 
-namespace utility
-{
-    template<class T, void(*Deleter)(T) = nullptr>
-    class locked_queue
-    {
-        typedef std::recursive_mutex     Mutex;
-        typedef std::unique_lock<Mutex>  Lock;
-        
-        int    _waiting = 0;
-        Mutex  _mtx;
-        std::condition_variable_any  _cv;
+namespace utility {
+    template<class T, void (*Deleter)(T) = nullptr>
+    class locked_queue {
+        typedef std::recursive_mutex Mutex;
+        typedef std::unique_lock<Mutex> Lock;
+
+        int _waiting = 0;
+        Mutex _mtx;
+        std::condition_variable_any _cv;
         std::deque<T> _q;
 
     public:
@@ -30,10 +28,8 @@ namespace utility
         void clear()
         {
             Lock L(_mtx);
-            if(Deleter != nullptr)
-            {
-                for(auto q : _q)
-                {
+            if (Deleter != nullptr) {
+                for (auto q : _q) {
                     Deleter(q);
                 }
             }
@@ -63,7 +59,7 @@ namespace utility
         T pop_back()
         {
             Lock L(_mtx);
-            _cv.wait(L, [&]{ return !_q.empty(); } );
+            _cv.wait(L, [&] { return !_q.empty(); });
             T r{std::move(_q.back())};
             _q.pop_back();
             return r;
@@ -74,7 +70,7 @@ namespace utility
         T pop_front()
         {
             Lock L(_mtx);
-            _cv.wait(L, [&]{ return !_q.empty(); } );
+            _cv.wait(L, [&] { return !_q.empty(); });
             T r{std::move(_q.front())};
             _q.pop_front();
             return r;
@@ -86,30 +82,28 @@ namespace utility
         {
             Lock L(_mtx);
             ++_waiting;
-            if(! _cv.wait_until(L, end_time, [this]{ return !_q.empty(); } ) )
-            {
+            if (!_cv.wait_until(L, end_time, [this] { return !_q.empty(); })) {
                 --_waiting;
                 return false;
             }
-            
+
             --_waiting;
             out = std::move(_q.back());
             _q.pop_back();
             return true;
         }
- 
+
         // returns true and set a copy of the first element and pop it from queue if there is any
         // returns false and leaves 'out' untouched if queue is empty even after 'end_time'
         bool try_pop_front(T& out, std::chrono::steady_clock::time_point end_time)
         {
             Lock L(_mtx);
             ++_waiting;
-            if(! _cv.wait_until(L, end_time, [this]{ return !_q.empty(); } ) )
-            {
+            if (!_cv.wait_until(L, end_time, [this] { return !_q.empty(); })) {
                 --_waiting;
                 return false;
             }
-            
+
             --_waiting;
             out = std::move(_q.front());
             _q.pop_front();
@@ -122,12 +116,11 @@ namespace utility
         {
             Lock L(_mtx);
             ++_waiting;
-            if(! _cv.wait_for(L, duration, [this]{ return !_q.empty(); } ) )
-            {
+            if (!_cv.wait_for(L, duration, [this] { return !_q.empty(); })) {
                 --_waiting;
                 return false;
             }
-            
+
             --_waiting;
             out = std::move(_q.front());
             _q.pop_front();

message_cache.cc → src/message_cache.cc

@@ -20,67 +20,58 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::cache_decrypt_message(
-            PEP_SESSION session,
-            message *src,
-            message **dst,
-            stringlist_t **keylist,
-            PEP_rating *rating,
-            PEP_decrypt_flags_t *flags
-        )
+        PEP_SESSION session,
+        message *src,
+        message **dst,
+        stringlist_t **keylist,
+        PEP_rating *rating,
+        PEP_decrypt_flags_t *flags)
     {
-        return message_cache.decrypt_message(session, src, dst, keylist,
-                rating, flags);
+        return message_cache.decrypt_message(session, src, dst, keylist, rating, flags);
     }
 
     PEP_STATUS MessageCache::cache_mime_encode_message(
-            int one,
-            const message * msg,
-            bool omit_fields,
-            char **mimetext,
-            bool has_pEp_msg_attachment     
-        )
+        int one,
+        const message *msg,
+        bool omit_fields,
+        char **mimetext,
+        bool has_pEp_msg_attachment)
     {
-        which _one = (which) one;
-        return message_cache.mime_encode_message(_one, msg, omit_fields,
-                mimetext, has_pEp_msg_attachment);
+        which _one = (which)one;
+        return message_cache.mime_encode_message(_one, msg, omit_fields, mimetext, has_pEp_msg_attachment);
     }
 
     PEP_STATUS MessageCache::cache_mime_decode_message(
-            const char *mimetext,
-            size_t size,
-            message **msg,
-            bool* has_possible_pEp_msg
-        )
+        const char *mimetext,
+        size_t size,
+        message **msg,
+        bool *has_possible_pEp_msg)
     {
-        return message_cache.mime_decode_message(mimetext, size, msg,
-                has_possible_pEp_msg);
+        return message_cache.mime_decode_message(mimetext, size, msg, has_possible_pEp_msg);
     }
 
     PEP_STATUS MessageCache::cache_encrypt_message(
-            PEP_SESSION session,
-            message *src,
-            stringlist_t *extra,
-            message **dst,
-            PEP_enc_format enc_format,
-            PEP_encrypt_flags_t flags
-        )
+        PEP_SESSION session,
+        message *src,
+        stringlist_t *extra,
+        message **dst,
+        PEP_enc_format enc_format,
+        PEP_encrypt_flags_t flags)
     {
-        return message_cache.encrypt_message(session, src, extra, dst,
-                enc_format, flags);
+        return message_cache.encrypt_message(session, src, extra, dst, enc_format, flags);
     }
 
     PEP_STATUS MessageCache::cache_encrypt_message_for_self(
-            PEP_SESSION session,
-            pEp_identity* target_id,
-            message *src,
-            stringlist_t* extra,
-            message **dst,
-            PEP_enc_format enc_format,
-            PEP_encrypt_flags_t flags
-        )
+        PEP_SESSION session,
+        pEp_identity *target_id,
+        message *src,
+        stringlist_t *extra,
+        message **dst,
+        PEP_enc_format enc_format,
+        PEP_encrypt_flags_t flags)
     {
-        return message_cache.encrypt_message_for_self(session, target_id, src,
-                extra, dst, enc_format, flags);
+        return message_cache
+            .encrypt_message_for_self(session, target_id, src, extra, dst, enc_format, flags);
     }
 
     PEP_STATUS MessageCache::cache_release(std::string id)
@@ -96,8 +87,8 @@ namespace pEp {
             ::free_message(_cache.at(id).src);
             ::free_message(_cache.at(id).dst);
             _cache.erase(id);
+        } catch (...) {
         }
-        catch (...) { }
     }
 
     static char *dup(const char *src)
@@ -105,7 +96,7 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        char * dst = ::strdup(src);
+        char *dst = ::strdup(src);
         assert(dst);
         if (!dst)
             throw std::bad_alloc();
@@ -118,7 +109,7 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        ::timestamp * dst = ::timestamp_dup(src);
+        ::timestamp *dst = ::timestamp_dup(src);
         if (!dst)
             throw std::bad_alloc();
 
@@ -130,7 +121,7 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        ::pEp_identity * dst = ::identity_dup(src);
+        ::pEp_identity *dst = ::identity_dup(src);
         if (!dst)
             throw std::bad_alloc();
 
@@ -142,7 +133,7 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        ::identity_list * dst = ::identity_list_dup(src);
+        ::identity_list *dst = ::identity_list_dup(src);
         if (!dst)
             throw std::bad_alloc();
 
@@ -154,7 +145,7 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        ::stringlist_t * dst = ::stringlist_dup(src);
+        ::stringlist_t *dst = ::stringlist_dup(src);
         if (!dst)
             throw std::bad_alloc();
 
@@ -166,19 +157,19 @@ namespace pEp {
         if (!src)
             return nullptr;
 
-        ::stringpair_list_t * dst = ::stringpair_list_dup(src);
+        ::stringpair_list_t *dst = ::stringpair_list_dup(src);
         if (!dst)
             throw std::bad_alloc();
 
         return dst;
     }
 
-    static ::message_ref_list *dup(const ::message_ref_list *src) {
+    static ::message_ref_list *dup(const ::message_ref_list *src)
+    {
         if (!src)
             return nullptr;
 
-        ::message_ref_list *dst = (::message_ref_list *) ::calloc(1,
-                sizeof(::message_ref_list));
+        ::message_ref_list *dst = (::message_ref_list *)::calloc(1, sizeof(::message_ref_list));
         assert(dst);
         if (!dst)
             throw std::bad_alloc();
@@ -187,8 +178,7 @@ namespace pEp {
         for (const message_ref_list *s = src; s; s = s->next) {
             d->msg_ref = s->msg_ref;
             if (s->next) {
-                d->next = (::message_ref_list *) ::calloc(1,
-                        sizeof(::message_ref_list));
+                d->next = (::message_ref_list *)::calloc(1, sizeof(::message_ref_list));
                 assert(d);
                 if (!d)
                     throw std::bad_alloc();
@@ -223,7 +213,7 @@ namespace pEp {
             dst->longmsg = dup("pEp");
         else if (!emptystr(src->longmsg_formatted))
             dst->longmsg_formatted = dup("<pEp/>");
-        
+
         // attachments are never copied
 
         dst->rawmsg_ref = src->rawmsg_ref;
@@ -251,9 +241,9 @@ namespace pEp {
 
         if (_id == "") {
             dst->opt_fields = dup(src->opt_fields);
-        }
-        else {
-            dst->opt_fields = ::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID", _id.c_str()));
+        } else {
+            dst->opt_fields = ::new_stringpair_list(
+                ::new_stringpair("X-pEp-Adapter-Cache-ID", _id.c_str()));
             if (!dst->opt_fields)
                 throw std::bad_alloc();
             dst->opt_fields->next = dup(src->opt_fields);
@@ -262,20 +252,19 @@ namespace pEp {
         return dst;
     }
 
-    static void correctAttachmentsOrder(bloblist_t*& bl)
+    static void correctAttachmentsOrder(bloblist_t *&bl)
     {
         // only execute if there are exactly two attachments, both with
         // a non-empty MIME type
 
         if (bl && bl->next && !bl->next->next && !emptystr(bl->mime_type) &&
-                !emptystr(bl->next->mime_type)) {
+            !emptystr(bl->next->mime_type)) {
 
             // if this is most likely an PGP/MIME compliant format then correct
             // order of attachments
 
             if (std::string(bl->mime_type) == "application/octet-stream" &&
-                    std::string(bl->next->mime_type) ==
-                    "application/pgp-encrypted") {
+                std::string(bl->next->mime_type) == "application/pgp-encrypted") {
                 bloblist_t *one = bl->next;
                 bloblist_t *two = bl;
                 bl = one;
@@ -285,7 +274,7 @@ namespace pEp {
         }
     }
 
-    static void swapContent(::message*& part, ::message*& full)
+    static void swapContent(::message *&part, ::message *&full)
     {
         free(part->longmsg);
         part->longmsg = full->longmsg;
@@ -301,13 +290,12 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::decrypt_message(
-            PEP_SESSION session,
-            message *src,
-            message **dst,
-            stringlist_t **keylist,
-            PEP_rating *rating,
-            PEP_decrypt_flags_t *flags
-        )
+        PEP_SESSION session,
+        message *src,
+        message **dst,
+        stringlist_t **keylist,
+        PEP_rating *rating,
+        PEP_decrypt_flags_t *flags)
     {
         if (!src || cacheID(src) == "")
             return PEP_ILLEGAL_VALUE;
@@ -324,8 +312,7 @@ namespace pEp {
         correctAttachmentsOrder(src->attachments);
 
         ::message *_dst = nullptr;
-        PEP_STATUS status = ::decrypt_message(session, src, &_dst, keylist,
-                rating, flags);
+        PEP_STATUS status = ::decrypt_message(session, src, &_dst, keylist, rating, flags);
         *dst = empty_message_copy(_dst, _id);
 
         {
@@ -338,12 +325,11 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::mime_encode_message(
-            which one,
-            const message * msg,
-            bool omit_fields,
-            char **mimetext,
-            bool has_pEp_msg_attachment     
-        )
+        which one,
+        const message *msg,
+        bool omit_fields,
+        char **mimetext,
+        bool has_pEp_msg_attachment)
     {
         if (!msg || cacheID(msg) == "")
             return PEP_ILLEGAL_VALUE;
@@ -357,16 +343,14 @@ namespace pEp {
             std::lock_guard<std::mutex> l(_mtx);
             ::message *_src = _cache.at(cacheID(msg)).src;
             swapContent(_msg, _src);
-        }
-        else /* msg_dst */ {
+        } else /* msg_dst */ {
             std::lock_guard<std::mutex> l(_mtx);
             ::message *_dst = _cache.at(cacheID(msg)).dst;
             swapContent(_msg, _dst);
         }
 
         removeCacheID(_msg);
-        PEP_STATUS status = ::mime_encode_message(_msg, omit_fields, mimetext,
-                has_pEp_msg_attachment);
+        PEP_STATUS status = ::mime_encode_message(_msg, omit_fields, mimetext, has_pEp_msg_attachment);
         ::free_message(_msg);
 
         cache_release(cacheID(msg));
@@ -374,7 +358,7 @@ namespace pEp {
         return status;
     }
 
-    void MessageCache::generateCacheID(::message* msg)
+    void MessageCache::generateCacheID(::message *msg)
     {
         std::string _range = std::to_string(id_range);
         std::string _id = std::to_string(next_id++);
@@ -383,18 +367,15 @@ namespace pEp {
         // if opt_fields is an empty list generate a new list
         if (!msg->opt_fields || !msg->opt_fields->value) {
             free_stringpair_list(msg->opt_fields);
-            msg->opt_fields =
-                ::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID",
-                            cid.c_str()));
+            msg->opt_fields = ::new_stringpair_list(
+                ::new_stringpair("X-pEp-Adapter-Cache-ID", cid.c_str()));
             if (!msg->opt_fields)
                 throw std::bad_alloc();
-        }
-        else {
+        } else {
             // add the cache ID as first field to an existing list
             auto spl = msg->opt_fields;
-            msg->opt_fields =
-                ::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID",
-                            cid.c_str()));
+            msg->opt_fields = ::new_stringpair_list(
+                ::new_stringpair("X-pEp-Adapter-Cache-ID", cid.c_str()));
             if (!msg->opt_fields) {
                 msg->opt_fields = spl;
                 throw std::bad_alloc();
@@ -403,12 +384,11 @@ namespace pEp {
         }
     }
 
-    std::string MessageCache::cacheID(const ::message* msg)
+    std::string MessageCache::cacheID(const ::message *msg)
     {
         for (auto spl = msg->opt_fields; spl && spl->value; spl = spl->next) {
             assert(spl->value->key);
-            if (spl->value->key && std::string(spl->value->key) ==
-                    "X-pEp-Adapter-Cache-ID") {
+            if (spl->value->key && std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
                 assert(spl->value->value);
                 if (spl->value->value)
                     return spl->value->value;
@@ -418,27 +398,22 @@ namespace pEp {
         }
         return "";
     }
- 
-    void MessageCache::removeCacheID(::message* msg)
+
+    void MessageCache::removeCacheID(::message *msg)
     {
         // if the first element in the list is the cache ID then skip
-        if (msg->opt_fields && msg->opt_fields->value &&
-                msg->opt_fields->value->key &&
-                std::string(msg->opt_fields->value->key) ==
-                "X-pEp-Adapter-Cache-ID") {
+        if (msg->opt_fields && msg->opt_fields->value && msg->opt_fields->value->key &&
+            std::string(msg->opt_fields->value->key) == "X-pEp-Adapter-Cache-ID") {
             auto n = msg->opt_fields->next;
             msg->opt_fields->next = nullptr;
             ::free_stringpair_list(msg->opt_fields);
             msg->opt_fields = n;
-        }
-        else {
+        } else {
             // go through the list and remove
             ::stringpair_list_t *prev = nullptr;
-            for (auto spl = msg->opt_fields; spl && spl->value; spl =
-                    spl->next) {
+            for (auto spl = msg->opt_fields; spl && spl->value; spl = spl->next) {
                 assert(spl->value->key);
-                if (spl->value->key &&
-                        std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
+                if (spl->value->key && std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
                     auto next = spl->next;
                     spl->next = nullptr;
                     ::free_stringpair_list(spl);
@@ -451,37 +426,34 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::mime_decode_message(
-            const char *mimetext,
-            size_t size,
-            message **msg,
-            bool* has_possible_pEp_msg
-        )
+        const char *mimetext,
+        size_t size,
+        message **msg,
+        bool *has_possible_pEp_msg)
     {
         ::message *_msg = nullptr;
-        PEP_STATUS status = ::mime_decode_message(mimetext, size, &_msg,
-                has_possible_pEp_msg);
+        PEP_STATUS status = ::mime_decode_message(mimetext, size, &_msg, has_possible_pEp_msg);
         if (status)
             return status;
 
-        generateCacheID(_msg); *msg = empty_message_copy(_msg);
+        generateCacheID(_msg);
+        *msg = empty_message_copy(_msg);
 
         {
             std::lock_guard<std::mutex> l(_mtx);
-            message_cache._cache.emplace(std::make_pair(cacheID(_msg),
-                        cache_entry(_msg, nullptr)));
+            message_cache._cache.emplace(std::make_pair(cacheID(_msg), cache_entry(_msg, nullptr)));
         }
 
         return status;
     }
 
     PEP_STATUS MessageCache::encrypt_message(
-            PEP_SESSION session,
-            message *src,
-            stringlist_t *extra,
-            message **dst,
-            PEP_enc_format enc_format,
-            PEP_encrypt_flags_t flags
-        )
+        PEP_SESSION session,
+        message *src,
+        stringlist_t *extra,
+        message **dst,
+        PEP_enc_format enc_format,
+        PEP_encrypt_flags_t flags)
     {
         ::message *_msg;
         std::string _id = cacheID(src);
@@ -492,8 +464,7 @@ namespace pEp {
         }
 
         ::message *_dst = nullptr;
-        PEP_STATUS status = ::encrypt_message(session, src, extra, &_dst,
-                enc_format, flags);
+        PEP_STATUS status = ::encrypt_message(session, src, extra, &_dst, enc_format, flags);
         *dst = empty_message_copy(_dst, _id);
 
         {
@@ -507,14 +478,13 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::encrypt_message_for_self(
-            PEP_SESSION session,
-            pEp_identity* target_id,
-            message *src,
-            stringlist_t* extra,
-            message **dst,
-            PEP_enc_format enc_format,
-            PEP_encrypt_flags_t flags
-        )
+        PEP_SESSION session,
+        pEp_identity *target_id,
+        message *src,
+        stringlist_t *extra,
+        message **dst,
+        PEP_enc_format enc_format,
+        PEP_encrypt_flags_t flags)
     {
         ::message *_msg;
         std::string _id = cacheID(src);
@@ -525,8 +495,14 @@ namespace pEp {
         }
 
         ::message *_dst = nullptr;
-        PEP_STATUS status = ::encrypt_message_for_self(session, target_id, src,
-                extra, &_dst, enc_format, flags);
+        PEP_STATUS status = ::encrypt_message_for_self(
+            session,
+            target_id,
+            src,
+            extra,
+            &_dst,
+            enc_format,
+            flags);
         *dst = empty_message_copy(_dst, _id);
 
         {
@@ -538,5 +514,4 @@ namespace pEp {
 
         return status;
     }
-};
-
+}; // namespace pEp

message_cache.hh → src/message_cache.hh

@@ -13,8 +13,7 @@
 namespace pEp {
     class MessageCache {
         struct cache_entry {
-            cache_entry(::message *s, ::message *d)
-                : src(s), dst(d) { }
+            cache_entry(::message *s, ::message *d) : src(s), dst(d) {}
 
             ::message *src;
             ::message *dst;
@@ -30,106 +29,100 @@ namespace pEp {
     public:
         MessageCache();
 
-        enum which { msg_src = 0, msg_dst = 1 };
+        enum which
+        {
+            msg_src = 0,
+            msg_dst = 1
+        };
 
-		static PEP_STATUS cache_mime_decode_message(
-				const char *mimetext,
-				size_t size,
-				message **msg,
-				bool* has_possible_pEp_msg
-			);
+        static PEP_STATUS cache_mime_decode_message(
+            const char *mimetext,
+            size_t size,
+            message **msg,
+            bool *has_possible_pEp_msg);
 
         static PEP_STATUS cache_mime_encode_message(
-                int one,
-                const message * msg,
-                bool omit_fields,
-                char **mimetext,
-                bool has_pEp_msg_attachment     
-            );
+            int one,
+            const message *msg,
+            bool omit_fields,
+            char **mimetext,
+            bool has_pEp_msg_attachment);
 
         static PEP_STATUS cache_decrypt_message(
-                PEP_SESSION session,
-                message *src,
-                message **dst,
-                stringlist_t **keylist,
-                PEP_rating *rating,
-                PEP_decrypt_flags_t *flags
-            );
-
-		static PEP_STATUS cache_encrypt_message(
-				PEP_SESSION session,
-				message *src,
-				stringlist_t *extra,
-				message **dst,
-				PEP_enc_format enc_format,
-				PEP_encrypt_flags_t flags
-			);
+            PEP_SESSION session,
+            message *src,
+            message **dst,
+            stringlist_t **keylist,
+            PEP_rating *rating,
+            PEP_decrypt_flags_t *flags);
+
+        static PEP_STATUS cache_encrypt_message(
+            PEP_SESSION session,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags);
 
         static PEP_STATUS cache_encrypt_message_for_self(
-                PEP_SESSION session,
-                pEp_identity* target_id,
-                message *src,
-                stringlist_t* extra,
-                message **dst,
-                PEP_enc_format enc_format,
-                PEP_encrypt_flags_t flags
-            );
+            PEP_SESSION session,
+            pEp_identity *target_id,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags);
 
 
         static PEP_STATUS cache_release(std::string id);
-        static void removeCacheID(::message* msg);
+        static void removeCacheID(::message *msg);
 
     protected:
         void release(std::string id);
 
-		PEP_STATUS mime_decode_message(
-				const char *mimetext,
-				size_t size,
-				message **msg,
-				bool* has_possible_pEp_msg
-			);
+        PEP_STATUS mime_decode_message(
+            const char *mimetext,
+            size_t size,
+            message **msg,
+            bool *has_possible_pEp_msg);
 
         PEP_STATUS mime_encode_message(
-                which one,
-                const message * src,
-                bool omit_fields,
-                char **mimetext,
-                bool has_pEp_msg_attachment
-            );
+            which one,
+            const message *src,
+            bool omit_fields,
+            char **mimetext,
+            bool has_pEp_msg_attachment);
 
         PEP_STATUS decrypt_message(
-                PEP_SESSION session,
-                message *src,
-                message **dst,
-                stringlist_t **keylist,
-                PEP_rating *rating,
-                PEP_decrypt_flags_t *flags
-            );
-
-		PEP_STATUS encrypt_message(
-				PEP_SESSION session,
-				message *src,
-				stringlist_t *extra,
-				message **dst,
-				PEP_enc_format enc_format,
-				PEP_encrypt_flags_t flags
-			);
+            PEP_SESSION session,
+            message *src,
+            message **dst,
+            stringlist_t **keylist,
+            PEP_rating *rating,
+            PEP_decrypt_flags_t *flags);
+
+        PEP_STATUS encrypt_message(
+            PEP_SESSION session,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags);
 
         PEP_STATUS encrypt_message_for_self(
-                PEP_SESSION session,
-                pEp_identity* target_id,
-                message *src,
-                stringlist_t* extra,
-                message **dst,
-                PEP_enc_format enc_format,
-                PEP_encrypt_flags_t flags
-            );
-
-        void generateCacheID(::message* msg);
-        static std::string cacheID(const ::message* msg);
+            PEP_SESSION session,
+            pEp_identity *target_id,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags);
+
+        void generateCacheID(::message *msg);
+        static std::string cacheID(const ::message *msg);
     };
 
     extern MessageCache message_cache;
-};
+}; // namespace pEp
 
 #endif // LIBPEPADAPTER_MESSAGE_CACHE_HH

src/pEpLog.cc

+// This file is under GNU General Public License 3.0
+// see LICENSE.txt
+
+#include "pEpLog.hh"
+#include <iostream>
+#include <sstream>
+#include <mutex>
+#include <atomic>
+
+
+namespace pEp {
+    namespace Adapter {
+        namespace pEpLog {
+
+            std::mutex mtx;
+
+            std::atomic_bool is_enabled{false};
+
+            void set_enabled(bool enabled)
+            {
+                is_enabled.store(enabled);
+            }
+
+            bool get_enabled()
+            {
+                return is_enabled.load();
+            }
+
+            void log(std::string msg)
+            {
+                if (is_enabled.load()) {
+                    std::lock_guard<std::mutex> l(mtx);
+#ifdef ANDROID
+                    __android_log_print(ANDROID_LOG_DEBUG, "pEpDebugLog", "%s", msg.c_str());
+#else
+                    std::cout << msg << std::endl; //std::endl also flushes
+#endif
+                }
+            }
+
+        } // namespace pEpLog
+    }     // namespace Adapter
+} // namespace pEp

pEpLog.hh → src/pEpLog.hh

@@ -29,34 +29,36 @@
 // use set_enabled_<backend>(bool) to turn logging on/off per backend
 
 #ifdef NDEBUG
-    #define pEpLog(msg)  do{}while(0)
+    #define pEpLog(msg)                                                                            \
+        do {                                                                                       \
+        } while (0)
 #else
     #ifdef ANDROID
         #include <android/log.h>
     #endif
 
-    #define pEpLog(msg) \
-    do {                \
-        std::stringstream msg_ss; \
-        msg_ss << std::this_thread::get_id() << " - " << __FILE__ << "::" << __FUNCTION__ << " - " << msg;                 \
-        pEp::Adapter::pEpLog::log(msg_ss.str()); \
-    } while(0)
+    #define pEpLog(msg)                                                                            \
+        do {                                                                                       \
+            std::stringstream msg_ss;                                                              \
+            msg_ss << std::this_thread::get_id() << " - " << __FILE__ << "::" << __FUNCTION__      \
+                   << " - " << msg;                                                                \
+            pEp::Adapter::pEpLog::log(msg_ss.str());                                               \
+        } while (0)
 #endif // NDEBUG
 
 namespace pEp {
-namespace Adapter {
-namespace pEpLog {
+    namespace Adapter {
+        namespace pEpLog {
 
-void log(std::string msg);
+            void log(std::string msg);
 
-void set_enabled(bool is_enabled);
+            void set_enabled(bool is_enabled);
 
-bool get_enabled();
+            bool get_enabled();
 
-} // pEpLog
-} // Adapter
-} // pEp
+        } // namespace pEpLog
+    }     // namespace Adapter
+} // namespace pEp
 
 
 #endif // LIBPEPADAPTER_PEPLOG_HH
-

passphrase_cache.cc → src/passphrase_cache.cc

@@ -9,19 +9,19 @@
 pEp::PassphraseCache pEp::passphrase_cache;
 
 namespace pEp {
-    PassphraseCache::cache_entry::cache_entry(const std::string& p, time_point t) :
-            passphrase{p, 0, PassphraseCache::cache_entry::max_len}, tp{t}
-    { }
-
-    PassphraseCache::PassphraseCache(size_t max_size, duration timeout) :
-            _max_size{max_size}, _timeout{timeout}, _which(_cache.end()),
-            first_time(true)
-    { }
-
-    PassphraseCache::PassphraseCache(const PassphraseCache& second) :
-            _cache{second._cache}, _max_size{second._max_size},
-            _timeout{second._timeout}, _stored{second._stored},
-            _which(_cache.end()), first_time(true)
+    PassphraseCache::cache_entry::cache_entry(const std::string& p, time_point t)
+        : passphrase{p, 0, PassphraseCache::cache_entry::max_len}, tp{t}
+    {
+    }
+
+    PassphraseCache::PassphraseCache(size_t max_size, duration timeout)
+        : _max_size{max_size}, _timeout{timeout}, _which(_cache.end()), first_time(true)
+    {
+    }
+
+    PassphraseCache::PassphraseCache(const PassphraseCache& second)
+        : _cache{second._cache}, _max_size{second._max_size}, _timeout{second._timeout},
+          _stored{second._stored}, _which(_cache.end()), first_time(true)
     {
         cleanup();
     }
@@ -36,16 +36,16 @@ namespace pEp {
         return *this;
     }
 
-    const char *PassphraseCache::add(const std::string& passphrase)
+    const char* PassphraseCache::add(const std::string& passphrase)
     {
         if (!passphrase.empty()) {
-            const char *result = nullptr;
+            const char* result = nullptr;
             {
                 std::lock_guard<std::mutex> lock(_mtx);
 
                 while (_cache.size() >= _max_size)
                     _cache.pop_front();
-                
+
                 _cache.push_back({passphrase, clock::now()});
                 auto back = _cache.end();
                 assert(!_cache.empty());
@@ -55,11 +55,11 @@ namespace pEp {
             return result;
         }
 
-        static const char *empty = "";
+        static const char* empty = "";
         return empty;
     }
 
-    const char *PassphraseCache::add_stored(const std::string& passphrase)
+    const char* PassphraseCache::add_stored(const std::string& passphrase)
     {
         std::lock_guard<std::mutex> lock(_stored_mtx);
         _stored = passphrase;
@@ -81,7 +81,7 @@ namespace pEp {
             std::lock_guard<std::mutex> lock(_mtx);
             cleanup();
 
-            for (auto entry=_cache.begin(); entry!=_cache.end(); ++entry) {
+            for (auto entry = _cache.begin(); entry != _cache.end(); ++entry) {
                 if (callee(entry->passphrase)) {
                     refresh(entry);
                     return true;
@@ -104,7 +104,7 @@ namespace pEp {
         _cache.splice(_cache.end(), _cache, entry);
     }
 
-    const char *PassphraseCache::latest_passphrase(PassphraseCache& c)
+    const char* PassphraseCache::latest_passphrase(PassphraseCache& c)
     {
         if (c.first_time) {
             c.cleanup();
@@ -128,8 +128,8 @@ namespace pEp {
         return c._which->passphrase.c_str();
     }
 
-	PEP_STATUS PassphraseCache::config_next_passphrase(bool reset, PEP_SESSION session)
-	{
+    PEP_STATUS PassphraseCache::config_next_passphrase(bool reset, PEP_SESSION session)
+    {
         static pEp::PassphraseCache _copy;
         static bool new_copy = true;
 
@@ -146,16 +146,14 @@ namespace pEp {
         try {
             ::config_passphrase(session ? session : Adapter::session(), latest_passphrase(_copy));
             return PEP_STATUS_OK;
-        }
-        catch (pEp::PassphraseCache::Empty&) {
+        } catch (pEp::PassphraseCache::Empty&) {
             new_copy = true;
             return PEP_PASSPHRASE_REQUIRED;
-        }
-        catch (pEp::PassphraseCache::Exhausted&) {
+        } catch (pEp::PassphraseCache::Exhausted&) {
             new_copy = true;
             return PEP_WRONG_PASSPHRASE;
         }
-	}
+    }
 
     PEP_STATUS PassphraseCache::ensure_passphrase(PEP_SESSION session, std::string fpr)
     {
@@ -172,5 +170,4 @@ namespace pEp {
 
         return status;
     }
-};
-
+}; // namespace pEp

passphrase_cache.hh → src/passphrase_cache.hh

@@ -20,7 +20,7 @@ namespace pEp {
 
         struct cache_entry {
             static const size_t max_len = 250 * 4;
-            cache_entry(const std::string&  p, time_point t);
+            cache_entry(const std::string& p, time_point t);
 
             std::string passphrase;
             time_point tp;
@@ -39,30 +39,30 @@ namespace pEp {
 
     public:
         struct Empty : public std::underflow_error {
-            Empty() : std::underflow_error("passphrase cache empty") { }
+            Empty() : std::underflow_error("passphrase cache empty") {}
         };
         struct Exhausted : public std::underflow_error {
-            Exhausted() : std::underflow_error("out of passphrases") { }
+            Exhausted() : std::underflow_error("out of passphrases") {}
         };
 
-        PassphraseCache(size_t max_size=20, duration timeout = std::chrono::minutes(10));
-        ~PassphraseCache() { }
+        PassphraseCache(size_t max_size = 20, duration timeout = std::chrono::minutes(10));
+        ~PassphraseCache() {}
         PassphraseCache(const PassphraseCache& second);
         PassphraseCache& operator=(const PassphraseCache& second);
 
         // adds the passphrase to the cache, which will timeout
         // returns a ptr to the passsword entry in the cache. Don't free() it!
-        const char *add(const std::string& passphrase);
+        const char* add(const std::string& passphrase);
 
         // adds the stored passphrase to the cache, which will not timeout
-        const char *add_stored(const std::string& passphrase);
+        const char* add_stored(const std::string& passphrase);
 
         // call this function inside the messageToSend() implementation of the adapter
         // this function is using latest_passphrase() to test one passphrase after the
         // other until the cache is exhausted
         // call with reset = true to reset the iterator
 
-        static PEP_STATUS config_next_passphrase(bool reset=false, PEP_SESSION session = NULL);
+        static PEP_STATUS config_next_passphrase(bool reset = false, PEP_SESSION session = NULL);
 
         // convenience functions
         // i.e.
@@ -71,10 +71,10 @@ namespace pEp {
         // status = ::encrypt_message(session, src, extra, dst, enc_format, flags)
         // using for_each_passphrase()
 
-        template<typename... A> PEP_STATUS api(PEP_STATUS f(PEP_SESSION, A...),
-                PEP_SESSION session, A... a);
+        template<typename... A>
+        PEP_STATUS api(PEP_STATUS f(PEP_SESSION, A...), PEP_SESSION session, A... a);
 
-        static const char *latest_passphrase(PassphraseCache& _cache);
+        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);
@@ -85,7 +85,7 @@ namespace pEp {
     };
 
     extern PassphraseCache passphrase_cache;
-};
+}; // namespace pEp
 
 #include "passphrase_cache.hxx"
 

passphrase_cache.hxx → src/passphrase_cache.hxx

@@ -7,8 +7,8 @@
 #include "passphrase_cache.hh"
 
 namespace pEp {
-    template<typename... A> PEP_STATUS PassphraseCache::api(
-            PEP_STATUS f(PEP_SESSION, A...), PEP_SESSION session, A... a)
+    template<typename... A>
+    PEP_STATUS PassphraseCache::api(PEP_STATUS f(PEP_SESSION, A...), PEP_SESSION session, A... a)
     {
         PEP_STATUS status;
 
@@ -18,12 +18,11 @@ namespace pEp {
                 return true;
 
             status = f(session, a...);
-            return status != PEP_PASSPHRASE_REQUIRED &&
-                    status != PEP_WRONG_PASSPHRASE;
+            return status != PEP_PASSPHRASE_REQUIRED && status != PEP_WRONG_PASSPHRASE;
         });
 
         return status;
     }
-};
+}; // namespace pEp
 
 #endif // LIBPEPADAPTER_PASSPHRASE_CACHE_HXX

slurp.cc → src/slurp.cc

@@ -6,20 +6,16 @@
 #include <sstream>
 #include <stdexcept>
 
-namespace pEp
-{
-
-std::string slurp(const std::string& filename)
-{
-    std::ifstream input(filename.c_str(), std::ios_base::binary);
-    if(!input)
+namespace pEp {
+    std::string slurp(const std::string& filename)
     {
-        throw std::runtime_error("Cannot read file \"" + filename + "\"! ");
-    }
-    
-    std::stringstream sstr;
-    sstr << input.rdbuf();
-    return sstr.str();
-}
+        std::ifstream input(filename.c_str(), std::ios_base::binary);
+        if (!input) {
+            throw std::runtime_error("Cannot read file \"" + filename + "\"! ");
+        }
 
+        std::stringstream sstr;
+        sstr << input.rdbuf();
+        return sstr.str();
+    }
 } // end of namespace pEp

slurp.hh → src/slurp.hh

@@ -6,8 +6,7 @@
 
 #include <string>
 
-namespace pEp
-{
+namespace pEp {
     // reads a whole file and returns it as std::string
     // throws std::runtime_error() if the file cannot be read. Empty file is not an error.
     std::string slurp(const std::string& filename);

src/status_to_string.cc

+// This file is under GNU General Public License 3.0
+// see LICENSE.txt
+
+#include "status_to_string.hh"
+#include <sstream>
+
+
+namespace pEp {
+
+    // in pEpEngine.h positive values are hex, negative are decimal. :-o
+    // TODO: the code should be generated!
+    std::string status_to_string(PEP_STATUS status)
+    {
+        std::stringstream ss;
+        if (status > 0) {
+            ss << "0x" << std::hex << status;
+        } else {
+            ss << status;
+        }
+        return ss.str() + " \"" + pEp_status_to_string(status) + '"';
+    }
+
+} // end of namespace pEp

status_to_string.hh → src/status_to_string.hh

@@ -8,12 +8,11 @@
 #include <pEp/status_to_string.h>
 #include <string>
 
-namespace pEp
-{
+namespace pEp {
     // creates a textual string (returned by pep_status_to_string() ) and the numerical status value.
     // in pEpEngine.h positive values are in hex value, negatives in decimal. So we follow this.
     std::string status_to_string(PEP_STATUS status);
-    
+
 } // end of namespace pEp
 
 #endif // LIBPEPADAPTER_STATUS_TO_STRING_HH

status_to_string.cc

-// This file is under GNU General Public License 3.0
-// see LICENSE.txt
-
-#include "status_to_string.hh"
-#include <sstream>
-
-
-namespace pEp
-{
-
-// in pEpEngine.h positive values are hex, negative are decimal. :-o
-// TODO: the code should be generated!
-std::string status_to_string(PEP_STATUS status)
-{
-    std::stringstream ss;
-    if(status>0)
-    {
-        ss << "0x" << std::hex << status;
-    }else{
-        ss << status;
-    }
-    return ss.str() + " \"" + pEp_status_to_string(status) + '"';
-}
-    
-} // end of namespace pEp

test/Makefile

 include ../Makefile.conf
 
-LDFLAGS=-L../ $(ENGINE_LIB)
+LDFLAGS=-L../src $(ENGINE_LIB)
 LDLIBS=-lstdc++ -lpEpEngine -lpEpAdapter
-CXXFLAGS+=-I../ $(ENGINE_INC) -std=c++11 -DENGINE_TEST=$(ENGINE_TEST)
-
+CXXFLAGS:=-I../src -DENGINE_TEST=$(ENGINE_TEST) $(CXXFLAGS)
 SRC=$(wildcard test_*.cc)
 TST=$(subst .cc,,$(SRC))
 
@@ -13,7 +12,7 @@ $(TST): framework.o
 
 .PHONY: clean rmtestdata
 
-clean:	
+clean:
 	rm -f $(TST)
 	rm -Rf *.dSYM
 	rm -f *.o

test/framework.cc

@@ -20,6 +20,8 @@
 #include <pEp/sync_codec.h>
 #include <pEp/distribution_codec.h>
 
+#include <Adapter.hh>
+
 pEp::Test::Transport pEp::Test::transport;
 std::string pEp::Test::path;
 extern std::thread pEp::Adapter::_sync_thread;
@@ -28,7 +30,7 @@ namespace pEp {
     namespace Test {
         using namespace Adapter;
 
-        void setup(vector<string>& args)
+        void setup(vector<string> &args)
         {
 #ifdef WIN32
             string dir = getenv("TEMP");
@@ -45,17 +47,15 @@ namespace pEp {
                     cout << "usage: " << args[0] << " [--dir HOME]" << endl;
 #endif
                     exit(0);
-                }
-                else if (args[1] == "--dir" && args.size() == 3) {
+                } else if (args[1] == "--dir" && args.size() == 3) {
                     dir = args[2];
-                }
-                else {
+                } else {
                     cerr << "illegal parameter" << endl;
                     exit(1);
                 }
             }
 
-            char _path[MAXPATHLEN+1];
+            char _path[MAXPATHLEN + 1];
             const char *templ = dir.c_str();
             strcpy(_path, templ);
             mkdtemp(_path);
@@ -71,8 +71,8 @@ namespace pEp {
 
         void setup(int argc, char **argv)
         {
-            vector<string> args{(size_t) argc};
-            for (int i=0; i<argc; ++i)
+            vector<string> args{ (size_t)argc };
+            for (int i = 0; i < argc; ++i)
                 args[i] = argv[i];
 
             setup(args);
@@ -81,9 +81,9 @@ namespace pEp {
         void import_key_from_file(string filename)
         {
             ifstream f(filename, ifstream::in);
-            string key{istreambuf_iterator<char>(f), istreambuf_iterator<char>()};
+            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);
+            ::PEP_STATUS status = ::import_key(session(), key.c_str(), key.length(), &il);
             assert(status == PEP_KEY_IMPORTED);
             ::free_identity_list(il);
         }
@@ -95,14 +95,18 @@ namespace pEp {
 
         Identity make_identity(::pEp_identity *ident)
         {
-            return shared_ptr<::pEp_identity>(ident , ::free_identity);
+            return shared_ptr<::pEp_identity>(ident, ::free_identity);
         }
 
         Message mime_parse(string text)
         {
             ::message *msg;
             bool has_possible_pEp_msg;
-            PEP_STATUS status = ::mime_decode_message(text.c_str(), text.length(), &msg, &has_possible_pEp_msg);
+            ::PEP_STATUS status = ::mime_decode_message(
+                text.c_str(),
+                text.length(),
+                &msg,
+                &has_possible_pEp_msg);
             throw_status(status);
             return make_message(msg);
         }
@@ -123,9 +127,9 @@ namespace pEp {
 
             ::message *_dst;
             stringlist_t *keylist;
-            PEP_rating rating;
-            PEP_decrypt_flags_t flags = 0;
-            PEP_STATUS status = ::decrypt_message(session(), msg.get(), &_dst, &keylist, &rating, &flags);
+            ::PEP_rating rating;
+            ::PEP_decrypt_flags_t flags = 0;
+            ::PEP_STATUS status = ::decrypt_message(session(), msg.get(), &_dst, &keylist, &rating, &flags);
             throw_status(status);
 
             Message dst;
@@ -138,18 +142,17 @@ namespace pEp {
                 for (auto a = dst.get()->attachments; a && a->value; a = a->next) {
                     if (string("application/pEp.sync") == a->mime_type) {
                         char *_text;
-                        status = PER_to_XER_Sync_msg(a->value, a->size, &_text);
+                        status = ::PER_to_XER_Sync_msg(a->value, a->size, &_text);
                         throw_status(status);
                         text += _text;
-                        pEp_free(_text);
+                        ::pEp_free(_text);
                         return text;
-                    }
-                    else if (string("application/pEp.distribution") == a->mime_type) {
+                    } else if (string("application/pEp.distribution") == a->mime_type) {
                         char *_text;
-                        status = PER_to_XER_Distribution_msg(a->value, a->size, &_text);
+                        status = ::PER_to_XER_Distribution_msg(a->value, a->size, &_text);
                         throw_status(status);
                         text += _text;
-                        pEp_free(_text);
+                        ::pEp_free(_text);
                         return text;
                     }
                 }
@@ -171,11 +174,10 @@ namespace pEp {
 
             return msg;
         }
-    
+
         void Transport::send(Message msg)
         {
             mkdir(outbox_path.c_str(), 0770);
-
         }
-    };
-};
+    }; // namespace Test
+};     // namespace pEp

test/framework.hh

@@ -7,22 +7,22 @@
 #include <vector>
 #include <memory>
 
-#include "Adapter.hh"
+#include <pEp/message.h>
 
 namespace pEp {
     namespace Test {
         using namespace std;
 
         // manually set up test
-        void setup(vector<string>& args);
+        void setup(vector<string> &args);
 
         // call this in main() for auto set up
-        void setup(int argc=1, char **argv=nullptr);
+        void setup(int argc = 1, char **argv = nullptr);
 
         void import_key_from_file(string filename);
 
         using Message = shared_ptr<::message>;
-        using Identity= shared_ptr<::pEp_identity>;
+        using Identity = shared_ptr<::pEp_identity>;
 
         // use this instead of constructor to auto assign ::free_message as
         // deleter
@@ -57,7 +57,7 @@ namespace pEp {
 
         extern Transport transport;
         extern string path;
-    };
-};
+    }; // namespace Test
+};     // namespace pEp
 
 #endif // LIBPEPADAPTER_FRAMEWORK_HH

test/test_adapter.cc

@@ -6,11 +6,15 @@
 #include <assert.h>
 #include <unistd.h>
 #include <sys/param.h>
+
+#include <pEpLog.hh>
+#include <Adapter.hh>
+#include <pEp/sync_api.h>
 #include <pEp/keymanagement.h>
-#include "pEpLog.hh"
+#include <pEp/message_api.h>
 
 using namespace std;
-using namespace pEp::Adapter;
+using namespace pEp;
 
 PEP_STATUS messageToSend(struct _message *msg)
 {
@@ -18,7 +22,7 @@ PEP_STATUS messageToSend(struct _message *msg)
     return PEP_STATUS_OK;
 }
 
-PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
+PEP_STATUS notifyHandshake(::pEp_identity *me, ::pEp_identity *partner, ::sync_handshake_signal signal)
 {
     pEpLog("called()");
     return PEP_STATUS_OK;
@@ -26,14 +30,14 @@ PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handsha
 
 int main(int argc, char **argv)
 {
-    pEp::Test::setup(argc, argv);
+    Test::setup(argc, argv);
 
     // 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");
+    ::pEp_identity *me = new_identity("alice@peptest.ch", NULL, "23", "Who the F* is Alice");
     assert(me);
-    PEP_STATUS status = myself(session(), me);
-    free_identity(me);
+    ::PEP_STATUS status = ::myself(Adapter::session(), me);
+    ::free_identity(me);
     pEp::throw_status(status);
 
     // start and stop sync repeatedly
@@ -44,10 +48,10 @@ int main(int argc, char **argv)
         pEpLog(i);
         pEpLog("SYNC START");
         pEpLog("starting the adapter including sync");
-        startup(messageToSend, notifyHandshake);
+        Adapter::startup(messageToSend, notifyHandshake);
         pEpLog("SYNC STOP");
         usleep(sleepuSec);
-        shutdown();
+        Adapter::shutdown();
     }
     return 0;
 }

test/test_adapter_cxx.cc

@@ -5,55 +5,69 @@
 #include <iostream>
 #include <assert.h>
 #include <unistd.h>
+
 #include <pEp/keymanagement.h>
-#include "pEpLog.hh"
+#include <pEpLog.hh>
+#include <pEp/sync_api.h>
+
+#include <Adapter.hh>
 
-using namespace pEp::Adapter;
+using namespace pEp;
 
-PEP_STATUS messageToSend(struct _message *msg) {
-	pEpLog("called");
-	return PEP_STATUS_OK;
+PEP_STATUS messageToSend(struct _message *msg)
+{
+    pEpLog("called");
+    return PEP_STATUS_OK;
 }
 
-PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) {
-	pEpLog("called");
-	return PEP_STATUS_OK;
+PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, ::sync_handshake_signal signal)
+{
+    pEpLog("called");
+    return PEP_STATUS_OK;
 }
 
 class JNISync {
 public:
-	void onSyncStartup() {
-		pEpLog("called");
-	}
+    void onSyncStartup()
+    {
+        pEpLog("called");
+    }
 
-	void onSyncShutdown() {
-		pEpLog("called");
-	}
+    void onSyncShutdown()
+    {
+        pEpLog("called");
+    }
 } o;
 
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
     pEp::Test::setup(argc, argv);
 
-	// 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");
-	assert(me);
-	PEP_STATUS status = myself(session(), me);
-	free_identity(me);
-	pEp::throw_status(status);
-
-	// start and stop sync repeatedly
-	useconds_t sleepuSec = 1000 * 100;
-	unsigned long long int nrIters = 1000 * 1000 * 1000;
-	for (int i = 0; i < nrIters; i++) {
-		pEpLog("RUN NR: ");
-		pEpLog(i);
-		pEpLog("SYNC START");
-		pEpLog("starting the adapter including sync");
-		startup<JNISync>(messageToSend, notifyHandshake, &o, &JNISync::onSyncStartup, &JNISync::onSyncShutdown);
-		pEpLog("SYNC STOP");
-		usleep(sleepuSec);
-		shutdown();
-	}
-	return 0;
+    // 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");
+    assert(me);
+    ::PEP_STATUS status = ::myself(Adapter::session(), me);
+    ::free_identity(me);
+    throw_status(status);
+
+    // start and stop sync repeatedly
+    useconds_t sleepuSec = 1000 * 100;
+    unsigned long long int nrIters = 1000 * 1000 * 1000;
+    for (int i = 0; i < nrIters; i++) {
+        pEpLog("RUN NR: ");
+        pEpLog(i);
+        pEpLog("SYNC START");
+        pEpLog("starting the adapter including sync");
+        Adapter::startup<JNISync>(
+            messageToSend,
+            notifyHandshake,
+            &o,
+            &JNISync::onSyncStartup,
+            &JNISync::onSyncShutdown);
+        pEpLog("SYNC STOP");
+        usleep(sleepuSec);
+        Adapter::shutdown();
+    }
+    return 0;
 }

test/test_ensure_passphrase.cc

@@ -9,18 +9,18 @@
 
 #include "framework.hh"
 
-#include "passphrase_cache.hh"
-#include "status_to_string.hh"
+#include <passphrase_cache.hh>
+#include <status_to_string.hh>
+#include <Adapter.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;
 
-int main(int argc, char **argv)
+int main(int argc, char** argv)
 {
     Test::setup(argc, argv);
 
@@ -28,7 +28,8 @@ int main(int argc, char **argv)
     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_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";
@@ -37,15 +38,15 @@ int main(int argc, char **argv)
     Test::import_key_from_file(bob_filename);
     Test::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);
+    ::pEp_identity* bob = ::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog");
+    ::PEP_STATUS status = ::set_own_key(Adapter::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);
+    ::pEp_identity* erwin = ::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin");
+    status = ::set_own_key(Adapter::session(), erwin, erwin_fpr);
     assert(status == PEP_STATUS_OK);
 
-    status = ::key_reset_all_own_keys(session());
+    status = ::key_reset_all_own_keys(Adapter::session());
     assert(status == PEP_STATUS_OK);
 
     ::free_identity(bob);
@@ -55,4 +56,3 @@ int main(int argc, char **argv)
 
     return 0;
 }
-

test/test_leave_device_group.cc

@@ -3,32 +3,27 @@
 #include <unistd.h>
 
 #include "framework.hh"
-#include "passphrase_cache.hh"
-#include "callback_dispatcher.hh"
+#include <passphrase_cache.hh>
+#include <callback_dispatcher.hh>
 
 #include <pEp/sync_api.h>
 
-using namespace pEp;
-using namespace pEp::Adapter;
 using namespace std;
+using namespace pEp;
+
+vector<string> expected_msg = { "synchronizeGroupKeys",
+                                "groupKeysUpdate",
+                                "initUnledGroupKeyReset",
+                                "beacon",
+                                "beacon" };
 
-vector<string> expected_msg = {
-        "synchronizeGroupKeys",
-        "groupKeysUpdate",
-        "initUnledGroupKeyReset",
-        "beacon",
-        "beacon"
-    };
-
-vector<::sync_handshake_signal> expected_notification = {
-        SYNC_NOTIFY_IN_GROUP,
-        SYNC_NOTIFY_START,
-        SYNC_NOTIFY_SOLE,
-        SYNC_NOTIFY_START,
-        SYNC_NOTIFY_STOP
-    };
-
-PEP_STATUS test_messageToSend(::message *_msg)
+vector<::sync_handshake_signal> expected_notification = { SYNC_NOTIFY_IN_GROUP,
+                                                          SYNC_NOTIFY_START,
+                                                          SYNC_NOTIFY_SOLE,
+                                                          SYNC_NOTIFY_START,
+                                                          SYNC_NOTIFY_STOP };
+
+::PEP_STATUS test_messageToSend(::message* _msg)
 {
     static auto actual = expected_msg.begin();
 
@@ -37,11 +32,11 @@ PEP_STATUS test_messageToSend(::message *_msg)
     cerr << "expecting: " << *actual << endl;
     cerr << text;
     assert(text.find(*actual++) != string::npos);
-    return PEP_STATUS_OK;   
+    return PEP_STATUS_OK;
 }
 
 
-PEP_STATUS test_notifyHandshake(pEp_identity *_me, pEp_identity *_partner, sync_handshake_signal signal)
+::PEP_STATUS test_notifyHandshake(::pEp_identity* _me, ::pEp_identity* _partner, sync_handshake_signal signal)
 {
     static auto actual = expected_notification.begin();
 
@@ -50,20 +45,21 @@ PEP_STATUS test_notifyHandshake(pEp_identity *_me, pEp_identity *_partner, sync_
     cerr << "expecting: " << *actual << endl;
     cerr << "notifyHandshake: " << signal << endl;
     assert(signal == *actual++);
-    return PEP_STATUS_OK;   
+    return PEP_STATUS_OK;
 }
 
-int main(int argc, char **argv)
+int main(int argc, char** argv)
 {
     Test::setup(argc, argv);
-    session();
+    Adapter::session();
 
     // set up two own identites for sync
 
     passphrase_cache.add("erwin");
     passphrase_cache.add("bob");
 
-    const char* bob_filename = ENGINE_TEST "/test_keys/bob-primary-with-password-bob-subkey-without.pgp";
+    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";
@@ -72,24 +68,26 @@ int main(int argc, char **argv)
     Test::import_key_from_file(bob_filename);
     Test::import_key_from_file(erwin_filename);
 
-    Test::Identity bob = Test::make_identity(::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog"));
-    PEP_STATUS status = ::set_own_key(session(), bob.get(), bob_fpr);
+    Test::Identity bob = Test::make_identity(
+        ::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog"));
+    PEP_STATUS status = ::set_own_key(Adapter::session(), bob.get(), bob_fpr);
     assert(status == PEP_STATUS_OK);
 
-    status = ::enable_identity_for_sync(session(), bob.get());
+    status = ::enable_identity_for_sync(Adapter::session(), bob.get());
     assert(status == PEP_STATUS_OK);
 
-    Test::Identity erwin = Test::make_identity(::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin"));
-    status = ::set_own_key(session(), erwin.get(), erwin_fpr);
+    Test::Identity erwin = Test::make_identity(
+        ::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin"));
+    status = ::set_own_key(Adapter::session(), erwin.get(), erwin_fpr);
     assert(status == PEP_STATUS_OK);
 
-    status = ::enable_identity_for_sync(session(), erwin.get());
+    status = ::enable_identity_for_sync(Adapter::session(), erwin.get());
     assert(status == PEP_STATUS_OK);
 
     // simulate a device group by setting the identities to in sync
 
-    status = set_identity_flags(session(), bob.get(), PEP_idf_devicegroup);
-    status = set_identity_flags(session(), erwin.get(), PEP_idf_devicegroup);
+    status = ::set_identity_flags(Adapter::session(), bob.get(), PEP_idf_devicegroup);
+    status = ::set_identity_flags(Adapter::session(), erwin.get(), PEP_idf_devicegroup);
 
     // register at callback_dispatcher and start sync
 
@@ -98,24 +96,24 @@ int main(int argc, char **argv)
 
     // leave device group
 
-    status = ::leave_device_group(session());
+
+    status = ::leave_device_group(Adapter::session());
 
     // wait for sync shutdown and release first session
 
     Test::join_sync_thread();
-    assert(!is_sync_running());
+    assert(!Adapter::is_sync_running());
 
     // switch off and on again
 
     CallbackDispatcher::start_sync();
     sleep(2);
-    assert(is_sync_running());
+    assert(Adapter::is_sync_running());
     CallbackDispatcher::stop_sync();
     Test::join_sync_thread();
-    assert(!is_sync_running());
+    assert(!Adapter::is_sync_running());
 
-    session(Adapter::release);
+    Adapter::session(Adapter::release);
 
     return 0;
 }
-

test/test_library.cc

@@ -4,113 +4,99 @@
 #include <iostream>
 #include <thread>
 
-
 using namespace pEp;
 
-
 // Producer's data:
-class P
-{
+class P {
 public:
-	P(int i)
-	: data{new char[64]}
-	{
-		snprintf(data, 63, "%i", i);
-	}
-	
-	P(const P&) = delete;
-	void operator=(const P&) = delete;
-	
-	~P()
-	{
-		std::cerr << "~P(): data=" << (data ? data : "(NULL)" ) << '\n';
-		delete[] data;
-	}
-	
-	char* data;
+    P(int i) : data{ new char[64] }
+    {
+        snprintf(data, 63, "%i", i);
+    }
+
+    P(const P&) = delete;
+    void operator=(const P&) = delete;
+
+    ~P()
+    {
+        std::cerr << "~P(): data=" << (data ? data : "(NULL)") << '\n';
+        delete[] data;
+    }
+
+    char* data;
 };
 
 
 // Consumer's data:
-class C
-{
+class C {
 public:
-	C(int _i) : i(_i) {}
-	int i;
+    C(int _i) : i(_i) {}
+    int i;
 };
 
-pc_container<P,C> pc;
+pc_container<P, C> pc;
 
 void consumer_thread()
 {
-	bool keep_running = true;
-	int sum = 0;
-	while(keep_running)
-	{
-		for(auto& q : pc)
-		{
-		    switch(q.state())
-		    {
-			case PC_State::Created:
-			{
-				const int value = atoi( q.pdata->data );
-				if(value<0)
-				{
-					std::cerr << "Q\n";
-					keep_running = false;
-				}else{
-					std::cerr << "C";
-					q.cdata = new C( value );
-					sum += q.cdata->i;
-				}
-				break;
-			}
-			case PC_State::Deleted:
-			{
-				std::cerr << "D";
-				sum -= q.cdata->i;
-				delete q.cdata;
-				break;
-			}
-			case PC_State::Changed:
-			{
-				std::cerr << "X";
-				sum -= q.cdata->i;
-				delete q.cdata;
-				q.cdata = new C( atoi( q.pdata->data ) );
-				sum += q.cdata->i;
-				break;
-			}
-			default: throw "Illegal state";
-			}
-		}
-	}
-	
-	std::cout << "Consumer sum: " << sum << ".\n";
+    bool keep_running = true;
+    int sum = 0;
+    while (keep_running) {
+        for (auto& q : pc) {
+            switch (q.state()) {
+                case PC_State::Created: {
+                    const int value = atoi(q.pdata->data);
+                    if (value < 0) {
+                        std::cerr << "Q\n";
+                        keep_running = false;
+                    } else {
+                        std::cerr << "C";
+                        q.cdata = new C(value);
+                        sum += q.cdata->i;
+                    }
+                    break;
+                }
+                case PC_State::Deleted: {
+                    std::cerr << "D";
+                    sum -= q.cdata->i;
+                    delete q.cdata;
+                    break;
+                }
+                case PC_State::Changed: {
+                    std::cerr << "X";
+                    sum -= q.cdata->i;
+                    delete q.cdata;
+                    q.cdata = new C(atoi(q.pdata->data));
+                    sum += q.cdata->i;
+                    break;
+                }
+                default:
+                    throw "Illegal state";
+            }
+        }
+    }
+
+    std::cout << "Consumer sum: " << sum << ".\n";
 }
 
 int main()
 {
-	for(int i=0; i<10; ++i)
-	{
-		pc.insert( new P(i) );
-	}
-	
-	std::thread t{ &consumer_thread };
-	
-	for(int i=10; i<100; ++i)
-	{
-		pc.insert( new P(i) );
-	}
-	
-	while( !pc.empty() )
-	{
-		auto q = pc.begin();
-		delete q->pdata;
-		pc.erase( q );
-	}
-	
-	pc.insert( new P(-1) );
-	
-	t.join();
+    for (int i = 0; i < 10; ++i) {
+        pc.insert(new P(i));
+    }
+
+    std::thread t{ &consumer_thread };
+
+    for (int i = 10; i < 100; ++i) {
+        pc.insert(new P(i));
+    }
+
+    while (!pc.empty()) {
+        auto q = pc.begin();
+        delete q->pdata;
+        pc.erase(q);
+    }
+
+    pc.insert(new P(-1));
+
+    t.join();
 }

test/test_message_cache.cc

+#include "framework.hh"
 #include <iostream>
 #include <cassert>
 #include <sys/param.h>
 #include <unistd.h>
-#include "message_cache.hh"
-#include "framework.hh"
+#include <message_cache.hh>
+#include <Adapter.hh>
 
 using namespace std;
 using namespace pEp;
@@ -12,8 +13,8 @@ int main(int argc, char **argv)
 {
     Test::setup(argc, argv);
 
-    pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice");
-    ::myself(pEp::Adapter::session(), alice);
+    ::pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice");
+    ::myself(Adapter::session(), alice);
 
     char *mime = strdup("From: Alice <alice@mail.com>\n"
                         "To: Bob <bob@mail.com>\n"
@@ -25,20 +26,30 @@ int main(int argc, char **argv)
 
     ::message *src = nullptr;
     bool has_possible_pEp_msg;
-    PEP_STATUS 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(pEp::Adapter::session(), src->from);
+    status = ::myself(Adapter::session(), src->from);
     assert(status == PEP_STATUS_OK);
 
-    ::update_identity(pEp::Adapter::session(), src->to->ident);
+    ::update_identity(Adapter::session(), src->to->ident);
     assert(status == PEP_STATUS_OK);
 
-    pEp_identity *bob = identity_dup(src->to->ident);
+    ::pEp_identity *bob = identity_dup(src->to->ident);
 
-    src->dir = PEP_dir_outgoing;
+    src->dir = ::PEP_dir_outgoing;
     ::message *dst = nullptr;
-    status = MessageCache::cache_encrypt_message(pEp::Adapter::session(), src, nullptr, &dst, PEP_enc_PEP, 0);
+    status = MessageCache::cache_encrypt_message(
+        Adapter::session(),
+        src,
+        nullptr,
+        &dst,
+        PEP_enc_PEP,
+        0);
     assert(status != PEP_ILLEGAL_VALUE);
 
     assert(src->longmsg == nullptr);
@@ -65,11 +76,17 @@ int main(int argc, char **argv)
     assert(src->longmsg == nullptr);
     assert(src->attachments == nullptr);
 
-    PEP_rating rating;
-    PEP_decrypt_flags_t flags = 0;
-    stringlist_t *keylist = nullptr;
-
-    status = MessageCache::cache_decrypt_message(pEp::Adapter::session(), src, &dst, &keylist, &rating, &flags);
+    ::PEP_rating rating;
+    ::PEP_decrypt_flags_t flags = 0;
+    ::stringlist_t *keylist = nullptr;
+
+    status = MessageCache::cache_decrypt_message(
+        Adapter::session(),
+        src,
+        &dst,
+        &keylist,
+        &rating,
+        &flags);
     assert(status != PEP_ILLEGAL_VALUE);
 
     assert(src->longmsg == nullptr);
@@ -92,7 +109,6 @@ int main(int argc, char **argv)
     ::free_identity(bob);
     ::free_identity(alice);
 
-    pEp::Adapter::session(pEp::Adapter::release);
+    Adapter::session(Adapter::release);
     return 0;
 }
-

test/test_passphrase_cache.cc

+#include "framework.hh"
+
 #include <iostream>
 #include <unistd.h>
 #include <assert.h>
+
 #include <sys/param.h>
+#include <passphrase_cache.hh>
+#include <status_to_string.hh>
+#include <Adapter.hh>
 
-#include "framework.hh"
-#include "passphrase_cache.hh"
-#include "status_to_string.hh"
+using namespace pEp;
 
 extern "C" {
-    PEP_STATUS api_test1(PEP_SESSION session, const char *str, char *bytes, int n, ::stringlist_t *sl)
-    {
-        std::cout << "called api_test1\n";
-        return PEP_WRONG_PASSPHRASE;
-    }
+::PEP_STATUS api_test1(::PEP_SESSION session, const char *str, char *bytes, int n, ::stringlist_t *sl)
+{
+    std::cout << "called api_test1\n";
+    return PEP_WRONG_PASSPHRASE;
+}
 
-    PEP_STATUS api_test2(PEP_SESSION session, int n, const char *str, char *bytes, ::stringlist_t *sl)
-    {
-        std::cout << "called api_test2\n";
-        return PEP_STATUS_OK;
-    }
+::PEP_STATUS api_test2(::PEP_SESSION session, int n, const char *str, char *bytes, ::stringlist_t *sl)
+{
+    std::cout << "called api_test2\n";
+    return PEP_STATUS_OK;
+}
 };
 
 int main(int argc, char **argv)
 {
-    pEp::Test::setup(argc, argv);
+    Test::setup(argc, argv);
 
     const char *str = "23";
     char *bytes = NULL;
     int n = 42;
     ::stringlist_t *sl = NULL;
 
-    pEp::PassphraseCache cache{2, std::chrono::seconds(1)};
+    PassphraseCache cache{ 2, std::chrono::seconds(1) };
     cache.add("say");
     cache.add("hello");
     cache.add("world");
 
     std::cout << "expected: two passphrases\n";
-    cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return false;});
+    cache.for_each_passphrase([&](std::string passphrase) {
+        std::cout << "'" << passphrase << "'\n";
+        return false;
+    });
 
     std::cout << "expected: one passphrase\n";
-    cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return passphrase != "";});
+    cache.for_each_passphrase([&](std::string passphrase) {
+        std::cout << "'" << passphrase << "'\n";
+        return passphrase != "";
+    });
 
     std::cout << "expected: two passphrases but reverse order\n";
-    cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return false;});
+    cache.for_each_passphrase([&](std::string passphrase) {
+        std::cout << "'" << passphrase << "'\n";
+        return false;
+    });
 
-    PEP_STATUS status = cache.api(api_test1, pEp::Adapter::session(), "23", bytes, n, (::stringlist_t *) NULL);
+    ::PEP_STATUS status = cache.api(api_test1, Adapter::session(), "23", bytes, n, (::stringlist_t *)NULL);
     assert(status == PEP_WRONG_PASSPHRASE);
-    status = cache.api(api_test2, pEp::Adapter::session(), n, str, bytes, sl);
+    status = cache.api(api_test2, Adapter::session(), n, str, bytes, sl);
     assert(status == PEP_STATUS_OK);
 
     cache.add("hello");
     cache.add("world");
     std::cout << "expected: two passphrases in reverse order\n";
-    pEp::PassphraseCache _cache = cache;
+    PassphraseCache _cache = cache;
     try {
         while (1) {
             std::cout << "'" << _cache.latest_passphrase(_cache) << "'\n";
         }
+    } catch (std::underflow_error &) {
     }
-    catch (std::underflow_error&) { }
 
-    pEp::passphrase_cache.add("hello");
-    pEp::passphrase_cache.add("world");
+    passphrase_cache.add("hello");
+    passphrase_cache.add("world");
     std::cout << "two times PEP_STATUS_OK (0), one time PEP_WRONG_PASSPHRASE (2561)\n";
     do {
-        status = pEp::PassphraseCache::config_next_passphrase();
-        std::cout << pEp::status_to_string(status) << " (" << status << ")\n";
+        status = PassphraseCache::config_next_passphrase();
+        std::cout << status_to_string(status) << " (" << status << ")\n";
     } while (status == PEP_STATUS_OK);
 
     sleep(2);
 
     std::cout << "expected: no passphrase\n";
-    cache.for_each_passphrase([&](std::string passphrase){std::cout << "'" << passphrase << "'\n"; return false;});
+    cache.for_each_passphrase([&](std::string passphrase) {
+        std::cout << "'" << passphrase << "'\n";
+        return false;
+    });
 
-    status = cache.api(api_test1, pEp::Adapter::session(), str, bytes, n, sl);
+    status = cache.api(api_test1, Adapter::session(), str, bytes, n, sl);
     assert(status == PEP_WRONG_PASSPHRASE);
-    status = cache.api(api_test2, pEp::Adapter::session(), 23, str, bytes, sl);
+    status = cache.api(api_test2, Adapter::session(), 23, str, bytes, sl);
     assert(status == PEP_STATUS_OK);
 
-    pEp::Adapter::session(pEp::Adapter::release);
+    Adapter::session(Adapter::release);
     return 0;
 }
-

test/test_semaphore.cc

@@ -10,26 +10,25 @@ int main()
 {
     Semaphore semaphore;
 
-    thread thread1([&](){
-            cout << "1: before stop\n";
-            semaphore.stop();
-            cout << "1: now on stop\n";
-            semaphore.try_wait();
-            cout << "1: and on go again\n";
-            semaphore.try_wait();
-            cout << "1: keep going\n";
-        });
+    thread thread1([&]() {
+        cout << "1: before stop\n";
+        semaphore.stop();
+        cout << "1: now on stop\n";
+        semaphore.try_wait();
+        cout << "1: and on go again\n";
+        semaphore.try_wait();
+        cout << "1: keep going\n";
+    });
 
     sleep(1);
 
-    thread thread2([&](){
-            cout << "2: setting go\n";
-            semaphore.go();
-        });
+    thread thread2([&]() {
+        cout << "2: setting go\n";
+        semaphore.go();
+    });
 
     thread1.join();
     thread2.join();
 
     return 0;
 }
-