Skip to content

GitLab

Source
Select Git revision
...
Target
Select Git revision
 
Commits (21)
Hide whitespace changes
Inline Side-by-side
Showing with 1350 additions and 696 deletions
.clang-format 0 → 100644
View file @ b5f0227a
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
Makefile
View file @ b5f0227a
...@@ -3,45 +3,22 @@ ...@@ -3,45 +3,22 @@
# This file may be used under the terms of the GNU General Public License version 3 # This file may be used under the terms of the GNU General Public License version 3
# see LICENSE.txt # 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) test: src
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
$(MAKE) -C test $(MAKE) -C test
$(TARGET): $(OBJECTS)
$(AR) -rc $@ $^
clean: clean:
rm -vf $(TARGET) $(OBJECTS) $(DEPENDS) $(MAKE) -C src clean
rm -f *.d.*
$(MAKE) -C test clean $(MAKE) -C test clean
install: $(TARGET) install:
mkdir -p $(PREFIX)/include/pEp $(MAKE) -C src install
mkdir -p $(PREFIX)/lib
cp -v $(HEADERS) $(PREFIX)/include/pEp/
cp -v $(TARGET) $(PREFIX)/lib/
uninstall: uninstall:
cd $(PREFIX)/include/pEp && rm -vf $(HEADERS) $(MAKE) -C src uninstall
cd $(PREFIX)/lib && rm -vf $(TARGET) \ No newline at end of file
Makefile.conf
View file @ b5f0227a
# Copyright 2018, pEp Foundation # Copyright 2018, pEp Foundation
# This file is part of lib pEp Adapter # This file is part of libpEpAdapter
# This file may be used under the terms of the GNU General Public License version 3 # This file may be used under the terms of the GNU General Public License version 3
# see LICENSE.txt # see LICENSE.txt
HERE:=$(dir $(lastword $(MAKEFILE_LIST))) HERE:=$(dir $(lastword $(MAKEFILE_LIST)))
TARGET=libpEpAdapter.a
# Defaults # Defaults
DEBUG=1 DEBUG=1
...@@ -12,7 +13,7 @@ PREFIX?=$(HOME) ...@@ -12,7 +13,7 @@ PREFIX?=$(HOME)
ENGINE_LIB_PATH=$(PREFIX)/lib ENGINE_LIB_PATH=$(PREFIX)/lib
ENGINE_INC_PATH=$(PREFIX)/include ENGINE_INC_PATH=$(PREFIX)/include
CXXFLAGS+=-std=c++11 -fPIC CXXFLAGS+=-std=c++14 -fPIC
# Build target # Build target
BUILD_FOR:=$(shell uname) BUILD_FOR:=$(shell uname)
......
call_with_lock.hh deleted 100644 → 0
View file @ 1270d147
// 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 deleted 100644 → 0
View file @ 1270d147
// 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
View file @ b5f0227a
...@@ -14,87 +14,169 @@ using namespace std; ...@@ -14,87 +14,169 @@ using namespace std;
thread_local pEp::Adapter::Session pEp::Adapter::session; thread_local pEp::Adapter::Session pEp::Adapter::session;
namespace pEp { 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; return;
if (status >= 0x400 && status <= 0x4ff) }
if (status >= 0x400 && status <= 0x4ff) {
return; return;
if (status == PEP_STATEMACHINE_CANNOT_SEND) }
if (status == ::PEP_STATEMACHINE_CANNOT_SEND) {
return; return;
if (status == PEP_OUT_OF_MEMORY) }
if (status == ::PEP_OUT_OF_MEMORY) {
throw bad_alloc(); throw bad_alloc();
if (status == PEP_ILLEGAL_VALUE) }
if (status == ::PEP_ILLEGAL_VALUE) {
throw invalid_argument("illegal value"); throw invalid_argument("illegal value");
}
string _status = status_to_string(status); string _status = status_to_string(status);
throw RuntimeError(_status, status); throw RuntimeError(_status, status);
} }
RuntimeError::RuntimeError(const std::string& _text, PEP_STATUS _status) RuntimeError::RuntimeError(const std::string &_text, ::PEP_STATUS _status)
: std::runtime_error(_text.c_str()), text(_text), status(_status) : std::runtime_error(_text.c_str()), text(_text), status(_status)
{ {
} }
namespace Adapter { namespace Adapter {
messageToSend_t _messageToSend = nullptr; // private
notifyHandshake_t _notifyHandshake = nullptr; 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; 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; // private
std::mutex m;
std::thread::id sync_thread_id() std::thread::id sync_thread_id()
{ {
return _sync_thread.get_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 { try {
if (ev == nullptr) { if (ev == nullptr) {
sync_evt_q.clear(); sync_evt_q.clear();
sync_evt_q.push_back(ev); sync_evt_q.push_back(ev);
} } else {
else {
sync_evt_q.push_front(ev); sync_evt_q.push_front(ev);
} }
} } catch (exception &) {
catch (exception&) {
return 1; return 1;
} }
return 0; 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); return passphrase_cache.ensure_passphrase(session, fpr);
} }
// threshold: max waiting time in seconds // public
SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold) ::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)); const bool success = sync_evt_q.try_pop_front(syncEvent, std::chrono::seconds(threshold));
if (!success) { if (!success) {
return new_sync_timeout_event(); return ::new_sync_timeout_event();
} }
return syncEvent; return syncEvent;
} }
// public
bool on_sync_thread() bool on_sync_thread()
{ {
return _sync_thread.get_id() == this_thread::get_id(); 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) { switch (action) {
case release: case release:
...@@ -105,43 +187,49 @@ namespace pEp { ...@@ -105,43 +187,49 @@ namespace pEp {
case init: case init:
if (!_session.get()) { if (!_session.get()) {
PEP_SESSION session_; ::PEP_SESSION session_;
status = ::init(&session_, _messageToSend, _inject_sync_event, _ensure_passphrase); status = ::init(&session_, _messageToSend, _inject_action, _ensure_passphrase);
throw_status(status); throw_status(status);
_session = SessionPtr{session_, ::release}; _session = SessionPtr{session_, ::release};
} }
break; break;
default: default:
status = PEP_ILLEGAL_VALUE; status = ::PEP_ILLEGAL_VALUE;
} }
throw_status(status); throw_status(status);
return _session.get(); return _session.get();
} }
// public
void shutdown() void shutdown()
{ {
pEpLog("called"); pEpLog("called");
if (_sync_thread.joinable()) { if (_sync_thread.joinable()) {
pEpLog("sync_is_running - injecting null event"); pEpLog("sync_is_running - injecting null event");
_inject_sync_event(nullptr, nullptr); _queue_sync_event(nullptr, nullptr);
_sync_thread.join(); _sync_thread.join();
} }
} }
// public
bool is_sync_running() 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() bool in_shutdown()
{ {
SYNC_EVENT ev; SYNC_EVENT ev;
try { try {
ev = sync_evt_q.back(); ev = sync_evt_q.back();
} } catch (std::underflow_error &) {
catch (std::underflow_error&) {
return false; return false;
} }
if (ev) { if (ev) {
...@@ -149,6 +237,6 @@ namespace pEp { ...@@ -149,6 +237,6 @@ namespace pEp {
} else { } else {
return true; return true;
} }
} }
} } // namespace Adapter
} } // namespace pEp
Adapter.hh → src/Adapter.hh
View file @ b5f0227a
...@@ -5,10 +5,10 @@ ...@@ -5,10 +5,10 @@
#define LIBPEPADAPTER_ADAPTER_HH #define LIBPEPADAPTER_ADAPTER_HH
#include <functional> #include <functional>
#include <memory>
#include <stdexcept>
#include <string> #include <string>
#include <thread> #include <thread>
#include <stdexcept>
#include <memory>
#include <pEp/sync_api.h> #include <pEp/sync_api.h>
...@@ -17,26 +17,43 @@ namespace pEp { ...@@ -17,26 +17,43 @@ namespace pEp {
// throws std::bad_alloc if status==PEP_OUT_OF_MEMORY, // throws std::bad_alloc if status==PEP_OUT_OF_MEMORY,
// throws std::invalid_argument if status==PEP_ILLEGAL_VALUE, // throws std::invalid_argument if status==PEP_ILLEGAL_VALUE,
// throws RuntimeError when 'status' represents another exceptional 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 { struct RuntimeError : std::runtime_error {
RuntimeError(const std::string& _text, PEP_STATUS _status); RuntimeError(const std::string &_text, ::PEP_STATUS _status);
std::string text; std::string text;
PEP_STATUS status; ::PEP_STATUS status;
}; };
namespace Adapter { namespace Adapter {
int _inject_sync_event(SYNC_EVENT ev, void *management); // public
PEP_STATUS _ensure_passphrase(PEP_SESSION session, const char *fpr); 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> template<class T = void>
void startup( void startup(
messageToSend_t messageToSend, messageToSend_t messageToSend,
notifyHandshake_t notifyHandshake, notifyHandshake_t notifyHandshake,
T *obj = nullptr, T *obj = nullptr,
std::function< void (T *) > _startup = nullptr, std::function<void(T *)> _startup = nullptr,
std::function< void (T *) > _shutdown = nullptr std::function<void(T *)> _shutdown = nullptr);
);
// returns 'true' when called from the "sync" thread, 'false' otherwise. // returns 'true' when called from the "sync" thread, 'false' otherwise.
bool on_sync_thread(); bool on_sync_thread();
...@@ -44,9 +61,10 @@ namespace pEp { ...@@ -44,9 +61,10 @@ namespace pEp {
// returns the thread id of the sync thread // returns the thread id of the sync thread
std::thread::id sync_thread_id(); std::thread::id sync_thread_id();
enum session_action { enum session_action
{
init, init,
release release,
}; };
class Session { class Session {
...@@ -59,15 +77,15 @@ namespace pEp { ...@@ -59,15 +77,15 @@ namespace pEp {
extern thread_local Session session; extern thread_local Session session;
// injects a NULL event into sync_event_queue to denote sync thread to shutdown, // injects a NULL event into sync_event_queue to denote sync thread to
// and joins & removes the sync thread // shutdown, and joins & removes the sync thread
void shutdown(); void shutdown();
bool is_sync_running(); bool is_sync_running();
bool in_shutdown(); bool in_shutdown();
} } // namespace Adapter
} } // namespace pEp
#include "Adapter.hxx" #include "Adapter.hxx"
#endif //LIBPEPADAPTER_ADAPTER_HH #endif // LIBPEPADAPTER_ADAPTER_HH
\ No newline at end of file \ No newline at end of file
Adapter.hxx → src/Adapter.hxx
View file @ b5f0227a
...@@ -14,43 +14,63 @@ namespace pEp { ...@@ -14,43 +14,63 @@ namespace pEp {
namespace Adapter { namespace Adapter {
using std::function; using std::function;
extern messageToSend_t _messageToSend; extern ::messageToSend_t _messageToSend;
extern notifyHandshake_t _notifyHandshake; extern ::notifyHandshake_t _notifyHandshake;
extern std::thread _sync_thread; extern std::thread _sync_thread;
extern ::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > sync_evt_q; extern ::utility::locked_queue<::SYNC_EVENT, ::free_Sync_event> sync_evt_q;
extern std::mutex m; 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::exception_ptr _ex;
static std::atomic_bool register_done{false}; 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"); pEpLog("called");
_ex = nullptr; _ex = nullptr;
assert(_messageToSend); assert(_messageToSend);
assert(_notifyHandshake); assert(_notifyHandshake);
// 1. Execute registered startup function
if (obj && _startup) { if (obj && _startup) {
_startup(obj); _startup(obj);
} }
pEpLog("creating session"); pEpLog("creating session for the sync thread");
// 2. Create session for the sync thread
session(); 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()"); pEpLog("register_sync_callbacks()");
PEP_STATUS status = register_sync_callbacks(session(), nullptr, ::PEP_STATUS status = ::register_sync_callbacks(
_notifyHandshake, _retrieve_next_sync_event); session(),
nullptr,
_notifyHandshake,
_retrieve_next_sync_event);
pEpLog("register_sync_callbacks() return:" << status); pEpLog("register_sync_callbacks() return:" << status);
// Convert status into exception and store it
// set register_done AFTER that
try { try {
throw_status(status); throw_status(status);
register_done.store(true); register_done.store(true);
} } catch (...) {
catch (...) {
_ex = std::current_exception(); _ex = std::current_exception();
register_done.store(true); register_done.store(true);
return; return;
...@@ -58,24 +78,38 @@ namespace pEp { ...@@ -58,24 +78,38 @@ namespace pEp {
} }
pEpLog("sync protocol loop started"); 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"); pEpLog("sync protocol loop ended");
// 5. unregister_sync_callbacks()
unregister_sync_callbacks(session()); unregister_sync_callbacks(session());
// 6. Release the session
// TODO: Maybe do that AFTER shutdown?
session(release); session(release);
// 7. Execute registered shutdown function
if (obj && _shutdown) { if (obj && _shutdown) {
_shutdown(obj); _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( void startup(
messageToSend_t messageToSend, ::messageToSend_t messageToSend,
notifyHandshake_t notifyHandshake, ::notifyHandshake_t notifyHandshake,
T *obj, T *obj,
function< void(T *) > _startup, function<void(T *)> _startup,
function< void(T *) > _shutdown) function<void(T *)> _shutdown)
{ {
pEpLog("called"); pEpLog("called");
if (messageToSend) { if (messageToSend) {
...@@ -85,26 +119,30 @@ namespace pEp { ...@@ -85,26 +119,30 @@ namespace pEp {
if (notifyHandshake) { if (notifyHandshake) {
_notifyHandshake = notifyHandshake; _notifyHandshake = notifyHandshake;
} }
pEpLog("creating session"); pEpLog("ensure session for the main thread");
session(); // 1. re-initialize session for the main thread (registers: messageToSend, _queue_sync_event, _ensure_passphrase)
session(release);
session(init);
if (!_sync_thread.joinable()) { if (!_sync_thread.joinable()) {
register_done.store(false); register_done.store(false);
pEpLog("creating sync-thread"); pEpLog("creating sync-thread");
// 2. Start the sync thread
_sync_thread = std::thread(sync_thread<T>, obj, _startup, _shutdown); _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) { while (register_done.load() == false) {
pEpLog("waiting for sync-thread to init..."); pEpLog("waiting for sync-thread to init...");
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
} }
// 4. Throw pending exception from the sync thread
if (_ex) { if (_ex) {
pEpLog("exception pending, rethrowing"); pEpLog("exception pending, rethrowing");
std::rethrow_exception(_ex); std::rethrow_exception(_ex);
} }
} }
} }
} } // namespace Adapter
} } // namespace pEp
#endif //LIBPEPADAPTER_ADAPTER_HXX #endif //LIBPEPADAPTER_ADAPTER_HXX
\ No newline at end of file
src/Makefile 0 → 100644
View file @ b5f0227a
# 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
View file @ b5f0227a
...@@ -19,7 +19,7 @@ namespace pEp { ...@@ -19,7 +19,7 @@ namespace pEp {
std::atomic_bool _stop; std::atomic_bool _stop;
public: public:
Semaphore() : _stop(false) { } Semaphore() : _stop(false) {}
void stop() void stop()
{ {
...@@ -34,7 +34,7 @@ namespace pEp { ...@@ -34,7 +34,7 @@ namespace pEp {
return; return;
} }
while(_stop.load()) { while (_stop.load()) {
cv.wait(lock); cv.wait(lock);
} }
} }
...@@ -46,8 +46,6 @@ namespace pEp { ...@@ -46,8 +46,6 @@ namespace pEp {
cv.notify_all(); cv.notify_all();
} }
}; };
} } // namespace pEp
#endif // LIBPEPADAPTER_SEMAPHORE_HH #endif // LIBPEPADAPTER_SEMAPHORE_HH
call_with_lock.cc → src/call_with_lock.cc
View file @ b5f0227a
...@@ -3,7 +3,6 @@ ...@@ -3,7 +3,6 @@
#include "call_with_lock.hh" #include "call_with_lock.hh"
namespace pEp namespace pEp {
{ std::mutex call_with_lock_mutex;
std::mutex call_with_lock_mutex;
} }
src/call_with_lock.hh 0 → 100644
View file @ b5f0227a
// 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
View file @ b5f0227a
...@@ -14,18 +14,19 @@ namespace pEp { ...@@ -14,18 +14,19 @@ namespace pEp {
return callback_dispatcher._messageToSend(msg); return callback_dispatcher._messageToSend(msg);
} }
PEP_STATUS CallbackDispatcher::notifyHandshake(::pEp_identity *me, PEP_STATUS CallbackDispatcher::notifyHandshake(
::pEp_identity *partner, ::sync_handshake_signal signal) ::pEp_identity *me,
::pEp_identity *partner,
::sync_handshake_signal signal)
{ {
return callback_dispatcher._notifyHandshake(me, partner, signal); return callback_dispatcher._notifyHandshake(me, partner, signal);
} }
void CallbackDispatcher::add( void CallbackDispatcher::add(
::messageToSend_t messageToSend, ::messageToSend_t messageToSend,
::notifyHandshake_t notifyHandshake, ::notifyHandshake_t notifyHandshake,
proc on_startup, proc on_startup,
proc shutdown proc shutdown)
)
{ {
assert(messageToSend); assert(messageToSend);
if (!messageToSend) { if (!messageToSend) {
...@@ -77,10 +78,12 @@ namespace pEp { ...@@ -77,10 +78,12 @@ namespace pEp {
pEpLog("called"); pEpLog("called");
callback_dispatcher.semaphore.go(); callback_dispatcher.semaphore.go();
pEp::Adapter::startup<CallbackDispatcher>(CallbackDispatcher::messageToSend, pEp::Adapter::startup<CallbackDispatcher>(
CallbackDispatcher::notifyHandshake, &callback_dispatcher, CallbackDispatcher::messageToSend,
&CallbackDispatcher::on_startup, CallbackDispatcher::notifyHandshake,
&CallbackDispatcher::on_shutdown); &callback_dispatcher,
&CallbackDispatcher::on_startup,
&CallbackDispatcher::on_shutdown);
pEpLog("all targets signal: SYNC_NOTIFY_START"); pEpLog("all targets signal: SYNC_NOTIFY_START");
for (auto target : callback_dispatcher.targets) { for (auto target : callback_dispatcher.targets) {
...@@ -143,8 +146,10 @@ namespace pEp { ...@@ -143,8 +146,10 @@ namespace pEp {
return PEP_STATUS_OK; return PEP_STATUS_OK;
} }
PEP_STATUS CallbackDispatcher::_notifyHandshake(::pEp_identity *me, PEP_STATUS CallbackDispatcher::_notifyHandshake(
::pEp_identity *partner, ::sync_handshake_signal signal) ::pEp_identity *me,
::pEp_identity *partner,
::sync_handshake_signal signal)
{ {
for (auto target : targets) { for (auto target : targets) {
if (target.notifyHandshake) { if (target.notifyHandshake) {
...@@ -169,5 +174,4 @@ namespace pEp { ...@@ -169,5 +174,4 @@ namespace pEp {
return PEP_STATUS_OK; return PEP_STATUS_OK;
} }
}; }; // namespace pEp
callback_dispatcher.hh → src/callback_dispatcher.hh
View file @ b5f0227a
...@@ -34,8 +34,7 @@ namespace pEp { ...@@ -34,8 +34,7 @@ namespace pEp {
::messageToSend_t messageToSend, ::messageToSend_t messageToSend,
::notifyHandshake_t notifyHandshake, ::notifyHandshake_t notifyHandshake,
proc on_startup = nullptr, proc on_startup = nullptr,
proc on_shutdown = nullptr proc on_shutdown = nullptr);
);
void remove(::messageToSend_t messageToSend); void remove(::messageToSend_t messageToSend);
static void start_sync(); static void start_sync();
...@@ -45,8 +44,8 @@ namespace pEp { ...@@ -45,8 +44,8 @@ namespace pEp {
static PEP_STATUS notifyHandshake( static PEP_STATUS notifyHandshake(
::pEp_identity *me, ::pEp_identity *me,
::pEp_identity *partner, ::pEp_identity *partner,
::sync_handshake_signal signal ::sync_handshake_signal signal);
);
protected: protected:
void on_startup(); void on_startup();
void on_shutdown(); void on_shutdown();
...@@ -55,13 +54,12 @@ namespace pEp { ...@@ -55,13 +54,12 @@ namespace pEp {
PEP_STATUS _notifyHandshake( PEP_STATUS _notifyHandshake(
::pEp_identity *me, ::pEp_identity *me,
::pEp_identity *partner, ::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; extern CallbackDispatcher callback_dispatcher;
} } // namespace pEp
#endif // LIBPEPADAPTER_CALLBACK_DISPATCHER_HH #endif // LIBPEPADAPTER_CALLBACK_DISPATCHER_HH
constant_time_algo.cc → src/constant_time_algo.cc
View file @ b5f0227a
...@@ -3,19 +3,17 @@ ...@@ -3,19 +3,17 @@
#include "constant_time_algo.hh" #include "constant_time_algo.hh"
namespace pEp namespace pEp {
{ bool constant_time_equal(const std::string &a, const std::string &b)
bool constant_time_equal(const std::string& a, const std::string& b)
{ {
if(a.size() != b.size()) if (a.size() != b.size())
return false; return false;
unsigned d = 0; unsigned d = 0;
for(std::size_t idx = 0; idx<a.size(); ++idx) for (std::size_t idx = 0; idx < a.size(); ++idx) {
{ d |= (static_cast<unsigned>(a[idx]) ^ static_cast<unsigned>(b[idx]));
d |= ( static_cast<unsigned>(a[idx]) ^ static_cast<unsigned>(b[idx]) );
} }
// if d is still 0, the strings are equal. // if d is still 0, the strings are equal.
return d == 0; return d == 0;
} }
......
constant_time_algo.hh → src/constant_time_algo.hh
View file @ b5f0227a
...@@ -6,14 +6,13 @@ ...@@ -6,14 +6,13 @@
#include <string> #include <string>
namespace pEp namespace pEp {
{
// Returns false if a.size() != b.size(). // Returns false if a.size() != b.size().
// Compares always _all_ characters of 'a' and 'b' so runtime does not // Compares always _all_ characters of 'a' and 'b' so runtime does not
// depends on the character position where the strings differ. // depends on the character position where the strings differ.
// Use this function instead of operator== if timing sidechannel attack // Use this function instead of operator== if timing sidechannel attack
// might be a security problem. // 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 } // end of namespace pEp
......
locked_queue.hh → src/locked_queue.hh
View file @ b5f0227a
...@@ -8,17 +8,15 @@ ...@@ -8,17 +8,15 @@
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
namespace utility namespace utility {
{ template<class T, void (*Deleter)(T) = nullptr>
template<class T, void(*Deleter)(T) = nullptr> class locked_queue {
class locked_queue typedef std::recursive_mutex Mutex;
{ typedef std::unique_lock<Mutex> Lock;
typedef std::recursive_mutex Mutex;
typedef std::unique_lock<Mutex> Lock; int _waiting = 0;
Mutex _mtx;
int _waiting = 0; std::condition_variable_any _cv;
Mutex _mtx;
std::condition_variable_any _cv;
std::deque<T> _q; std::deque<T> _q;
public: public:
...@@ -30,10 +28,8 @@ namespace utility ...@@ -30,10 +28,8 @@ namespace utility
void clear() void clear()
{ {
Lock L(_mtx); Lock L(_mtx);
if(Deleter != nullptr) if (Deleter != nullptr) {
{ for (auto q : _q) {
for(auto q : _q)
{
Deleter(q); Deleter(q);
} }
} }
...@@ -63,7 +59,7 @@ namespace utility ...@@ -63,7 +59,7 @@ namespace utility
T pop_back() T pop_back()
{ {
Lock L(_mtx); Lock L(_mtx);
_cv.wait(L, [&]{ return !_q.empty(); } ); _cv.wait(L, [&] { return !_q.empty(); });
T r{std::move(_q.back())}; T r{std::move(_q.back())};
_q.pop_back(); _q.pop_back();
return r; return r;
...@@ -74,7 +70,7 @@ namespace utility ...@@ -74,7 +70,7 @@ namespace utility
T pop_front() T pop_front()
{ {
Lock L(_mtx); Lock L(_mtx);
_cv.wait(L, [&]{ return !_q.empty(); } ); _cv.wait(L, [&] { return !_q.empty(); });
T r{std::move(_q.front())}; T r{std::move(_q.front())};
_q.pop_front(); _q.pop_front();
return r; return r;
...@@ -86,30 +82,28 @@ namespace utility ...@@ -86,30 +82,28 @@ namespace utility
{ {
Lock L(_mtx); Lock L(_mtx);
++_waiting; ++_waiting;
if(! _cv.wait_until(L, end_time, [this]{ return !_q.empty(); } ) ) if (!_cv.wait_until(L, end_time, [this] { return !_q.empty(); })) {
{
--_waiting; --_waiting;
return false; return false;
} }
--_waiting; --_waiting;
out = std::move(_q.back()); out = std::move(_q.back());
_q.pop_back(); _q.pop_back();
return true; return true;
} }
// returns true and set a copy of the first element and pop it from queue if there is any // 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' // 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) bool try_pop_front(T& out, std::chrono::steady_clock::time_point end_time)
{ {
Lock L(_mtx); Lock L(_mtx);
++_waiting; ++_waiting;
if(! _cv.wait_until(L, end_time, [this]{ return !_q.empty(); } ) ) if (!_cv.wait_until(L, end_time, [this] { return !_q.empty(); })) {
{
--_waiting; --_waiting;
return false; return false;
} }
--_waiting; --_waiting;
out = std::move(_q.front()); out = std::move(_q.front());
_q.pop_front(); _q.pop_front();
...@@ -122,12 +116,11 @@ namespace utility ...@@ -122,12 +116,11 @@ namespace utility
{ {
Lock L(_mtx); Lock L(_mtx);
++_waiting; ++_waiting;
if(! _cv.wait_for(L, duration, [this]{ return !_q.empty(); } ) ) if (!_cv.wait_for(L, duration, [this] { return !_q.empty(); })) {
{
--_waiting; --_waiting;
return false; return false;
} }
--_waiting; --_waiting;
out = std::move(_q.front()); out = std::move(_q.front());
_q.pop_front(); _q.pop_front();
......
message_cache.cc → src/message_cache.cc
View file @ b5f0227a
...@@ -20,67 +20,58 @@ namespace pEp { ...@@ -20,67 +20,58 @@ namespace pEp {
} }
PEP_STATUS MessageCache::cache_decrypt_message( PEP_STATUS MessageCache::cache_decrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
message **dst, message **dst,
stringlist_t **keylist, stringlist_t **keylist,
PEP_rating *rating, PEP_rating *rating,
PEP_decrypt_flags_t *flags PEP_decrypt_flags_t *flags)
)
{ {
return message_cache.decrypt_message(session, src, dst, keylist, return message_cache.decrypt_message(session, src, dst, keylist, rating, flags);
rating, flags);
} }
PEP_STATUS MessageCache::cache_mime_encode_message( PEP_STATUS MessageCache::cache_mime_encode_message(
int one, int one,
const message * msg, const message *msg,
bool omit_fields, bool omit_fields,
char **mimetext, char **mimetext,
bool has_pEp_msg_attachment bool has_pEp_msg_attachment)
)
{ {
which _one = (which) one; which _one = (which)one;
return message_cache.mime_encode_message(_one, msg, omit_fields, return message_cache.mime_encode_message(_one, msg, omit_fields, mimetext, has_pEp_msg_attachment);
mimetext, has_pEp_msg_attachment);
} }
PEP_STATUS MessageCache::cache_mime_decode_message( PEP_STATUS MessageCache::cache_mime_decode_message(
const char *mimetext, const char *mimetext,
size_t size, size_t size,
message **msg, message **msg,
bool* has_possible_pEp_msg bool *has_possible_pEp_msg)
)
{ {
return message_cache.mime_decode_message(mimetext, size, msg, return message_cache.mime_decode_message(mimetext, size, msg, has_possible_pEp_msg);
has_possible_pEp_msg);
} }
PEP_STATUS MessageCache::cache_encrypt_message( PEP_STATUS MessageCache::cache_encrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
stringlist_t *extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags)
)
{ {
return message_cache.encrypt_message(session, src, extra, dst, return message_cache.encrypt_message(session, src, extra, dst, enc_format, flags);
enc_format, flags);
} }
PEP_STATUS MessageCache::cache_encrypt_message_for_self( PEP_STATUS MessageCache::cache_encrypt_message_for_self(
PEP_SESSION session, PEP_SESSION session,
pEp_identity* target_id, pEp_identity *target_id,
message *src, message *src,
stringlist_t* extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags)
)
{ {
return message_cache.encrypt_message_for_self(session, target_id, src, return message_cache
extra, dst, enc_format, flags); .encrypt_message_for_self(session, target_id, src, extra, dst, enc_format, flags);
} }
PEP_STATUS MessageCache::cache_release(std::string id) PEP_STATUS MessageCache::cache_release(std::string id)
...@@ -96,8 +87,8 @@ namespace pEp { ...@@ -96,8 +87,8 @@ namespace pEp {
::free_message(_cache.at(id).src); ::free_message(_cache.at(id).src);
::free_message(_cache.at(id).dst); ::free_message(_cache.at(id).dst);
_cache.erase(id); _cache.erase(id);
} catch (...) {
} }
catch (...) { }
} }
static char *dup(const char *src) static char *dup(const char *src)
...@@ -105,7 +96,7 @@ namespace pEp { ...@@ -105,7 +96,7 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
char * dst = ::strdup(src); char *dst = ::strdup(src);
assert(dst); assert(dst);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -118,7 +109,7 @@ namespace pEp { ...@@ -118,7 +109,7 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
::timestamp * dst = ::timestamp_dup(src); ::timestamp *dst = ::timestamp_dup(src);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -130,7 +121,7 @@ namespace pEp { ...@@ -130,7 +121,7 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
::pEp_identity * dst = ::identity_dup(src); ::pEp_identity *dst = ::identity_dup(src);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -142,7 +133,7 @@ namespace pEp { ...@@ -142,7 +133,7 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
::identity_list * dst = ::identity_list_dup(src); ::identity_list *dst = ::identity_list_dup(src);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -154,7 +145,7 @@ namespace pEp { ...@@ -154,7 +145,7 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
::stringlist_t * dst = ::stringlist_dup(src); ::stringlist_t *dst = ::stringlist_dup(src);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -166,19 +157,19 @@ namespace pEp { ...@@ -166,19 +157,19 @@ namespace pEp {
if (!src) if (!src)
return nullptr; return nullptr;
::stringpair_list_t * dst = ::stringpair_list_dup(src); ::stringpair_list_t *dst = ::stringpair_list_dup(src);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
return dst; return dst;
} }
static ::message_ref_list *dup(const ::message_ref_list *src) { static ::message_ref_list *dup(const ::message_ref_list *src)
{
if (!src) if (!src)
return nullptr; return nullptr;
::message_ref_list *dst = (::message_ref_list *) ::calloc(1, ::message_ref_list *dst = (::message_ref_list *)::calloc(1, sizeof(::message_ref_list));
sizeof(::message_ref_list));
assert(dst); assert(dst);
if (!dst) if (!dst)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -187,8 +178,7 @@ namespace pEp { ...@@ -187,8 +178,7 @@ namespace pEp {
for (const message_ref_list *s = src; s; s = s->next) { for (const message_ref_list *s = src; s; s = s->next) {
d->msg_ref = s->msg_ref; d->msg_ref = s->msg_ref;
if (s->next) { if (s->next) {
d->next = (::message_ref_list *) ::calloc(1, d->next = (::message_ref_list *)::calloc(1, sizeof(::message_ref_list));
sizeof(::message_ref_list));
assert(d); assert(d);
if (!d) if (!d)
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -223,7 +213,7 @@ namespace pEp { ...@@ -223,7 +213,7 @@ namespace pEp {
dst->longmsg = dup("pEp"); dst->longmsg = dup("pEp");
else if (!emptystr(src->longmsg_formatted)) else if (!emptystr(src->longmsg_formatted))
dst->longmsg_formatted = dup("<pEp/>"); dst->longmsg_formatted = dup("<pEp/>");
// attachments are never copied // attachments are never copied
dst->rawmsg_ref = src->rawmsg_ref; dst->rawmsg_ref = src->rawmsg_ref;
...@@ -251,9 +241,9 @@ namespace pEp { ...@@ -251,9 +241,9 @@ namespace pEp {
if (_id == "") { if (_id == "") {
dst->opt_fields = dup(src->opt_fields); dst->opt_fields = dup(src->opt_fields);
} } else {
else { dst->opt_fields = ::new_stringpair_list(
dst->opt_fields = ::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID", _id.c_str())); ::new_stringpair("X-pEp-Adapter-Cache-ID", _id.c_str()));
if (!dst->opt_fields) if (!dst->opt_fields)
throw std::bad_alloc(); throw std::bad_alloc();
dst->opt_fields->next = dup(src->opt_fields); dst->opt_fields->next = dup(src->opt_fields);
...@@ -262,20 +252,19 @@ namespace pEp { ...@@ -262,20 +252,19 @@ namespace pEp {
return dst; return dst;
} }
static void correctAttachmentsOrder(bloblist_t*& bl) static void correctAttachmentsOrder(bloblist_t *&bl)
{ {
// only execute if there are exactly two attachments, both with // only execute if there are exactly two attachments, both with
// a non-empty MIME type // a non-empty MIME type
if (bl && bl->next && !bl->next->next && !emptystr(bl->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 // if this is most likely an PGP/MIME compliant format then correct
// order of attachments // order of attachments
if (std::string(bl->mime_type) == "application/octet-stream" && if (std::string(bl->mime_type) == "application/octet-stream" &&
std::string(bl->next->mime_type) == std::string(bl->next->mime_type) == "application/pgp-encrypted") {
"application/pgp-encrypted") {
bloblist_t *one = bl->next; bloblist_t *one = bl->next;
bloblist_t *two = bl; bloblist_t *two = bl;
bl = one; bl = one;
...@@ -285,7 +274,7 @@ namespace pEp { ...@@ -285,7 +274,7 @@ namespace pEp {
} }
} }
static void swapContent(::message*& part, ::message*& full) static void swapContent(::message *&part, ::message *&full)
{ {
free(part->longmsg); free(part->longmsg);
part->longmsg = full->longmsg; part->longmsg = full->longmsg;
...@@ -301,13 +290,12 @@ namespace pEp { ...@@ -301,13 +290,12 @@ namespace pEp {
} }
PEP_STATUS MessageCache::decrypt_message( PEP_STATUS MessageCache::decrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
message **dst, message **dst,
stringlist_t **keylist, stringlist_t **keylist,
PEP_rating *rating, PEP_rating *rating,
PEP_decrypt_flags_t *flags PEP_decrypt_flags_t *flags)
)
{ {
if (!src || cacheID(src) == "") if (!src || cacheID(src) == "")
return PEP_ILLEGAL_VALUE; return PEP_ILLEGAL_VALUE;
...@@ -324,8 +312,7 @@ namespace pEp { ...@@ -324,8 +312,7 @@ namespace pEp {
correctAttachmentsOrder(src->attachments); correctAttachmentsOrder(src->attachments);
::message *_dst = nullptr; ::message *_dst = nullptr;
PEP_STATUS status = ::decrypt_message(session, src, &_dst, keylist, PEP_STATUS status = ::decrypt_message(session, src, &_dst, keylist, rating, flags);
rating, flags);
*dst = empty_message_copy(_dst, _id); *dst = empty_message_copy(_dst, _id);
{ {
...@@ -338,12 +325,11 @@ namespace pEp { ...@@ -338,12 +325,11 @@ namespace pEp {
} }
PEP_STATUS MessageCache::mime_encode_message( PEP_STATUS MessageCache::mime_encode_message(
which one, which one,
const message * msg, const message *msg,
bool omit_fields, bool omit_fields,
char **mimetext, char **mimetext,
bool has_pEp_msg_attachment bool has_pEp_msg_attachment)
)
{ {
if (!msg || cacheID(msg) == "") if (!msg || cacheID(msg) == "")
return PEP_ILLEGAL_VALUE; return PEP_ILLEGAL_VALUE;
...@@ -357,16 +343,14 @@ namespace pEp { ...@@ -357,16 +343,14 @@ namespace pEp {
std::lock_guard<std::mutex> l(_mtx); std::lock_guard<std::mutex> l(_mtx);
::message *_src = _cache.at(cacheID(msg)).src; ::message *_src = _cache.at(cacheID(msg)).src;
swapContent(_msg, _src); swapContent(_msg, _src);
} } else /* msg_dst */ {
else /* msg_dst */ {
std::lock_guard<std::mutex> l(_mtx); std::lock_guard<std::mutex> l(_mtx);
::message *_dst = _cache.at(cacheID(msg)).dst; ::message *_dst = _cache.at(cacheID(msg)).dst;
swapContent(_msg, _dst); swapContent(_msg, _dst);
} }
removeCacheID(_msg); removeCacheID(_msg);
PEP_STATUS status = ::mime_encode_message(_msg, omit_fields, mimetext, PEP_STATUS status = ::mime_encode_message(_msg, omit_fields, mimetext, has_pEp_msg_attachment);
has_pEp_msg_attachment);
::free_message(_msg); ::free_message(_msg);
cache_release(cacheID(msg)); cache_release(cacheID(msg));
...@@ -374,7 +358,7 @@ namespace pEp { ...@@ -374,7 +358,7 @@ namespace pEp {
return status; return status;
} }
void MessageCache::generateCacheID(::message* msg) void MessageCache::generateCacheID(::message *msg)
{ {
std::string _range = std::to_string(id_range); std::string _range = std::to_string(id_range);
std::string _id = std::to_string(next_id++); std::string _id = std::to_string(next_id++);
...@@ -383,18 +367,15 @@ namespace pEp { ...@@ -383,18 +367,15 @@ namespace pEp {
// if opt_fields is an empty list generate a new list // if opt_fields is an empty list generate a new list
if (!msg->opt_fields || !msg->opt_fields->value) { if (!msg->opt_fields || !msg->opt_fields->value) {
free_stringpair_list(msg->opt_fields); free_stringpair_list(msg->opt_fields);
msg->opt_fields = msg->opt_fields = ::new_stringpair_list(
::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID", ::new_stringpair("X-pEp-Adapter-Cache-ID", cid.c_str()));
cid.c_str()));
if (!msg->opt_fields) if (!msg->opt_fields)
throw std::bad_alloc(); throw std::bad_alloc();
} } else {
else {
// add the cache ID as first field to an existing list // add the cache ID as first field to an existing list
auto spl = msg->opt_fields; auto spl = msg->opt_fields;
msg->opt_fields = msg->opt_fields = ::new_stringpair_list(
::new_stringpair_list(::new_stringpair("X-pEp-Adapter-Cache-ID", ::new_stringpair("X-pEp-Adapter-Cache-ID", cid.c_str()));
cid.c_str()));
if (!msg->opt_fields) { if (!msg->opt_fields) {
msg->opt_fields = spl; msg->opt_fields = spl;
throw std::bad_alloc(); throw std::bad_alloc();
...@@ -403,12 +384,11 @@ namespace pEp { ...@@ -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) { for (auto spl = msg->opt_fields; spl && spl->value; spl = spl->next) {
assert(spl->value->key); assert(spl->value->key);
if (spl->value->key && std::string(spl->value->key) == if (spl->value->key && std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
"X-pEp-Adapter-Cache-ID") {
assert(spl->value->value); assert(spl->value->value);
if (spl->value->value) if (spl->value->value)
return spl->value->value; return spl->value->value;
...@@ -418,27 +398,22 @@ namespace pEp { ...@@ -418,27 +398,22 @@ namespace pEp {
} }
return ""; 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 the first element in the list is the cache ID then skip
if (msg->opt_fields && msg->opt_fields->value && if (msg->opt_fields && msg->opt_fields->value && msg->opt_fields->value->key &&
msg->opt_fields->value->key && std::string(msg->opt_fields->value->key) == "X-pEp-Adapter-Cache-ID") {
std::string(msg->opt_fields->value->key) ==
"X-pEp-Adapter-Cache-ID") {
auto n = msg->opt_fields->next; auto n = msg->opt_fields->next;
msg->opt_fields->next = nullptr; msg->opt_fields->next = nullptr;
::free_stringpair_list(msg->opt_fields); ::free_stringpair_list(msg->opt_fields);
msg->opt_fields = n; msg->opt_fields = n;
} } else {
else {
// go through the list and remove // go through the list and remove
::stringpair_list_t *prev = nullptr; ::stringpair_list_t *prev = nullptr;
for (auto spl = msg->opt_fields; spl && spl->value; spl = for (auto spl = msg->opt_fields; spl && spl->value; spl = spl->next) {
spl->next) {
assert(spl->value->key); assert(spl->value->key);
if (spl->value->key && if (spl->value->key && std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
std::string(spl->value->key) == "X-pEp-Adapter-Cache-ID") {
auto next = spl->next; auto next = spl->next;
spl->next = nullptr; spl->next = nullptr;
::free_stringpair_list(spl); ::free_stringpair_list(spl);
...@@ -451,37 +426,34 @@ namespace pEp { ...@@ -451,37 +426,34 @@ namespace pEp {
} }
PEP_STATUS MessageCache::mime_decode_message( PEP_STATUS MessageCache::mime_decode_message(
const char *mimetext, const char *mimetext,
size_t size, size_t size,
message **msg, message **msg,
bool* has_possible_pEp_msg bool *has_possible_pEp_msg)
)
{ {
::message *_msg = nullptr; ::message *_msg = nullptr;
PEP_STATUS status = ::mime_decode_message(mimetext, size, &_msg, PEP_STATUS status = ::mime_decode_message(mimetext, size, &_msg, has_possible_pEp_msg);
has_possible_pEp_msg);
if (status) if (status)
return status; return status;
generateCacheID(_msg); *msg = empty_message_copy(_msg); generateCacheID(_msg);
*msg = empty_message_copy(_msg);
{ {
std::lock_guard<std::mutex> l(_mtx); std::lock_guard<std::mutex> l(_mtx);
message_cache._cache.emplace(std::make_pair(cacheID(_msg), message_cache._cache.emplace(std::make_pair(cacheID(_msg), cache_entry(_msg, nullptr)));
cache_entry(_msg, nullptr)));
} }
return status; return status;
} }
PEP_STATUS MessageCache::encrypt_message( PEP_STATUS MessageCache::encrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
stringlist_t *extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags)
)
{ {
::message *_msg; ::message *_msg;
std::string _id = cacheID(src); std::string _id = cacheID(src);
...@@ -492,8 +464,7 @@ namespace pEp { ...@@ -492,8 +464,7 @@ namespace pEp {
} }
::message *_dst = nullptr; ::message *_dst = nullptr;
PEP_STATUS status = ::encrypt_message(session, src, extra, &_dst, PEP_STATUS status = ::encrypt_message(session, src, extra, &_dst, enc_format, flags);
enc_format, flags);
*dst = empty_message_copy(_dst, _id); *dst = empty_message_copy(_dst, _id);
{ {
...@@ -507,14 +478,13 @@ namespace pEp { ...@@ -507,14 +478,13 @@ namespace pEp {
} }
PEP_STATUS MessageCache::encrypt_message_for_self( PEP_STATUS MessageCache::encrypt_message_for_self(
PEP_SESSION session, PEP_SESSION session,
pEp_identity* target_id, pEp_identity *target_id,
message *src, message *src,
stringlist_t* extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags)
)
{ {
::message *_msg; ::message *_msg;
std::string _id = cacheID(src); std::string _id = cacheID(src);
...@@ -525,8 +495,14 @@ namespace pEp { ...@@ -525,8 +495,14 @@ namespace pEp {
} }
::message *_dst = nullptr; ::message *_dst = nullptr;
PEP_STATUS status = ::encrypt_message_for_self(session, target_id, src, PEP_STATUS status = ::encrypt_message_for_self(
extra, &_dst, enc_format, flags); session,
target_id,
src,
extra,
&_dst,
enc_format,
flags);
*dst = empty_message_copy(_dst, _id); *dst = empty_message_copy(_dst, _id);
{ {
...@@ -538,5 +514,4 @@ namespace pEp { ...@@ -538,5 +514,4 @@ namespace pEp {
return status; return status;
} }
}; }; // namespace pEp
message_cache.hh → src/message_cache.hh
View file @ b5f0227a
...@@ -13,8 +13,7 @@ ...@@ -13,8 +13,7 @@
namespace pEp { namespace pEp {
class MessageCache { class MessageCache {
struct cache_entry { struct cache_entry {
cache_entry(::message *s, ::message *d) cache_entry(::message *s, ::message *d) : src(s), dst(d) {}
: src(s), dst(d) { }
::message *src; ::message *src;
::message *dst; ::message *dst;
...@@ -30,106 +29,100 @@ namespace pEp { ...@@ -30,106 +29,100 @@ namespace pEp {
public: public:
MessageCache(); MessageCache();
enum which { msg_src = 0, msg_dst = 1 }; enum which
{
msg_src = 0,
msg_dst = 1
};
static PEP_STATUS cache_mime_decode_message( static PEP_STATUS cache_mime_decode_message(
const char *mimetext, const char *mimetext,
size_t size, size_t size,
message **msg, message **msg,
bool* has_possible_pEp_msg bool *has_possible_pEp_msg);
);
static PEP_STATUS cache_mime_encode_message( static PEP_STATUS cache_mime_encode_message(
int one, int one,
const message * msg, const message *msg,
bool omit_fields, bool omit_fields,
char **mimetext, char **mimetext,
bool has_pEp_msg_attachment bool has_pEp_msg_attachment);
);
static PEP_STATUS cache_decrypt_message( static PEP_STATUS cache_decrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
message **dst, message **dst,
stringlist_t **keylist, stringlist_t **keylist,
PEP_rating *rating, PEP_rating *rating,
PEP_decrypt_flags_t *flags PEP_decrypt_flags_t *flags);
);
static PEP_STATUS cache_encrypt_message(
static PEP_STATUS cache_encrypt_message( PEP_SESSION session,
PEP_SESSION session, message *src,
message *src, stringlist_t *extra,
stringlist_t *extra, message **dst,
message **dst, PEP_enc_format enc_format,
PEP_enc_format enc_format, PEP_encrypt_flags_t flags);
PEP_encrypt_flags_t flags
);
static PEP_STATUS cache_encrypt_message_for_self( static PEP_STATUS cache_encrypt_message_for_self(
PEP_SESSION session, PEP_SESSION session,
pEp_identity* target_id, pEp_identity *target_id,
message *src, message *src,
stringlist_t* extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags);
);
static PEP_STATUS cache_release(std::string id); static PEP_STATUS cache_release(std::string id);
static void removeCacheID(::message* msg); static void removeCacheID(::message *msg);
protected: protected:
void release(std::string id); void release(std::string id);
PEP_STATUS mime_decode_message( PEP_STATUS mime_decode_message(
const char *mimetext, const char *mimetext,
size_t size, size_t size,
message **msg, message **msg,
bool* has_possible_pEp_msg bool *has_possible_pEp_msg);
);
PEP_STATUS mime_encode_message( PEP_STATUS mime_encode_message(
which one, which one,
const message * src, const message *src,
bool omit_fields, bool omit_fields,
char **mimetext, char **mimetext,
bool has_pEp_msg_attachment bool has_pEp_msg_attachment);
);
PEP_STATUS decrypt_message( PEP_STATUS decrypt_message(
PEP_SESSION session, PEP_SESSION session,
message *src, message *src,
message **dst, message **dst,
stringlist_t **keylist, stringlist_t **keylist,
PEP_rating *rating, PEP_rating *rating,
PEP_decrypt_flags_t *flags PEP_decrypt_flags_t *flags);
);
PEP_STATUS encrypt_message(
PEP_STATUS encrypt_message( PEP_SESSION session,
PEP_SESSION session, message *src,
message *src, stringlist_t *extra,
stringlist_t *extra, message **dst,
message **dst, PEP_enc_format enc_format,
PEP_enc_format enc_format, PEP_encrypt_flags_t flags);
PEP_encrypt_flags_t flags
);
PEP_STATUS encrypt_message_for_self( PEP_STATUS encrypt_message_for_self(
PEP_SESSION session, PEP_SESSION session,
pEp_identity* target_id, pEp_identity *target_id,
message *src, message *src,
stringlist_t* extra, stringlist_t *extra,
message **dst, message **dst,
PEP_enc_format enc_format, PEP_enc_format enc_format,
PEP_encrypt_flags_t flags PEP_encrypt_flags_t flags);
);
void generateCacheID(::message *msg);
void generateCacheID(::message* msg); static std::string cacheID(const ::message *msg);
static std::string cacheID(const ::message* msg);
}; };
extern MessageCache message_cache; extern MessageCache message_cache;
}; }; // namespace pEp
#endif // LIBPEPADAPTER_MESSAGE_CACHE_HH #endif // LIBPEPADAPTER_MESSAGE_CACHE_HH
src/pEpLog.cc 0 → 100644
View file @ b5f0227a
// 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
View file @ b5f0227a
...@@ -29,34 +29,36 @@ ...@@ -29,34 +29,36 @@
// use set_enabled_<backend>(bool) to turn logging on/off per backend // use set_enabled_<backend>(bool) to turn logging on/off per backend
#ifdef NDEBUG #ifdef NDEBUG
#define pEpLog(msg) do{}while(0) #define pEpLog(msg) \
do { \
} while (0)
#else #else
#ifdef ANDROID #ifdef ANDROID
#include <android/log.h> #include <android/log.h>
#endif #endif
#define pEpLog(msg) \ #define pEpLog(msg) \
do { \ do { \
std::stringstream msg_ss; \ std::stringstream msg_ss; \
msg_ss << std::this_thread::get_id() << " - " << __FILE__ << "::" << __FUNCTION__ << " - " << msg; \ msg_ss << std::this_thread::get_id() << " - " << __FILE__ << "::" << __FUNCTION__ \
pEp::Adapter::pEpLog::log(msg_ss.str()); \ << " - " << msg; \
} while(0) pEp::Adapter::pEpLog::log(msg_ss.str()); \
} while (0)
#endif // NDEBUG #endif // NDEBUG
namespace pEp { namespace pEp {
namespace Adapter { namespace Adapter {
namespace pEpLog { 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 } // namespace pEpLog
} // Adapter } // namespace Adapter
} // pEp } // namespace pEp
#endif // LIBPEPADAPTER_PEPLOG_HH #endif // LIBPEPADAPTER_PEPLOG_HH
passphrase_cache.cc → src/passphrase_cache.cc
View file @ b5f0227a
...@@ -9,19 +9,19 @@ ...@@ -9,19 +9,19 @@
pEp::PassphraseCache pEp::passphrase_cache; pEp::PassphraseCache pEp::passphrase_cache;
namespace pEp { namespace pEp {
PassphraseCache::cache_entry::cache_entry(const std::string& p, time_point t) : PassphraseCache::cache_entry::cache_entry(const std::string& p, time_point t)
passphrase{p, 0, PassphraseCache::cache_entry::max_len}, tp{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()), PassphraseCache::PassphraseCache(size_t max_size, duration timeout)
first_time(true) : _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}, PassphraseCache::PassphraseCache(const PassphraseCache& second)
_timeout{second._timeout}, _stored{second._stored}, : _cache{second._cache}, _max_size{second._max_size}, _timeout{second._timeout},
_which(_cache.end()), first_time(true) _stored{second._stored}, _which(_cache.end()), first_time(true)
{ {
cleanup(); cleanup();
} }
...@@ -36,16 +36,16 @@ namespace pEp { ...@@ -36,16 +36,16 @@ namespace pEp {
return *this; return *this;
} }
const char *PassphraseCache::add(const std::string& passphrase) const char* PassphraseCache::add(const std::string& passphrase)
{ {
if (!passphrase.empty()) { if (!passphrase.empty()) {
const char *result = nullptr; const char* result = nullptr;
{ {
std::lock_guard<std::mutex> lock(_mtx); std::lock_guard<std::mutex> lock(_mtx);
while (_cache.size() >= _max_size) while (_cache.size() >= _max_size)
_cache.pop_front(); _cache.pop_front();
_cache.push_back({passphrase, clock::now()}); _cache.push_back({passphrase, clock::now()});
auto back = _cache.end(); auto back = _cache.end();
assert(!_cache.empty()); assert(!_cache.empty());
...@@ -55,11 +55,11 @@ namespace pEp { ...@@ -55,11 +55,11 @@ namespace pEp {
return result; return result;
} }
static const char *empty = ""; static const char* empty = "";
return 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); std::lock_guard<std::mutex> lock(_stored_mtx);
_stored = passphrase; _stored = passphrase;
...@@ -81,7 +81,7 @@ namespace pEp { ...@@ -81,7 +81,7 @@ namespace pEp {
std::lock_guard<std::mutex> lock(_mtx); std::lock_guard<std::mutex> lock(_mtx);
cleanup(); cleanup();
for (auto entry=_cache.begin(); entry!=_cache.end(); ++entry) { for (auto entry = _cache.begin(); entry != _cache.end(); ++entry) {
if (callee(entry->passphrase)) { if (callee(entry->passphrase)) {
refresh(entry); refresh(entry);
return true; return true;
...@@ -104,7 +104,7 @@ namespace pEp { ...@@ -104,7 +104,7 @@ namespace pEp {
_cache.splice(_cache.end(), _cache, entry); _cache.splice(_cache.end(), _cache, entry);
} }
const char *PassphraseCache::latest_passphrase(PassphraseCache& c) const char* PassphraseCache::latest_passphrase(PassphraseCache& c)
{ {
if (c.first_time) { if (c.first_time) {
c.cleanup(); c.cleanup();
...@@ -128,8 +128,8 @@ namespace pEp { ...@@ -128,8 +128,8 @@ namespace pEp {
return c._which->passphrase.c_str(); 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 pEp::PassphraseCache _copy;
static bool new_copy = true; static bool new_copy = true;
...@@ -146,16 +146,14 @@ namespace pEp { ...@@ -146,16 +146,14 @@ namespace pEp {
try { try {
::config_passphrase(session ? session : Adapter::session(), latest_passphrase(_copy)); ::config_passphrase(session ? session : Adapter::session(), latest_passphrase(_copy));
return PEP_STATUS_OK; return PEP_STATUS_OK;
} } catch (pEp::PassphraseCache::Empty&) {
catch (pEp::PassphraseCache::Empty&) {
new_copy = true; new_copy = true;
return PEP_PASSPHRASE_REQUIRED; return PEP_PASSPHRASE_REQUIRED;
} } catch (pEp::PassphraseCache::Exhausted&) {
catch (pEp::PassphraseCache::Exhausted&) {
new_copy = true; new_copy = true;
return PEP_WRONG_PASSPHRASE; return PEP_WRONG_PASSPHRASE;
} }
} }
PEP_STATUS PassphraseCache::ensure_passphrase(PEP_SESSION session, std::string fpr) PEP_STATUS PassphraseCache::ensure_passphrase(PEP_SESSION session, std::string fpr)
{ {
...@@ -172,5 +170,4 @@ namespace pEp { ...@@ -172,5 +170,4 @@ namespace pEp {
return status; return status;
} }
}; }; // namespace pEp
passphrase_cache.hh → src/passphrase_cache.hh
View file @ b5f0227a
...@@ -20,7 +20,7 @@ namespace pEp { ...@@ -20,7 +20,7 @@ namespace pEp {
struct cache_entry { struct cache_entry {
static const size_t max_len = 250 * 4; 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; std::string passphrase;
time_point tp; time_point tp;
...@@ -39,30 +39,30 @@ namespace pEp { ...@@ -39,30 +39,30 @@ namespace pEp {
public: public:
struct Empty : public std::underflow_error { 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 { 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(size_t max_size = 20, duration timeout = std::chrono::minutes(10));
~PassphraseCache() { } ~PassphraseCache() {}
PassphraseCache(const PassphraseCache& second); PassphraseCache(const PassphraseCache& second);
PassphraseCache& operator=(const PassphraseCache& second); PassphraseCache& operator=(const PassphraseCache& second);
// adds the passphrase to the cache, which will timeout // adds the passphrase to the cache, which will timeout
// returns a ptr to the passsword entry in the cache. Don't free() it! // 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 // 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 // call this function inside the messageToSend() implementation of the adapter
// this function is using latest_passphrase() to test one passphrase after the // this function is using latest_passphrase() to test one passphrase after the
// other until the cache is exhausted // other until the cache is exhausted
// call with reset = true to reset the iterator // 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 // convenience functions
// i.e. // i.e.
...@@ -71,10 +71,10 @@ namespace pEp { ...@@ -71,10 +71,10 @@ namespace pEp {
// status = ::encrypt_message(session, src, extra, dst, enc_format, flags) // status = ::encrypt_message(session, src, extra, dst, enc_format, flags)
// using for_each_passphrase() // using for_each_passphrase()
template<typename... A> PEP_STATUS api(PEP_STATUS f(PEP_SESSION, A...), template<typename... A>
PEP_SESSION session, A... 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)>; using passphrase_callee = std::function<bool(std::string)>;
bool for_each_passphrase(const passphrase_callee& callee); bool for_each_passphrase(const passphrase_callee& callee);
PEP_STATUS ensure_passphrase(PEP_SESSION session, std::string fpr); PEP_STATUS ensure_passphrase(PEP_SESSION session, std::string fpr);
...@@ -85,7 +85,7 @@ namespace pEp { ...@@ -85,7 +85,7 @@ namespace pEp {
}; };
extern PassphraseCache passphrase_cache; extern PassphraseCache passphrase_cache;
}; }; // namespace pEp
#include "passphrase_cache.hxx" #include "passphrase_cache.hxx"
......
passphrase_cache.hxx → src/passphrase_cache.hxx
View file @ b5f0227a
...@@ -7,8 +7,8 @@ ...@@ -7,8 +7,8 @@
#include "passphrase_cache.hh" #include "passphrase_cache.hh"
namespace pEp { namespace pEp {
template<typename... A> PEP_STATUS PassphraseCache::api( template<typename... A>
PEP_STATUS f(PEP_SESSION, A...), PEP_SESSION session, A... a) PEP_STATUS PassphraseCache::api(PEP_STATUS f(PEP_SESSION, A...), PEP_SESSION session, A... a)
{ {
PEP_STATUS status; PEP_STATUS status;
...@@ -18,12 +18,11 @@ namespace pEp { ...@@ -18,12 +18,11 @@ namespace pEp {
return true; return true;
status = f(session, a...); status = f(session, a...);
return status != PEP_PASSPHRASE_REQUIRED && return status != PEP_PASSPHRASE_REQUIRED && status != PEP_WRONG_PASSPHRASE;
status != PEP_WRONG_PASSPHRASE;
}); });
return status; return status;
} }
}; }; // namespace pEp
#endif // LIBPEPADAPTER_PASSPHRASE_CACHE_HXX #endif // LIBPEPADAPTER_PASSPHRASE_CACHE_HXX
slurp.cc → src/slurp.cc
View file @ b5f0227a
...@@ -6,20 +6,16 @@ ...@@ -6,20 +6,16 @@
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
namespace pEp namespace pEp {
{ std::string slurp(const std::string& filename)
std::string slurp(const std::string& filename)
{
std::ifstream input(filename.c_str(), std::ios_base::binary);
if(!input)
{ {
throw std::runtime_error("Cannot read file \"" + filename + "\"! "); 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();
}
std::stringstream sstr;
sstr << input.rdbuf();
return sstr.str();
}
} // end of namespace pEp } // end of namespace pEp
slurp.hh → src/slurp.hh
View file @ b5f0227a
...@@ -6,8 +6,7 @@ ...@@ -6,8 +6,7 @@
#include <string> #include <string>
namespace pEp namespace pEp {
{
// reads a whole file and returns it as std::string // 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. // throws std::runtime_error() if the file cannot be read. Empty file is not an error.
std::string slurp(const std::string& filename); std::string slurp(const std::string& filename);
......
src/status_to_string.cc 0 → 100644
View file @ b5f0227a
// 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
View file @ b5f0227a
...@@ -8,12 +8,11 @@ ...@@ -8,12 +8,11 @@
#include <pEp/status_to_string.h> #include <pEp/status_to_string.h>
#include <string> #include <string>
namespace pEp namespace pEp {
{
// creates a textual string (returned by pep_status_to_string() ) and the numerical status value. // 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. // in pEpEngine.h positive values are in hex value, negatives in decimal. So we follow this.
std::string status_to_string(PEP_STATUS status); std::string status_to_string(PEP_STATUS status);
} // end of namespace pEp } // end of namespace pEp
#endif // LIBPEPADAPTER_STATUS_TO_STRING_HH #endif // LIBPEPADAPTER_STATUS_TO_STRING_HH
status_to_string.cc deleted 100644 → 0
View file @ 1270d147
// 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
View file @ b5f0227a
include ../Makefile.conf include ../Makefile.conf
LDFLAGS=-L../ $(ENGINE_LIB) LDFLAGS=-L../src $(ENGINE_LIB)
LDLIBS=-lstdc++ -lpEpEngine -lpEpAdapter 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) SRC=$(wildcard test_*.cc)
TST=$(subst .cc,,$(SRC)) TST=$(subst .cc,,$(SRC))
...@@ -13,7 +12,7 @@ $(TST): framework.o ...@@ -13,7 +12,7 @@ $(TST): framework.o
.PHONY: clean rmtestdata .PHONY: clean rmtestdata
clean: clean:
rm -f $(TST) rm -f $(TST)
rm -Rf *.dSYM rm -Rf *.dSYM
rm -f *.o rm -f *.o
......
test/framework.cc
View file @ b5f0227a
#include "framework.hh" // This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "framework.hh"
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
...@@ -20,6 +22,8 @@ ...@@ -20,6 +22,8 @@
#include <pEp/sync_codec.h> #include <pEp/sync_codec.h>
#include <pEp/distribution_codec.h> #include <pEp/distribution_codec.h>
#include <Adapter.hh>
pEp::Test::Transport pEp::Test::transport; pEp::Test::Transport pEp::Test::transport;
std::string pEp::Test::path; std::string pEp::Test::path;
extern std::thread pEp::Adapter::_sync_thread; extern std::thread pEp::Adapter::_sync_thread;
...@@ -28,7 +32,7 @@ namespace pEp { ...@@ -28,7 +32,7 @@ namespace pEp {
namespace Test { namespace Test {
using namespace Adapter; using namespace Adapter;
void setup(vector<string>& args) void setup(vector<string> &args)
{ {
#ifdef WIN32 #ifdef WIN32
string dir = getenv("TEMP"); string dir = getenv("TEMP");
...@@ -45,17 +49,15 @@ namespace pEp { ...@@ -45,17 +49,15 @@ namespace pEp {
cout << "usage: " << args[0] << " [--dir HOME]" << endl; cout << "usage: " << args[0] << " [--dir HOME]" << endl;
#endif #endif
exit(0); exit(0);
} } else if (args[1] == "--dir" && args.size() == 3) {
else if (args[1] == "--dir" && args.size() == 3) {
dir = args[2]; dir = args[2];
} } else {
else {
cerr << "illegal parameter" << endl; cerr << "illegal parameter" << endl;
exit(1); exit(1);
} }
} }
char _path[MAXPATHLEN+1]; char _path[MAXPATHLEN + 1];
const char *templ = dir.c_str(); const char *templ = dir.c_str();
strcpy(_path, templ); strcpy(_path, templ);
mkdtemp(_path); mkdtemp(_path);
...@@ -71,8 +73,8 @@ namespace pEp { ...@@ -71,8 +73,8 @@ namespace pEp {
void setup(int argc, char **argv) void setup(int argc, char **argv)
{ {
vector<string> args{(size_t) argc}; vector<string> args{ (size_t)argc };
for (int i=0; i<argc; ++i) for (int i = 0; i < argc; ++i)
args[i] = argv[i]; args[i] = argv[i];
setup(args); setup(args);
...@@ -81,9 +83,12 @@ namespace pEp { ...@@ -81,9 +83,12 @@ namespace pEp {
void import_key_from_file(string filename) void import_key_from_file(string filename)
{ {
ifstream f(filename, ifstream::in); 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; ::identity_list *il = NULL;
PEP_STATUS status = ::import_key(session(), key.c_str(), key.length(), &il); cout << key.c_str() << endl;
cout << key.length() << endl;
::PEP_STATUS status = ::import_key(session(), key.c_str(), key.length(), &il);
throw_status(status);
assert(status == PEP_KEY_IMPORTED); assert(status == PEP_KEY_IMPORTED);
::free_identity_list(il); ::free_identity_list(il);
} }
...@@ -95,14 +100,18 @@ namespace pEp { ...@@ -95,14 +100,18 @@ namespace pEp {
Identity make_identity(::pEp_identity *ident) 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 mime_parse(string text)
{ {
::message *msg; ::message *msg;
bool has_possible_pEp_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); throw_status(status);
return make_message(msg); return make_message(msg);
} }
...@@ -123,9 +132,9 @@ namespace pEp { ...@@ -123,9 +132,9 @@ namespace pEp {
::message *_dst; ::message *_dst;
stringlist_t *keylist; stringlist_t *keylist;
PEP_rating rating; ::PEP_rating rating;
PEP_decrypt_flags_t flags = 0; ::PEP_decrypt_flags_t flags = 0;
PEP_STATUS status = ::decrypt_message(session(), msg.get(), &_dst, &keylist, &rating, &flags); ::PEP_STATUS status = ::decrypt_message(session(), msg.get(), &_dst, &keylist, &rating, &flags);
throw_status(status); throw_status(status);
Message dst; Message dst;
...@@ -138,18 +147,17 @@ namespace pEp { ...@@ -138,18 +147,17 @@ namespace pEp {
for (auto a = dst.get()->attachments; a && a->value; a = a->next) { for (auto a = dst.get()->attachments; a && a->value; a = a->next) {
if (string("application/pEp.sync") == a->mime_type) { if (string("application/pEp.sync") == a->mime_type) {
char *_text; 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); throw_status(status);
text += _text; text += _text;
pEp_free(_text); ::pEp_free(_text);
return text; return text;
} } else if (string("application/pEp.distribution") == a->mime_type) {
else if (string("application/pEp.distribution") == a->mime_type) {
char *_text; 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); throw_status(status);
text += _text; text += _text;
pEp_free(_text); ::pEp_free(_text);
return text; return text;
} }
} }
...@@ -171,11 +179,10 @@ namespace pEp { ...@@ -171,11 +179,10 @@ namespace pEp {
return msg; return msg;
} }
void Transport::send(Message msg) void Transport::send(Message msg)
{ {
mkdir(outbox_path.c_str(), 0770); mkdir(outbox_path.c_str(), 0770);
} }
}; }; // namespace Test
}; }; // namespace pEp
test/framework.hh
View file @ b5f0227a
// This file is under GNU General Public License 3.0 // This file is under GNU General Public License 3.0
// see LICENSE.txt // see LICENSE.txt
#ifndef LIBPEPADAPTER_FRAMEWORK_HH #ifndef LIBPEPADAPTER_FRAMEWORK_HH
#define LIBPEPADAPTER_FRAMEWORK_HH #define LIBPEPADAPTER_FRAMEWORK_HH
...@@ -7,22 +8,22 @@ ...@@ -7,22 +8,22 @@
#include <vector> #include <vector>
#include <memory> #include <memory>
#include "Adapter.hh" #include <pEp/message.h>
namespace pEp { namespace pEp {
namespace Test { namespace Test {
using namespace std; using namespace std;
// manually set up test // manually set up test
void setup(vector<string>& args); void setup(vector<string> &args);
// call this in main() for auto set up // 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); void import_key_from_file(string filename);
using Message = shared_ptr<::message>; 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 // use this instead of constructor to auto assign ::free_message as
// deleter // deleter
...@@ -57,7 +58,7 @@ namespace pEp { ...@@ -57,7 +58,7 @@ namespace pEp {
extern Transport transport; extern Transport transport;
extern string path; extern string path;
}; }; // namespace Test
}; }; // namespace pEp
#endif // LIBPEPADAPTER_FRAMEWORK_HH #endif // LIBPEPADAPTER_FRAMEWORK_HH
test/test_adapter.cc
View file @ b5f0227a
...@@ -6,11 +6,15 @@ ...@@ -6,11 +6,15 @@
#include <assert.h> #include <assert.h>
#include <unistd.h> #include <unistd.h>
#include <sys/param.h> #include <sys/param.h>
#include <pEpLog.hh>
#include <Adapter.hh>
#include <pEp/sync_api.h>
#include <pEp/keymanagement.h> #include <pEp/keymanagement.h>
#include "pEpLog.hh" #include <pEp/message_api.h>
using namespace std; using namespace std;
using namespace pEp::Adapter; using namespace pEp;
PEP_STATUS messageToSend(struct _message *msg) PEP_STATUS messageToSend(struct _message *msg)
{ {
...@@ -18,7 +22,7 @@ PEP_STATUS messageToSend(struct _message *msg) ...@@ -18,7 +22,7 @@ PEP_STATUS messageToSend(struct _message *msg)
return PEP_STATUS_OK; 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()"); pEpLog("called()");
return PEP_STATUS_OK; return PEP_STATUS_OK;
...@@ -26,14 +30,14 @@ PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handsha ...@@ -26,14 +30,14 @@ PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handsha
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
pEp::Test::setup(argc, argv); Test::setup(argc, argv);
// Create new identity // Create new identity
pEpLog("updating or creating identity for me"); 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); assert(me);
PEP_STATUS status = myself(session(), me); ::PEP_STATUS status = ::myself(Adapter::session(), me);
free_identity(me); ::free_identity(me);
pEp::throw_status(status); pEp::throw_status(status);
// start and stop sync repeatedly // start and stop sync repeatedly
...@@ -44,10 +48,10 @@ int main(int argc, char **argv) ...@@ -44,10 +48,10 @@ int main(int argc, char **argv)
pEpLog(i); pEpLog(i);
pEpLog("SYNC START"); pEpLog("SYNC START");
pEpLog("starting the adapter including sync"); pEpLog("starting the adapter including sync");
startup(messageToSend, notifyHandshake); Adapter::startup(messageToSend, notifyHandshake);
pEpLog("SYNC STOP"); pEpLog("SYNC STOP");
usleep(sleepuSec); usleep(sleepuSec);
shutdown(); Adapter::shutdown();
} }
return 0; return 0;
} }
test/test_adapter_cxx.cc
View file @ b5f0227a
...@@ -5,55 +5,69 @@ ...@@ -5,55 +5,69 @@
#include <iostream> #include <iostream>
#include <assert.h> #include <assert.h>
#include <unistd.h> #include <unistd.h>
#include <pEp/keymanagement.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) { PEP_STATUS messageToSend(struct _message *msg)
pEpLog("called"); {
return PEP_STATUS_OK; pEpLog("called");
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; pEpLog("called");
return PEP_STATUS_OK;
} }
class JNISync { class JNISync {
public: public:
void onSyncStartup() { void onSyncStartup()
pEpLog("called"); {
} pEpLog("called");
}
void onSyncShutdown() { void onSyncShutdown()
pEpLog("called"); {
} pEpLog("called");
}
} o; } o;
int main(int argc, char **argv) { int main(int argc, char **argv)
{
pEp::Test::setup(argc, argv); pEp::Test::setup(argc, argv);
// Create new identity // Create new identity
pEpLog("updating or creating identity for me"); 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); assert(me);
PEP_STATUS status = myself(session(), me); ::PEP_STATUS status = ::myself(Adapter::session(), me);
free_identity(me); ::free_identity(me);
pEp::throw_status(status); throw_status(status);
// start and stop sync repeatedly // start and stop sync repeatedly
useconds_t sleepuSec = 1000 * 100; useconds_t sleepuSec = 1000 * 100;
unsigned long long int nrIters = 1000 * 1000 * 1000; unsigned long long int nrIters = 1000 * 1000 * 1000;
for (int i = 0; i < nrIters; i++) { for (int i = 0; i < nrIters; i++) {
pEpLog("RUN NR: "); pEpLog("RUN NR: ");
pEpLog(i); pEpLog(i);
pEpLog("SYNC START"); pEpLog("SYNC START");
pEpLog("starting the adapter including sync"); pEpLog("starting the adapter including sync");
startup<JNISync>(messageToSend, notifyHandshake, &o, &JNISync::onSyncStartup, &JNISync::onSyncShutdown); Adapter::startup<JNISync>(
pEpLog("SYNC STOP"); messageToSend,
usleep(sleepuSec); notifyHandshake,
shutdown(); &o,
} &JNISync::onSyncStartup,
return 0; &JNISync::onSyncShutdown);
pEpLog("SYNC STOP");
usleep(sleepuSec);
Adapter::shutdown();
}
return 0;
} }
test/test_ensure_passphrase.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
...@@ -9,18 +12,18 @@ ...@@ -9,18 +12,18 @@
#include "framework.hh" #include "framework.hh"
#include "passphrase_cache.hh" #include <passphrase_cache.hh>
#include "status_to_string.hh" #include <status_to_string.hh>
#include <Adapter.hh>
#include <pEp/message_api.h> #include <pEp/message_api.h>
#include <pEp/keymanagement.h> #include <pEp/keymanagement.h>
#include <pEp/key_reset.h> #include <pEp/key_reset.h>
using namespace pEp; using namespace pEp;
using namespace pEp::Adapter;
using namespace std; using namespace std;
int main(int argc, char **argv) int main(int argc, char** argv)
{ {
Test::setup(argc, argv); Test::setup(argc, argv);
...@@ -28,7 +31,8 @@ int main(int argc, char **argv) ...@@ -28,7 +31,8 @@ int main(int argc, char **argv)
passphrase_cache.add("cathy"); passphrase_cache.add("cathy");
passphrase_cache.add("bob"); 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* bob_fpr = "5C76378A62B04CF3F41BEC8D4940FC9FA1878736";
const char* erwin_filename = ENGINE_TEST "/test_keys/erwin_normal_encrypted.pgp"; const char* erwin_filename = ENGINE_TEST "/test_keys/erwin_normal_encrypted.pgp";
...@@ -37,15 +41,15 @@ int main(int argc, char **argv) ...@@ -37,15 +41,15 @@ int main(int argc, char **argv)
Test::import_key_from_file(bob_filename); Test::import_key_from_file(bob_filename);
Test::import_key_from_file(erwin_filename); Test::import_key_from_file(erwin_filename);
pEp_identity* bob = ::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog"); ::pEp_identity* bob = ::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog");
PEP_STATUS status = ::set_own_key(session(), bob, bob_fpr); ::PEP_STATUS status = ::set_own_key(Adapter::session(), bob, bob_fpr);
assert(status == PEP_STATUS_OK); assert(status == PEP_STATUS_OK);
pEp_identity* erwin = ::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin"); ::pEp_identity* erwin = ::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin");
status = ::set_own_key(session(), erwin, erwin_fpr); status = ::set_own_key(Adapter::session(), erwin, erwin_fpr);
assert(status == PEP_STATUS_OK); 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); assert(status == PEP_STATUS_OK);
::free_identity(bob); ::free_identity(bob);
...@@ -55,4 +59,3 @@ int main(int argc, char **argv) ...@@ -55,4 +59,3 @@ int main(int argc, char **argv)
return 0; return 0;
} }
test/test_leave_device_group.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <unistd.h> #include <unistd.h>
#include "framework.hh" #include "framework.hh"
#include "passphrase_cache.hh" #include <passphrase_cache.hh>
#include "callback_dispatcher.hh" #include <callback_dispatcher.hh>
#include <pEp/sync_api.h> #include <pEp/sync_api.h>
using namespace pEp;
using namespace pEp::Adapter;
using namespace std; using namespace std;
using namespace pEp;
vector<string> expected_msg = { "synchronizeGroupKeys",
"groupKeysUpdate",
"initUnledGroupKeyReset",
"beacon",
"beacon" };
vector<string> expected_msg = { vector<::sync_handshake_signal> expected_notification = { SYNC_NOTIFY_IN_GROUP,
"synchronizeGroupKeys", SYNC_NOTIFY_START,
"groupKeysUpdate", SYNC_NOTIFY_SOLE,
"initUnledGroupKeyReset", SYNC_NOTIFY_START,
"beacon", SYNC_NOTIFY_STOP };
"beacon"
}; ::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(); static auto actual = expected_msg.begin();
...@@ -37,11 +35,11 @@ PEP_STATUS test_messageToSend(::message *_msg) ...@@ -37,11 +35,11 @@ PEP_STATUS test_messageToSend(::message *_msg)
cerr << "expecting: " << *actual << endl; cerr << "expecting: " << *actual << endl;
cerr << text; cerr << text;
assert(text.find(*actual++) != string::npos); 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(); static auto actual = expected_notification.begin();
...@@ -50,20 +48,21 @@ PEP_STATUS test_notifyHandshake(pEp_identity *_me, pEp_identity *_partner, sync_ ...@@ -50,20 +48,21 @@ PEP_STATUS test_notifyHandshake(pEp_identity *_me, pEp_identity *_partner, sync_
cerr << "expecting: " << *actual << endl; cerr << "expecting: " << *actual << endl;
cerr << "notifyHandshake: " << signal << endl; cerr << "notifyHandshake: " << signal << endl;
assert(signal == *actual++); 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); Test::setup(argc, argv);
session(); Adapter::session();
// set up two own identites for sync // set up two own identites for sync
passphrase_cache.add("erwin"); passphrase_cache.add("erwin");
passphrase_cache.add("bob"); 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* bob_fpr = "5C76378A62B04CF3F41BEC8D4940FC9FA1878736";
const char* erwin_filename = ENGINE_TEST "/test_keys/erwin_normal_encrypted.pgp"; const char* erwin_filename = ENGINE_TEST "/test_keys/erwin_normal_encrypted.pgp";
...@@ -72,24 +71,26 @@ int main(int argc, char **argv) ...@@ -72,24 +71,26 @@ int main(int argc, char **argv)
Test::import_key_from_file(bob_filename); Test::import_key_from_file(bob_filename);
Test::import_key_from_file(erwin_filename); Test::import_key_from_file(erwin_filename);
Test::Identity bob = Test::make_identity(::new_identity("bob@example.org", bob_fpr, "BOB", "Bob Dog")); Test::Identity bob = Test::make_identity(
PEP_STATUS status = ::set_own_key(session(), bob.get(), bob_fpr); ::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); 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); assert(status == PEP_STATUS_OK);
Test::Identity erwin = Test::make_identity(::new_identity("erwin@example.org", erwin_fpr, "BOB", "Bob is Erwin")); Test::Identity erwin = Test::make_identity(
status = ::set_own_key(session(), erwin.get(), erwin_fpr); ::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); 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); assert(status == PEP_STATUS_OK);
// simulate a device group by setting the identities to in sync // 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(Adapter::session(), bob.get(), PEP_idf_devicegroup);
status = set_identity_flags(session(), erwin.get(), PEP_idf_devicegroup); status = ::set_identity_flags(Adapter::session(), erwin.get(), PEP_idf_devicegroup);
// register at callback_dispatcher and start sync // register at callback_dispatcher and start sync
...@@ -98,24 +99,24 @@ int main(int argc, char **argv) ...@@ -98,24 +99,24 @@ int main(int argc, char **argv)
// leave device group // leave device group
status = ::leave_device_group(session());
status = ::leave_device_group(Adapter::session());
// wait for sync shutdown and release first session // wait for sync shutdown and release first session
Test::join_sync_thread(); Test::join_sync_thread();
assert(!is_sync_running()); assert(!Adapter::is_sync_running());
// switch off and on again // switch off and on again
CallbackDispatcher::start_sync(); CallbackDispatcher::start_sync();
sleep(2); sleep(2);
assert(is_sync_running()); assert(Adapter::is_sync_running());
CallbackDispatcher::stop_sync(); CallbackDispatcher::stop_sync();
Test::join_sync_thread(); Test::join_sync_thread();
assert(!is_sync_running()); assert(!Adapter::is_sync_running());
session(Adapter::release); Adapter::session(Adapter::release);
return 0; return 0;
} }
test/test_library.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "pc_container.hh" #include "pc_container.hh"
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <thread> #include <thread>
using namespace pEp; using namespace pEp;
// Producer's data: // Producer's data:
class P class P {
{
public: public:
P(int i) P(int i) : data{ new char[64] }
: data{new char[64]} {
{ snprintf(data, 63, "%i", i);
snprintf(data, 63, "%i", i); }
}
P(const P&) = delete;
P(const P&) = delete; void operator=(const P&) = delete;
void operator=(const P&) = delete;
~P()
~P() {
{ std::cerr << "~P(): data=" << (data ? data : "(NULL)") << '\n';
std::cerr << "~P(): data=" << (data ? data : "(NULL)" ) << '\n'; delete[] data;
delete[] data; }
}
char* data;
char* data;
}; };
// Consumer's data: // Consumer's data:
class C class C {
{
public: public:
C(int _i) : i(_i) {} C(int _i) : i(_i) {}
int i; int i;
}; };
pc_container<P,C> pc; pc_container<P, C> pc;
void consumer_thread() void consumer_thread()
{ {
bool keep_running = true; bool keep_running = true;
int sum = 0; int sum = 0;
while(keep_running) while (keep_running) {
{ for (auto& q : pc) {
for(auto& q : pc) switch (q.state()) {
{ case PC_State::Created: {
switch(q.state()) const int value = atoi(q.pdata->data);
{ if (value < 0) {
case PC_State::Created: std::cerr << "Q\n";
{ keep_running = false;
const int value = atoi( q.pdata->data ); } else {
if(value<0) std::cerr << "C";
{ q.cdata = new C(value);
std::cerr << "Q\n"; sum += q.cdata->i;
keep_running = false; }
}else{ break;
std::cerr << "C"; }
q.cdata = new C( value ); case PC_State::Deleted: {
sum += q.cdata->i; std::cerr << "D";
} sum -= q.cdata->i;
break; delete q.cdata;
} break;
case PC_State::Deleted: }
{ case PC_State::Changed: {
std::cerr << "D"; std::cerr << "X";
sum -= q.cdata->i; sum -= q.cdata->i;
delete q.cdata; delete q.cdata;
break; q.cdata = new C(atoi(q.pdata->data));
} sum += q.cdata->i;
case PC_State::Changed: break;
{ }
std::cerr << "X"; default:
sum -= q.cdata->i; throw "Illegal state";
delete q.cdata; }
q.cdata = new C( atoi( q.pdata->data ) ); }
sum += q.cdata->i; }
break;
} std::cout << "Consumer sum: " << sum << ".\n";
default: throw "Illegal state";
}
}
}
std::cout << "Consumer sum: " << sum << ".\n";
} }
int main() int main()
{ {
for(int i=0; i<10; ++i) for (int i = 0; i < 10; ++i) {
{ pc.insert(new P(i));
pc.insert( new P(i) ); }
}
std::thread t{ &consumer_thread };
std::thread t{ &consumer_thread };
for (int i = 10; i < 100; ++i) {
for(int i=10; i<100; ++i) pc.insert(new P(i));
{ }
pc.insert( new P(i) );
} while (!pc.empty()) {
auto q = pc.begin();
while( !pc.empty() ) delete q->pdata;
{ pc.erase(q);
auto q = pc.begin(); }
delete q->pdata;
pc.erase( q ); pc.insert(new P(-1));
}
t.join();
pc.insert( new P(-1) );
t.join();
} }
test/test_message_cache.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "framework.hh"
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
#include <sys/param.h> #include <sys/param.h>
#include <unistd.h> #include <unistd.h>
#include "message_cache.hh" #include <message_cache.hh>
#include "framework.hh" #include <Adapter.hh>
using namespace std; using namespace std;
using namespace pEp; using namespace pEp;
...@@ -12,8 +16,8 @@ int main(int argc, char **argv) ...@@ -12,8 +16,8 @@ int main(int argc, char **argv)
{ {
Test::setup(argc, argv); Test::setup(argc, argv);
pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice"); ::pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice");
::myself(pEp::Adapter::session(), alice); ::myself(Adapter::session(), alice);
char *mime = strdup("From: Alice <alice@mail.com>\n" char *mime = strdup("From: Alice <alice@mail.com>\n"
"To: Bob <bob@mail.com>\n" "To: Bob <bob@mail.com>\n"
...@@ -25,20 +29,30 @@ int main(int argc, char **argv) ...@@ -25,20 +29,30 @@ int main(int argc, char **argv)
::message *src = nullptr; ::message *src = nullptr;
bool has_possible_pEp_msg; 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); assert(status == PEP_STATUS_OK);
status = ::myself(pEp::Adapter::session(), src->from); status = ::myself(Adapter::session(), src->from);
assert(status == PEP_STATUS_OK); 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); 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; ::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(status != PEP_ILLEGAL_VALUE);
assert(src->longmsg == nullptr); assert(src->longmsg == nullptr);
...@@ -65,11 +79,17 @@ int main(int argc, char **argv) ...@@ -65,11 +79,17 @@ int main(int argc, char **argv)
assert(src->longmsg == nullptr); assert(src->longmsg == nullptr);
assert(src->attachments == nullptr); assert(src->attachments == nullptr);
PEP_rating rating; ::PEP_rating rating;
PEP_decrypt_flags_t flags = 0; ::PEP_decrypt_flags_t flags = 0;
stringlist_t *keylist = nullptr; ::stringlist_t *keylist = nullptr;
status = MessageCache::cache_decrypt_message(pEp::Adapter::session(), src, &dst, &keylist, &rating, &flags); status = MessageCache::cache_decrypt_message(
Adapter::session(),
src,
&dst,
&keylist,
&rating,
&flags);
assert(status != PEP_ILLEGAL_VALUE); assert(status != PEP_ILLEGAL_VALUE);
assert(src->longmsg == nullptr); assert(src->longmsg == nullptr);
...@@ -92,7 +112,6 @@ int main(int argc, char **argv) ...@@ -92,7 +112,6 @@ int main(int argc, char **argv)
::free_identity(bob); ::free_identity(bob);
::free_identity(alice); ::free_identity(alice);
pEp::Adapter::session(pEp::Adapter::release); Adapter::session(Adapter::release);
return 0; return 0;
} }
test/test_passphrase_cache.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "framework.hh"
#include <iostream> #include <iostream>
#include <unistd.h> #include <unistd.h>
#include <assert.h> #include <assert.h>
#include <sys/param.h> #include <sys/param.h>
#include <passphrase_cache.hh>
#include <status_to_string.hh>
#include <Adapter.hh>
#include "framework.hh" using namespace pEp;
#include "passphrase_cache.hh"
#include "status_to_string.hh"
extern "C" { extern "C" {
PEP_STATUS api_test1(PEP_SESSION session, const char *str, char *bytes, int n, ::stringlist_t *sl) ::PEP_STATUS api_test1(::PEP_SESSION session, const char *str, char *bytes, int n, ::stringlist_t *sl)
{ {
std::cout << "called api_test1\n"; std::cout << "called api_test1\n";
return PEP_WRONG_PASSPHRASE; return PEP_WRONG_PASSPHRASE;
} }
PEP_STATUS api_test2(PEP_SESSION session, int n, const char *str, char *bytes, ::stringlist_t *sl) ::PEP_STATUS api_test2(::PEP_SESSION session, int n, const char *str, char *bytes, ::stringlist_t *sl)
{ {
std::cout << "called api_test2\n"; std::cout << "called api_test2\n";
return PEP_STATUS_OK; return PEP_STATUS_OK;
} }
}; };
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
pEp::Test::setup(argc, argv); Test::setup(argc, argv);
const char *str = "23"; const char *str = "23";
char *bytes = NULL; char *bytes = NULL;
int n = 42; int n = 42;
::stringlist_t *sl = NULL; ::stringlist_t *sl = NULL;
pEp::PassphraseCache cache{2, std::chrono::seconds(1)}; PassphraseCache cache{ 2, std::chrono::seconds(1) };
cache.add("say"); cache.add("say");
cache.add("hello"); cache.add("hello");
cache.add("world"); cache.add("world");
std::cout << "expected: two passphrases\n"; 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"; 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"; 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); 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); assert(status == PEP_STATUS_OK);
cache.add("hello"); cache.add("hello");
cache.add("world"); cache.add("world");
std::cout << "expected: two passphrases in reverse order\n"; std::cout << "expected: two passphrases in reverse order\n";
pEp::PassphraseCache _cache = cache; PassphraseCache _cache = cache;
try { try {
while (1) { while (1) {
std::cout << "'" << _cache.latest_passphrase(_cache) << "'\n"; std::cout << "'" << _cache.latest_passphrase(_cache) << "'\n";
} }
} catch (std::underflow_error &) {
} }
catch (std::underflow_error&) { }
pEp::passphrase_cache.add("hello"); passphrase_cache.add("hello");
pEp::passphrase_cache.add("world"); passphrase_cache.add("world");
std::cout << "two times PEP_STATUS_OK (0), one time PEP_WRONG_PASSPHRASE (2561)\n"; std::cout << "two times PEP_STATUS_OK (0), one time PEP_WRONG_PASSPHRASE (2561)\n";
do { do {
status = pEp::PassphraseCache::config_next_passphrase(); status = PassphraseCache::config_next_passphrase();
std::cout << pEp::status_to_string(status) << " (" << status << ")\n"; std::cout << status_to_string(status) << " (" << status << ")\n";
} while (status == PEP_STATUS_OK); } while (status == PEP_STATUS_OK);
sleep(2); sleep(2);
std::cout << "expected: no passphrase\n"; 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); 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); assert(status == PEP_STATUS_OK);
pEp::Adapter::session(pEp::Adapter::release); Adapter::session(Adapter::release);
return 0; return 0;
} }
test/test_semaphore.cc
View file @ b5f0227a
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include <iostream> #include <iostream>
#include <thread> #include <thread>
#include <unistd.h> #include <unistd.h>
...@@ -10,26 +13,25 @@ int main() ...@@ -10,26 +13,25 @@ int main()
{ {
Semaphore semaphore; Semaphore semaphore;
thread thread1([&](){ thread thread1([&]() {
cout << "1: before stop\n"; cout << "1: before stop\n";
semaphore.stop(); semaphore.stop();
cout << "1: now on stop\n"; cout << "1: now on stop\n";
semaphore.try_wait(); semaphore.try_wait();
cout << "1: and on go again\n"; cout << "1: and on go again\n";
semaphore.try_wait(); semaphore.try_wait();
cout << "1: keep going\n"; cout << "1: keep going\n";
}); });
sleep(1); sleep(1);
thread thread2([&](){ thread thread2([&]() {
cout << "2: setting go\n"; cout << "2: setting go\n";
semaphore.go(); semaphore.go();
}); });
thread1.join(); thread1.join();
thread2.join(); thread2.join();
return 0; return 0;
} }