heck
5 years ago
38 changed files with 2232 additions and 2148 deletions
@ -0,0 +1,22 @@ |
|||||
|
include Makefile.conf |
||||
|
|
||||
|
.PHONY: all build clean devenv envtest |
||||
|
|
||||
|
all: build_ext |
||||
|
|
||||
|
build_ext: |
||||
|
python3 setup.py build_ext $(BUILD_EXT_OPTS) |
||||
|
|
||||
|
clean: |
||||
|
rm -r $(BUILD_DIR) |
||||
|
|
||||
|
devenv: |
||||
|
LD_LIBRARY_PATH=$(PREFIX)/lib \
|
||||
|
DYLD_LIBRARY_PATH=$(PREFIX)/lib \
|
||||
|
PYTHONPATH=$PYTHONPATH:`pwd`/build/lib.linux-x86_64-3.7:\
|
||||
|
PYTHONPATH=$PYTHONPATH:`pwd`/build/lib.macosx-10.9-x86_64-3.8:\
|
||||
|
`pwd`/src \
|
||||
|
bash -l |
||||
|
|
||||
|
envtest: |
||||
|
python3 -c 'import pEp' |
||||
@ -0,0 +1,15 @@ |
|||||
|
HERE:=$(dir $(lastword $(MAKEFILE_LIST))) |
||||
|
|
||||
|
# Defaults
|
||||
|
DEBUG=0 |
||||
|
PREFIX?=$(HOME) |
||||
|
BUILD_DIR = ./build |
||||
|
|
||||
|
######### Overrides #########
|
||||
|
-include $(HERE)local.conf |
||||
|
|
||||
|
ifeq ($(DEBUG),1) |
||||
|
BUILD_EXT_OPTS+=--debug |
||||
|
endif |
||||
|
|
||||
|
BUILD_EXT_OPTS += --prefix=$(PREFIX) |
||||
@ -0,0 +1,11 @@ |
|||||
|
# This is an Example build config file (local.conf) |
||||
|
# you might not need this file, but if the defaults dont work for you |
||||
|
# You can override them here. |
||||
|
# Tweak the values to your needs and rename it to local.conf |
||||
|
|
||||
|
######### C++ Compiler ######### |
||||
|
# DEBUG=1 |
||||
|
# DEBUG=0 |
||||
|
|
||||
|
############# DIRS ############# |
||||
|
# PREFIX=$(HOME)/local |
||||
@ -1,97 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include "user_interface.hh" |
|
||||
#include <assert.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
Adapter::Adapter(bool unregister_this) |
|
||||
: flag_unregister(unregister_this) |
|
||||
{ |
|
||||
session(init); |
|
||||
} |
|
||||
|
|
||||
Adapter::~Adapter() |
|
||||
{ |
|
||||
session(release); |
|
||||
} |
|
||||
|
|
||||
PEP_SESSION Adapter::session(session_action action) |
|
||||
{ |
|
||||
lock_guard<mutex> lock(mtx()); |
|
||||
|
|
||||
thread_local static PEP_SESSION _session = nullptr; |
|
||||
thread_local int booked = 0; |
|
||||
PEP_STATUS status = PEP_STATUS_OK; |
|
||||
|
|
||||
switch (action) { |
|
||||
case release: |
|
||||
if (booked) |
|
||||
--booked; |
|
||||
if (!booked && _session) { |
|
||||
::release(_session); |
|
||||
_session = nullptr; |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case none: |
|
||||
if (_session) |
|
||||
break; |
|
||||
|
|
||||
case init: |
|
||||
++booked; |
|
||||
if (!_session) |
|
||||
status = ::init(&_session, _messageToSend, _inject_sync_event); |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
status = PEP_ILLEGAL_VALUE; |
|
||||
} |
|
||||
|
|
||||
if (status) |
|
||||
_throw_status(status); |
|
||||
|
|
||||
return _session; |
|
||||
} |
|
||||
|
|
||||
::utility::locked_queue< SYNC_EVENT > * Adapter::q = nullptr; |
|
||||
bool Adapter::flag_sync_enabled = false; |
|
||||
|
|
||||
void Adapter::shutdown_sync() |
|
||||
{ |
|
||||
if (queue_active()) |
|
||||
queue().push_front(nullptr); |
|
||||
flag_sync_enabled = false; |
|
||||
} |
|
||||
|
|
||||
PyObject *Adapter::ui_object(PyObject *value) |
|
||||
{ |
|
||||
lock_guard<mutex> lock(mtx()); |
|
||||
static PyObject *obj = nullptr; |
|
||||
if (value) |
|
||||
obj = value; |
|
||||
return obj; |
|
||||
} |
|
||||
|
|
||||
int Adapter::_inject_sync_event(SYNC_EVENT ev, void *management) |
|
||||
{ |
|
||||
if (!flag_sync_enabled) |
|
||||
return 1; |
|
||||
|
|
||||
if (is_sync_thread(adapter.session())) { |
|
||||
PEP_STATUS status = do_sync_protocol_step(adapter.session(), adapter.ui_object(), ev); |
|
||||
return status == PEP_STATUS_OK ? 0 : 1; |
|
||||
} |
|
||||
|
|
||||
try { |
|
||||
queue().push_back(ev); |
|
||||
} |
|
||||
catch (exception&) { |
|
||||
return 1; |
|
||||
} |
|
||||
return 0; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,59 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include "pEpmodule.hh" |
|
||||
#include "locked_queue.hh" |
|
||||
#include "user_interface.hh" |
|
||||
#include <pEp/sync_api.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
using Message = pEp::PythonAdapter::Message; |
|
||||
|
|
||||
class Adapter { |
|
||||
bool flag_unregister; |
|
||||
|
|
||||
public: |
|
||||
Adapter(bool unregister_this = false); |
|
||||
virtual ~Adapter(); |
|
||||
|
|
||||
enum session_action { |
|
||||
none = 0, |
|
||||
init, |
|
||||
release |
|
||||
}; |
|
||||
|
|
||||
PEP_SESSION session(session_action action = none); |
|
||||
static ::utility::locked_queue< SYNC_EVENT >& queue() |
|
||||
{ |
|
||||
if (!q) |
|
||||
q = new ::utility::locked_queue< SYNC_EVENT >(); |
|
||||
return *q; |
|
||||
} |
|
||||
void script_is_implementing_sync() { flag_sync_enabled = true; } |
|
||||
void shutdown_sync(); |
|
||||
bool is_sync_active() { return flag_sync_enabled; } |
|
||||
|
|
||||
protected: |
|
||||
static PyObject *ui_object(PyObject *value = nullptr); |
|
||||
static int _inject_sync_event(SYNC_EVENT ev, void *management); |
|
||||
|
|
||||
static ::utility::locked_queue< SYNC_EVENT > *q; |
|
||||
static bool flag_sync_enabled; |
|
||||
|
|
||||
bool queue_active() { return !!q; } |
|
||||
|
|
||||
private: |
|
||||
static mutex& mtx() |
|
||||
{ |
|
||||
static mutex m; |
|
||||
return m; |
|
||||
} |
|
||||
|
|
||||
friend class UserInterface_callback; |
|
||||
}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,161 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include "basic_api.hh" |
|
||||
#include <sstream> |
|
||||
#include <pEp/keymanagement.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
void update_identity(Identity& ident) |
|
||||
{ |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.user_id() == PEP_OWN_USERID) |
|
||||
throw runtime_error("update_identity: '" PEP_OWN_USERID |
|
||||
"' may only be used for own identities"); |
|
||||
|
|
||||
PEP_STATUS status = update_identity(adapter.session(), ident); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void myself(Identity& ident) |
|
||||
{ |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.username() == "") |
|
||||
throw invalid_argument("username needed"); |
|
||||
|
|
||||
if (ident.user_id() == "") |
|
||||
ident.user_id(ident.address()); |
|
||||
|
|
||||
PEP_STATUS status = myself(adapter.session(), ident); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
string _trustwords(Identity me, Identity partner, string lang, bool full) |
|
||||
{ |
|
||||
if (me.fpr() == "" || partner.fpr() == "") |
|
||||
throw invalid_argument("fingerprint needed in Identities"); |
|
||||
|
|
||||
if (lang == "" && me.lang() == partner.lang()) |
|
||||
lang = me.lang(); |
|
||||
|
|
||||
char *words = NULL; |
|
||||
size_t size = 0; |
|
||||
PEP_STATUS status = get_trustwords(adapter.session(), me, partner, |
|
||||
lang.c_str(),&words, &size, full); |
|
||||
_throw_status(status); |
|
||||
return words; |
|
||||
} |
|
||||
|
|
||||
void trust_personal_key(Identity ident) |
|
||||
{ |
|
||||
if (ident.fpr() == "") |
|
||||
throw invalid_argument("fingerprint needed in Identities"); |
|
||||
if (ident.user_id() == "") |
|
||||
throw invalid_argument("user_id must be provided"); |
|
||||
|
|
||||
PEP_STATUS status = trust_personal_key(adapter.session(), ident); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void set_identity_flags(Identity ident, identity_flags_t flags) |
|
||||
{ |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.user_id() == "") |
|
||||
throw invalid_argument("user_id needed"); |
|
||||
|
|
||||
PEP_STATUS status = set_identity_flags(adapter.session(), ident, flags); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void unset_identity_flags(Identity ident, identity_flags_t flags) |
|
||||
{ |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.user_id() == "") |
|
||||
throw invalid_argument("user_id needed"); |
|
||||
|
|
||||
PEP_STATUS status = unset_identity_flags(adapter.session(), ident, flags); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void key_reset_trust(Identity ident) |
|
||||
{ |
|
||||
if (ident.fpr() == "") |
|
||||
throw invalid_argument("fpr needed"); |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.user_id() == "") |
|
||||
throw invalid_argument("user_id needed"); |
|
||||
|
|
||||
PEP_STATUS status = key_reset_trust(adapter.session(), ident); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
|
|
||||
boost::python::list import_key(string key_data) |
|
||||
{ |
|
||||
::identity_list *private_keys = NULL; |
|
||||
PEP_STATUS status = ::import_key(adapter.session(), key_data.c_str(), key_data.size(), &private_keys); |
|
||||
if (status && status != PEP_KEY_IMPORTED) |
|
||||
_throw_status(status); |
|
||||
|
|
||||
auto result = boost::python::list(); |
|
||||
for (::identity_list *il = private_keys; il && il->ident; il=il->next) { |
|
||||
::pEp_identity *ident = ::identity_dup(il->ident); |
|
||||
if (!ident) { |
|
||||
free_identity_list(private_keys); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
result.append(Identity(ident)); |
|
||||
} |
|
||||
|
|
||||
free_identity_list(private_keys); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
string export_key(Identity ident) |
|
||||
{ |
|
||||
PEP_STATUS status = PEP_STATUS_OK; |
|
||||
char* key_data = NULL; |
|
||||
size_t size; |
|
||||
status = ::export_key(adapter.session(), ident.fpr().c_str(), &key_data, &size); |
|
||||
|
|
||||
_throw_status(status); |
|
||||
return key_data; |
|
||||
} |
|
||||
|
|
||||
string export_secret_key(Identity ident) |
|
||||
{ |
|
||||
PEP_STATUS status = PEP_STATUS_OK; |
|
||||
char* key_data = NULL; |
|
||||
size_t size; |
|
||||
status = ::export_secret_key(adapter.session(), ident.fpr().c_str(), &key_data, &size); |
|
||||
|
|
||||
_throw_status(status); |
|
||||
return key_data; |
|
||||
} |
|
||||
|
|
||||
void set_own_key(Identity& ident, string fpr) |
|
||||
{ |
|
||||
if (ident.address() == "") |
|
||||
throw invalid_argument("address needed"); |
|
||||
if (ident.username() == "") |
|
||||
throw invalid_argument("username needed"); |
|
||||
if (ident.user_id() == "") |
|
||||
throw invalid_argument("user_id needed"); |
|
||||
if (fpr == "") |
|
||||
throw invalid_argument("fpr needed"); |
|
||||
|
|
||||
|
|
||||
const char* fpr_c = fpr.c_str(); |
|
||||
PEP_STATUS status = set_own_key(adapter.session(), ident, fpr_c); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,25 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include "pEpmodule.hh" |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
void update_identity(Identity& ident); |
|
||||
void myself(Identity& ident); |
|
||||
string _trustwords(Identity me, Identity partner, string lang, bool full); |
|
||||
void trust_personal_key(Identity ident); |
|
||||
|
|
||||
void set_identity_flags(Identity ident, identity_flags_t flags); |
|
||||
void unset_identity_flags(Identity ident, identity_flags_t flags); |
|
||||
|
|
||||
void key_reset_trust(Identity ident); |
|
||||
|
|
||||
boost::python::list import_key(string key_data); |
|
||||
string export_key(Identity ident); |
|
||||
string export_secret_key(Identity ident); |
|
||||
void set_own_key(Identity& ident, string fpr); |
|
||||
} |
|
||||
} |
|
||||
@ -1,278 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include "identity.hh" |
|
||||
#include "pEpmodule.hh" |
|
||||
#include "basic_api.hh" |
|
||||
#include "message_api.hh" |
|
||||
#include <typeinfo> |
|
||||
#include <sstream> |
|
||||
#include <pEp/identity_list.h> |
|
||||
#include <pEp/keymanagement.h> |
|
||||
#include <pEp/key_reset.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
|
|
||||
Identity::Identity(string address, string username, string user_id, |
|
||||
string fpr, int comm_type, string lang, identity_flags_t flags) |
|
||||
: _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), |
|
||||
username.c_str()), &::free_identity) |
|
||||
{ |
|
||||
if (!_ident) |
|
||||
throw bad_alloc(); |
|
||||
_ident->comm_type = (PEP_comm_type) comm_type; |
|
||||
_ident->flags = (identity_flags_t) flags; |
|
||||
this->lang(lang); |
|
||||
} |
|
||||
|
|
||||
Identity::Identity(const Identity& second) |
|
||||
: _ident(second._ident) |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Identity::Identity(pEp_identity *ident) |
|
||||
: _ident(ident, &::free_identity) |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Identity::~Identity() |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Identity::operator pEp_identity *() |
|
||||
{ |
|
||||
return _ident.get(); |
|
||||
} |
|
||||
|
|
||||
Identity::operator const pEp_identity *() const |
|
||||
{ |
|
||||
return _ident.get(); |
|
||||
} |
|
||||
|
|
||||
string Identity::_repr() |
|
||||
{ |
|
||||
stringstream build; |
|
||||
build << "Identity("; |
|
||||
string address; |
|
||||
if (_ident->address) |
|
||||
address = string(_ident->address); |
|
||||
build << repr(address) << ", "; |
|
||||
string username; |
|
||||
if (_ident->username) |
|
||||
username = string(_ident->username); |
|
||||
build << repr(username) << ", "; |
|
||||
string user_id; |
|
||||
if (_ident->user_id) |
|
||||
user_id = string(_ident->user_id); |
|
||||
build << repr(user_id) << ", "; |
|
||||
string fpr; |
|
||||
if (_ident->fpr) |
|
||||
fpr = string(_ident->fpr); |
|
||||
build << repr(fpr) << ", "; |
|
||||
build << (int) _ident->comm_type << ", "; |
|
||||
string lang = _ident->lang; |
|
||||
build << repr(lang) << ")"; |
|
||||
return build.str(); |
|
||||
} |
|
||||
|
|
||||
string Identity::_str() |
|
||||
{ |
|
||||
if (!(_ident->address && _ident->address[0])) |
|
||||
return ""; |
|
||||
if (!(_ident->username && _ident->username[0])) |
|
||||
return _ident->address; |
|
||||
return string(_ident->username) + " <" + _ident->address + ">"; |
|
||||
} |
|
||||
|
|
||||
void Identity::username(string value) |
|
||||
{ |
|
||||
if (value.length() && value.length() < 5) |
|
||||
throw length_error("username must be at least 5 characters"); |
|
||||
|
|
||||
str_attr(_ident->username, value); |
|
||||
} |
|
||||
|
|
||||
void Identity::lang(string value) |
|
||||
{ |
|
||||
if (value == "") |
|
||||
memset(_ident->lang, 0, 3); |
|
||||
else if (value.length() != 2) |
|
||||
throw length_error("length of lang must be 2"); |
|
||||
else |
|
||||
memcpy(_ident->lang, value.c_str(), 3); |
|
||||
} |
|
||||
|
|
||||
string Identity::lang() |
|
||||
{ |
|
||||
return _ident->lang; |
|
||||
} |
|
||||
|
|
||||
int Identity::rating() |
|
||||
{ |
|
||||
if (!(_ident->address)) |
|
||||
throw invalid_argument("address must be given"); |
|
||||
|
|
||||
PEP_rating rating = PEP_rating_undefined; |
|
||||
PEP_STATUS status = ::identity_rating(adapter.session(), _ident.get(), &rating); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
return (int) rating; |
|
||||
} |
|
||||
|
|
||||
PEP_color Identity::color() |
|
||||
{ |
|
||||
return _color(rating()); |
|
||||
} |
|
||||
|
|
||||
Identity Identity::copy() |
|
||||
{ |
|
||||
pEp_identity *dup = ::identity_dup(*this); |
|
||||
if (!dup) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
return Identity(dup); |
|
||||
} |
|
||||
|
|
||||
Identity Identity::deepcopy(dict&) |
|
||||
{ |
|
||||
return copy(); |
|
||||
} |
|
||||
|
|
||||
void Identity::update() |
|
||||
{ |
|
||||
update_identity(*this); |
|
||||
} |
|
||||
|
|
||||
void Identity::key_reset(string fpr) |
|
||||
{ |
|
||||
PEP_STATUS status = ::key_reset_identity(adapter.session(), *this, |
|
||||
fpr != "" ? fpr.c_str() : nullptr); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void Identity::key_mistrusted() |
|
||||
{ |
|
||||
PEP_STATUS status = ::key_mistrusted(adapter.session(), *this); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
bool Identity::is_pEp_user() |
|
||||
{ |
|
||||
bool result; |
|
||||
PEP_STATUS status = ::is_pEp_user(adapter.session(), *this, &result); |
|
||||
_throw_status(status); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
void Identity::enable_for_sync() |
|
||||
{ |
|
||||
PEP_STATUS status = ::enable_identity_for_sync(adapter.session(), *this); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
void Identity::disable_for_sync() |
|
||||
{ |
|
||||
PEP_STATUS status = ::disable_identity_for_sync(adapter.session(), *this); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
Myself::Myself(string address, string username, string user_id, string lang) |
|
||||
: Identity(address, username, user_id, "", 0, lang) |
|
||||
|
|
||||
{ |
|
||||
if (!(address.length() && username.length())) |
|
||||
throw invalid_argument("address and username must be set"); |
|
||||
if (lang.length() && lang.length() != 2) |
|
||||
throw length_error("lang must be an ISO 639-1 language code or empty"); |
|
||||
|
|
||||
// FIXME: should set .me
|
|
||||
// _ident->me = true;
|
|
||||
if (user_id.length()) |
|
||||
throw runtime_error("user_id feature not yet implemented for Myself"); |
|
||||
} |
|
||||
|
|
||||
void Myself::update() |
|
||||
{ |
|
||||
pEp::PythonAdapter::myself(*this); |
|
||||
} |
|
||||
|
|
||||
Identity identity_attr(pEp_identity *&ident) |
|
||||
{ |
|
||||
if (!ident) |
|
||||
throw out_of_range("no identity assigned"); |
|
||||
|
|
||||
pEp_identity *_dup = identity_dup(ident); |
|
||||
if (!_dup) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
Identity _ident(_dup); |
|
||||
return _ident; |
|
||||
} |
|
||||
|
|
||||
void identity_attr(pEp_identity *&ident, object value) |
|
||||
{ |
|
||||
Identity& _ident = extract< Identity& >(value); |
|
||||
pEp_identity *_dup = ::identity_dup(_ident); |
|
||||
if (!_dup) |
|
||||
throw bad_alloc(); |
|
||||
PEP_STATUS status = update_identity(adapter.session(), _dup); |
|
||||
_throw_status(status); |
|
||||
free_identity(ident); |
|
||||
ident = _dup; |
|
||||
} |
|
||||
|
|
||||
boost::python::list identitylist_attr(identity_list *&il) |
|
||||
{ |
|
||||
boost::python::list result; |
|
||||
|
|
||||
for (identity_list *_il = il; _il && _il->ident; _il = _il->next) { |
|
||||
pEp_identity *ident = ::identity_dup(_il->ident); |
|
||||
if (!ident) |
|
||||
throw bad_alloc(); |
|
||||
result.append(object(Identity(ident))); |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
void identitylist_attr(identity_list *&il, boost::python::list value) |
|
||||
{ |
|
||||
identity_list *_il = new_identity_list(NULL); |
|
||||
if (!_il) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
identity_list *_i = _il; |
|
||||
for (int i=0; i<len(value); i++) { |
|
||||
extract< Identity& > extract_identity(value[i]); |
|
||||
if (!extract_identity.check()) { |
|
||||
free_identity_list(_il); |
|
||||
} |
|
||||
pEp_identity *_ident = extract_identity(); |
|
||||
pEp_identity *_dup = ::identity_dup(_ident); |
|
||||
if (!_dup) { |
|
||||
free_identity_list(_il); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
PEP_STATUS status = update_identity(adapter.session(), _dup); |
|
||||
if (status != PEP_STATUS_OK) { |
|
||||
free_identity_list(_il); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
_i = identity_list_add(_i, _dup); |
|
||||
if (!_i) { |
|
||||
free_identity_list(_il); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
free_identity_list(il); |
|
||||
il = _il; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,90 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <boost/python.hpp> |
|
||||
#include <pEp/pEpEngine.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
#include <string> |
|
||||
#include <memory> |
|
||||
#include <cstddef> |
|
||||
#include "str_attr.hh" |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
using namespace utility; |
|
||||
using namespace std; |
|
||||
|
|
||||
// Identity is owning a pEp_identity
|
|
||||
|
|
||||
class Identity { |
|
||||
protected: |
|
||||
shared_ptr< pEp_identity > _ident; |
|
||||
|
|
||||
public: |
|
||||
Identity(string address = "", string username = "", |
|
||||
string user_id = "", string fpr = "", int comm_type = 0, |
|
||||
string lang = "", identity_flags_t flags = 0); |
|
||||
|
|
||||
Identity(const Identity& second); |
|
||||
Identity(pEp_identity *ident); |
|
||||
virtual ~Identity(); |
|
||||
operator pEp_identity *(); |
|
||||
operator const pEp_identity *() const; |
|
||||
|
|
||||
string _repr(); |
|
||||
string _str(); |
|
||||
|
|
||||
string address() { return str_attr(_ident->address); } |
|
||||
void address(string value) { str_attr(_ident->address, value); } |
|
||||
|
|
||||
string fpr() { return str_attr(_ident->fpr); } |
|
||||
void fpr(string value) { str_attr(_ident->fpr, value); } |
|
||||
|
|
||||
string user_id() { return str_attr(_ident->user_id); } |
|
||||
void user_id(string value) { str_attr(_ident->user_id, value); } |
|
||||
|
|
||||
string username() { return str_attr(_ident->username); } |
|
||||
void username(string value); |
|
||||
|
|
||||
PEP_comm_type comm_type() { return _ident->comm_type; } |
|
||||
void comm_type(PEP_comm_type value) { _ident->comm_type = value; }; |
|
||||
|
|
||||
std::string lang(); |
|
||||
void lang(std::string value); |
|
||||
|
|
||||
identity_flags_t flags() { return _ident->flags; } |
|
||||
void flags(identity_flags_t flags) { _ident->flags = flags; } |
|
||||
|
|
||||
int rating(); |
|
||||
PEP_color color(); |
|
||||
|
|
||||
Identity copy(); |
|
||||
Identity deepcopy(dict& memo); |
|
||||
|
|
||||
virtual void update(); |
|
||||
|
|
||||
void key_reset(string fpr=""); |
|
||||
void key_mistrusted(); |
|
||||
|
|
||||
bool is_pEp_user(); |
|
||||
|
|
||||
void enable_for_sync(); |
|
||||
void disable_for_sync(); |
|
||||
}; |
|
||||
|
|
||||
class Myself : public Identity { |
|
||||
public: |
|
||||
Myself(string address, string username, string user_id="", string lang=""); |
|
||||
virtual void update(); |
|
||||
}; |
|
||||
|
|
||||
Identity identity_attr(pEp_identity *&ident); |
|
||||
void identity_attr(pEp_identity *&ident, object value); |
|
||||
|
|
||||
boost::python::list identitylist_attr(identity_list *&il); |
|
||||
void identitylist_attr(identity_list *&il, boost::python::list value); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,61 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <list> |
|
||||
#include <mutex> |
|
||||
|
|
||||
namespace utility |
|
||||
{ |
|
||||
using namespace std; |
|
||||
|
|
||||
template<class T> class locked_queue |
|
||||
{ |
|
||||
mutex _mtx; |
|
||||
list<T> _q; |
|
||||
|
|
||||
public: |
|
||||
T& back() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
return _q.back(); |
|
||||
} |
|
||||
T& front() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
return _q.front(); |
|
||||
} |
|
||||
T pop_back() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
T r = _q.back(); |
|
||||
_q.pop_back(); |
|
||||
return r; |
|
||||
} |
|
||||
T pop_front() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
T r = _q.front(); |
|
||||
_q.pop_front(); |
|
||||
return r; |
|
||||
} |
|
||||
void push_back(const T& data) |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
_q.push_back(data); |
|
||||
} |
|
||||
void push_front(const T& data) |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
_q.push_front(data); |
|
||||
} |
|
||||
size_t size() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
return _q.size(); |
|
||||
} |
|
||||
bool empty() |
|
||||
{ |
|
||||
lock_guard<mutex> lg(_mtx); |
|
||||
return _q.empty(); |
|
||||
} |
|
||||
}; |
|
||||
}; |
|
||||
@ -1,406 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include <Python.h> |
|
||||
#include "message.hh" |
|
||||
#include "message_api.hh" |
|
||||
#include <stdlib.h> |
|
||||
#include <string.h> |
|
||||
#include <stdexcept> |
|
||||
#include <sstream> |
|
||||
#include <vector> |
|
||||
#include <pEp/mime.h> |
|
||||
#include <pEp/keymanagement.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
using namespace std; |
|
||||
|
|
||||
Message::Blob::Blob(bloblist_t *bl, bool chained) : |
|
||||
_bl(bl), part_of_chain(chained) |
|
||||
{ |
|
||||
if (!_bl) |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
|
|
||||
Message::Blob::Blob(object data, string mime_type, string filename) : |
|
||||
_bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) |
|
||||
{ |
|
||||
if (!_bl) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
Py_buffer src; |
|
||||
int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO); |
|
||||
if (result) |
|
||||
throw invalid_argument("need a contiguous buffer to read"); |
|
||||
|
|
||||
char *mem = (char *)malloc(src.len); |
|
||||
if (!mem) { |
|
||||
PyBuffer_Release(&src); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
|
|
||||
memcpy(mem, src.buf, src.len); |
|
||||
free(_bl->value); |
|
||||
_bl->size = src.len; |
|
||||
_bl->value = mem; |
|
||||
|
|
||||
PyBuffer_Release(&src); |
|
||||
|
|
||||
this->mime_type(mime_type); |
|
||||
this->filename(filename); |
|
||||
} |
|
||||
|
|
||||
Message::Blob::Blob(const Message::Blob& second) : |
|
||||
_bl(second._bl), part_of_chain(true) |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Message::Blob::~Blob() |
|
||||
{ |
|
||||
if (!part_of_chain) { |
|
||||
free(_bl->value); |
|
||||
free(_bl); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
string Message::Blob::_repr() |
|
||||
{ |
|
||||
stringstream build; |
|
||||
build << "Blob("; |
|
||||
if (!_bl) { |
|
||||
build << "b'', '', ''"; |
|
||||
} |
|
||||
else { |
|
||||
build << "bytes(" << _bl->size << "), "; |
|
||||
string mime_type; |
|
||||
if (_bl->mime_type) |
|
||||
mime_type = string(_bl->mime_type); |
|
||||
string filename; |
|
||||
if (_bl->filename) |
|
||||
filename = string(_bl->filename); |
|
||||
build << repr(mime_type) << ", "; |
|
||||
build << repr(filename); |
|
||||
} |
|
||||
build << ")"; |
|
||||
return build.str(); |
|
||||
} |
|
||||
|
|
||||
int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) { |
|
||||
bloblist_t *bl = NULL; |
|
||||
|
|
||||
try { |
|
||||
Message::Blob& blob = extract< Message::Blob& >(self); |
|
||||
bl = blob._bl; |
|
||||
} |
|
||||
catch (exception& e) { |
|
||||
PyErr_SetString(PyExc_RuntimeError, "extract not possible"); |
|
||||
view->obj = NULL; |
|
||||
return -1; |
|
||||
} |
|
||||
|
|
||||
if (!(bl && bl->value)) { |
|
||||
PyErr_SetString(PyExc_RuntimeError, "no data available"); |
|
||||
view->obj = NULL; |
|
||||
return -1; |
|
||||
} |
|
||||
|
|
||||
return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags); |
|
||||
} |
|
||||
|
|
||||
string Message::Blob::decode(string encoding) |
|
||||
{ |
|
||||
if (encoding == "") { |
|
||||
string _mime_type = _bl->mime_type ? _bl->mime_type : ""; |
|
||||
encoding = "ascii"; |
|
||||
|
|
||||
if (_mime_type == "application/pEp.sync") |
|
||||
encoding = "pep.sync"; |
|
||||
|
|
||||
if (_mime_type == "application/pEp.keyreset") |
|
||||
encoding = "pep.distribution"; |
|
||||
|
|
||||
} |
|
||||
object codecs = import("codecs"); |
|
||||
object _decode = codecs.attr("decode"); |
|
||||
return call< string >(_decode.ptr(), this, encoding); |
|
||||
} |
|
||||
|
|
||||
PyBufferProcs Message::Blob::bp = { getbuffer, NULL }; |
|
||||
|
|
||||
Message::Message(int dir, Identity *from) |
|
||||
: _msg(new_message((PEP_msg_direction) dir), &free_message) |
|
||||
{ |
|
||||
if (!_msg) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
if (from) { |
|
||||
_msg->from = ::identity_dup(*from); |
|
||||
if (!_msg->from) |
|
||||
throw bad_alloc(); |
|
||||
_msg->dir = (PEP_msg_direction) dir; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
Message::Message(string mimetext) |
|
||||
: _msg(NULL, &free_message) |
|
||||
{ |
|
||||
message *_cpy; |
|
||||
PEP_STATUS status = mime_decode_message(mimetext.c_str(), |
|
||||
mimetext.size(), &_cpy, NULL); |
|
||||
switch (status) { |
|
||||
case PEP_STATUS_OK: |
|
||||
if (_cpy) |
|
||||
_cpy->dir = PEP_dir_outgoing; |
|
||||
else |
|
||||
_cpy = new_message(PEP_dir_outgoing); |
|
||||
|
|
||||
if (!_cpy) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
_msg = shared_ptr< message >(_cpy); |
|
||||
break; |
|
||||
|
|
||||
case PEP_BUFFER_TOO_SMALL: |
|
||||
throw runtime_error("mime_decode_message: buffer too small"); |
|
||||
|
|
||||
case PEP_CANNOT_CREATE_TEMP_FILE: |
|
||||
throw runtime_error("mime_decode_message: cannot create temp file"); |
|
||||
|
|
||||
case PEP_OUT_OF_MEMORY: |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
default: |
|
||||
stringstream build; |
|
||||
build << "mime_decode_message: unknown error (" << (int) status << ")"; |
|
||||
throw runtime_error(build.str()); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
Message::Message(const Message& second) |
|
||||
: _msg(second._msg) |
|
||||
{ |
|
||||
if (!_msg.get()) |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
|
|
||||
Message::Message(message *msg) |
|
||||
: _msg(::message_dup(msg), &free_message) |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Message::~Message() |
|
||||
{ |
|
||||
|
|
||||
} |
|
||||
|
|
||||
Message::operator message *() |
|
||||
{ |
|
||||
return _msg.get(); |
|
||||
} |
|
||||
|
|
||||
Message::operator const message *() const |
|
||||
{ |
|
||||
return _msg.get(); |
|
||||
} |
|
||||
|
|
||||
string Message::_str() |
|
||||
{ |
|
||||
if (!(_msg->from && _msg->from->address && _msg->from->address[0])) |
|
||||
throw out_of_range(".from_.address missing"); |
|
||||
|
|
||||
char *mimetext; |
|
||||
string result; |
|
||||
|
|
||||
PEP_STATUS status = mime_encode_message(*this, false, &mimetext, false); |
|
||||
switch (status) { |
|
||||
case PEP_STATUS_OK: |
|
||||
result = mimetext; |
|
||||
free(mimetext); |
|
||||
break; |
|
||||
|
|
||||
case PEP_BUFFER_TOO_SMALL: |
|
||||
throw runtime_error("mime_encode_message: buffer too small"); |
|
||||
|
|
||||
case PEP_CANNOT_CREATE_TEMP_FILE: |
|
||||
throw runtime_error("mime_encode_message: cannot create temp file"); |
|
||||
|
|
||||
case PEP_OUT_OF_MEMORY: |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
default: |
|
||||
stringstream build; |
|
||||
build << "mime_encode_message: unknown error (" << (int) status << ")"; |
|
||||
throw runtime_error(build.str()); |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
string Message::_repr() |
|
||||
{ |
|
||||
stringstream build; |
|
||||
build << "Message(" << repr(_str()) << ")"; |
|
||||
return build.str(); |
|
||||
} |
|
||||
|
|
||||
boost::python::tuple Message::attachments() |
|
||||
{ |
|
||||
boost::python::list l; |
|
||||
|
|
||||
for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = |
|
||||
bl->next) { |
|
||||
l.append(Blob(bl, true)); |
|
||||
} |
|
||||
|
|
||||
return boost::python::tuple(l); |
|
||||
} |
|
||||
|
|
||||
void Message::attachments(boost::python::list value) |
|
||||
{ |
|
||||
bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); |
|
||||
if (!bl) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
bloblist_t *_l = bl; |
|
||||
for (int i=0; i<len(value); i++) { |
|
||||
Message::Blob& blob = extract< Message::Blob& >(value[i]); |
|
||||
_l = bloblist_add(_l, blob._bl->value, blob._bl->size, |
|
||||
blob._bl->mime_type, blob._bl->filename); |
|
||||
if (!_l) { |
|
||||
for (_l = bl; _l && _l->value; ) { |
|
||||
free(_l->mime_type); |
|
||||
free(_l->filename); |
|
||||
bloblist_t *_ll = _l; |
|
||||
_l = _l->next; |
|
||||
free(_ll); |
|
||||
} |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
for (int i=0; i<len(value); i++) { |
|
||||
Message::Blob& blob = extract< Message::Blob& >(value[i]); |
|
||||
blob._bl->value = NULL; |
|
||||
blob._bl->size = 0; |
|
||||
free(blob._bl->mime_type); |
|
||||
blob._bl->mime_type = NULL; |
|
||||
free(blob._bl->filename); |
|
||||
blob._bl->filename = NULL; |
|
||||
} |
|
||||
|
|
||||
free_bloblist(_msg->attachments); |
|
||||
_msg->attachments = bl; |
|
||||
} |
|
||||
|
|
||||
Message Message::encrypt() |
|
||||
{ |
|
||||
boost::python::list extra; |
|
||||
return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0); |
|
||||
} |
|
||||
|
|
||||
Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) |
|
||||
{ |
|
||||
if (!enc_format) |
|
||||
enc_format = PEP_enc_PGP_MIME; |
|
||||
return encrypt_message(*this, extra, enc_format, flags); |
|
||||
} |
|
||||
|
|
||||
boost::python::tuple Message::decrypt(int flags) { |
|
||||
return pEp::PythonAdapter::decrypt_message(*this, flags); |
|
||||
} |
|
||||
|
|
||||
PEP_rating Message::outgoing_rating() |
|
||||
{ |
|
||||
if (_msg->dir != PEP_dir_outgoing) |
|
||||
throw invalid_argument("Message.dir must be outgoing"); |
|
||||
|
|
||||
if (from().address() == "") |
|
||||
throw invalid_argument("from.address needed"); |
|
||||
if (from().username() == "") |
|
||||
throw invalid_argument("from.username needed"); |
|
||||
|
|
||||
if (len(to()) + len(cc()) == 0) |
|
||||
throw invalid_argument("either to or cc needed"); |
|
||||
|
|
||||
PEP_STATUS status = myself(adapter.session(), _msg->from); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
PEP_rating rating = PEP_rating_undefined; |
|
||||
status = outgoing_message_rating(adapter.session(), *this, &rating); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
return rating; |
|
||||
} |
|
||||
|
|
||||
PEP_color Message::outgoing_color() |
|
||||
{ |
|
||||
return _color(outgoing_rating()); |
|
||||
} |
|
||||
|
|
||||
Message Message::copy() |
|
||||
{ |
|
||||
message *dup = message_dup(*this); |
|
||||
if (!dup) |
|
||||
throw bad_alloc(); |
|
||||
return Message(dup); |
|
||||
} |
|
||||
|
|
||||
Message Message::deepcopy(dict&) |
|
||||
{ |
|
||||
return copy(); |
|
||||
} |
|
||||
|
|
||||
Message outgoing_message(Identity me) |
|
||||
{ |
|
||||
if (me.address().empty() || me.user_id().empty()) |
|
||||
throw runtime_error("at least address and user_id of own user needed"); |
|
||||
|
|
||||
::myself(adapter.session(), me); |
|
||||
auto m = Message(PEP_dir_outgoing, &me); |
|
||||
return m; |
|
||||
} |
|
||||
|
|
||||
static object update(Identity ident) |
|
||||
{ |
|
||||
if (ident.address().empty()) |
|
||||
throw runtime_error("at least address needed"); |
|
||||
update_identity(adapter.session(), ident); |
|
||||
return object(ident); |
|
||||
} |
|
||||
|
|
||||
static boost::python::list update(boost::python::list il) |
|
||||
{ |
|
||||
for (int i=0; i<len(il); i++) { |
|
||||
update(extract< Identity >(il[i])); |
|
||||
} |
|
||||
|
|
||||
return il; |
|
||||
} |
|
||||
|
|
||||
Message incoming_message(string mime_text) |
|
||||
{ |
|
||||
auto m = Message(mime_text); |
|
||||
m.dir(PEP_dir_incoming); |
|
||||
|
|
||||
try { |
|
||||
m.from(update(m.from())); |
|
||||
} |
|
||||
catch (out_of_range&) { } |
|
||||
|
|
||||
try { |
|
||||
m.recv_by(update(m.recv_by())); |
|
||||
} |
|
||||
catch (out_of_range&) { } |
|
||||
|
|
||||
m.to(update(m.to())); |
|
||||
m.cc(update(m.cc())); |
|
||||
m.reply_to(update(m.reply_to())); |
|
||||
|
|
||||
return m; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,145 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <boost/python.hpp> |
|
||||
#include <boost/lexical_cast.hpp> |
|
||||
#include <pEp/message.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
#include <string> |
|
||||
#include "str_attr.hh" |
|
||||
#include "identity.hh" |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
using namespace std; |
|
||||
using namespace boost::python; |
|
||||
using boost::lexical_cast; |
|
||||
|
|
||||
// Message is owning a message struct
|
|
||||
|
|
||||
class Message { |
|
||||
shared_ptr< ::message > _msg; |
|
||||
|
|
||||
public: |
|
||||
// Blob is owning a bloblist_t struct - or not and just managing
|
|
||||
// one depending on part_of_chain
|
|
||||
|
|
||||
class Blob { |
|
||||
bloblist_t *_bl; |
|
||||
bool part_of_chain; |
|
||||
|
|
||||
public: |
|
||||
Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), |
|
||||
bool chained = false); |
|
||||
Blob(object data, string mime_type = "", string filename = ""); |
|
||||
Blob(const Blob& second); |
|
||||
~Blob(); |
|
||||
|
|
||||
string _repr(); |
|
||||
|
|
||||
string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; } |
|
||||
void mime_type(string value) { str_attr(_bl->mime_type, value); } |
|
||||
|
|
||||
string filename() { return str_attr(_bl->filename); } |
|
||||
void filename(string value) { str_attr(_bl->filename, value); } |
|
||||
|
|
||||
size_t size() { return _bl->size; } |
|
||||
string decode(string encoding); |
|
||||
string decode() { return decode(""); } |
|
||||
|
|
||||
static PyBufferProcs bp; |
|
||||
|
|
||||
friend class Message; |
|
||||
|
|
||||
protected: |
|
||||
static int getbuffer(PyObject *self, Py_buffer *view, int flags); |
|
||||
}; |
|
||||
|
|
||||
Message(int dir = PEP_dir_outgoing, Identity *from = NULL); |
|
||||
Message(string mimetext); |
|
||||
Message(const Message& second); |
|
||||
Message(message *msg); |
|
||||
~Message(); |
|
||||
operator message *(); |
|
||||
operator const message *() const; |
|
||||
|
|
||||
string _str(); |
|
||||
string _repr(); |
|
||||
|
|
||||
PEP_msg_direction dir() { return _msg->dir; } |
|
||||
void dir(PEP_msg_direction value) { _msg->dir = value; } |
|
||||
|
|
||||
string id() { return str_attr(_msg->id); } |
|
||||
void id(string value) { str_attr(_msg->id, value); } |
|
||||
|
|
||||
string shortmsg() { return str_attr(_msg->shortmsg); } |
|
||||
void shortmsg(string value) { str_attr(_msg->shortmsg, value); } |
|
||||
|
|
||||
string longmsg() { return str_attr(_msg->longmsg); } |
|
||||
void longmsg(string value) { str_attr(_msg->longmsg, value); } |
|
||||
|
|
||||
string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); } |
|
||||
void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); } |
|
||||
|
|
||||
boost::python::tuple attachments(); |
|
||||
void attachments(boost::python::list value); |
|
||||
|
|
||||
time_t sent() { return timestamp_attr(_msg->sent); } |
|
||||
void sent(time_t value) { timestamp_attr(_msg->sent, value); } |
|
||||
|
|
||||
time_t recv() { return timestamp_attr(_msg->recv); } |
|
||||
void recv(time_t value) { timestamp_attr(_msg->recv, value); } |
|
||||
|
|
||||
Identity from() { return identity_attr(_msg->from); } |
|
||||
void from(object value) { identity_attr(_msg->from, value); } |
|
||||
|
|
||||
boost::python::list to() { return identitylist_attr(_msg->to); } |
|
||||
void to(boost::python::list value) { identitylist_attr(_msg->to, value); } |
|
||||
|
|
||||
Identity recv_by() { return identity_attr(_msg->recv_by); } |
|
||||
void recv_by(object value) { identity_attr(_msg->recv_by, value); } |
|
||||
|
|
||||
boost::python::list cc() { return identitylist_attr(_msg->cc); } |
|
||||
void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); } |
|
||||
|
|
||||
boost::python::list bcc() { return identitylist_attr(_msg->bcc); } |
|
||||
void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); } |
|
||||
|
|
||||
boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); } |
|
||||
void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); } |
|
||||
|
|
||||
boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); } |
|
||||
void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); } |
|
||||
|
|
||||
boost::python::list references() { return strlist_attr(_msg->references); } |
|
||||
void references(boost::python::list value) { strlist_attr(_msg->references, value); } |
|
||||
|
|
||||
boost::python::list keywords() { return strlist_attr(_msg->keywords); } |
|
||||
void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); } |
|
||||
|
|
||||
string comments() { return str_attr(_msg->comments); } |
|
||||
void comments(string value) { str_attr(_msg->comments, value); } |
|
||||
|
|
||||
dict opt_fields() { return strdict_attr(_msg->opt_fields); } |
|
||||
void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); } |
|
||||
|
|
||||
PEP_enc_format enc_format() { return _msg->enc_format; } |
|
||||
void enc_format(PEP_enc_format value) { _msg->enc_format = value; } |
|
||||
|
|
||||
Message encrypt(); |
|
||||
Message _encrypt(boost::python::list extra, int enc_format=4, int flags=0); |
|
||||
|
|
||||
boost::python::tuple decrypt(int flags=0); |
|
||||
PEP_rating outgoing_rating(); |
|
||||
PEP_color outgoing_color(); |
|
||||
Message deepcopy(dict& memo); |
|
||||
Message copy(); |
|
||||
}; |
|
||||
|
|
||||
Message outgoing_message(Identity me); |
|
||||
Message incoming_message(string mime_text); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,167 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include "message_api.hh" |
|
||||
#include "basic_api.hh" |
|
||||
#include <pEp/pEpEngine.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
#include <pEp/sync_api.h> |
|
||||
#include <pEp/sync_codec.h> |
|
||||
#include <pEp/distribution_codec.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
Message encrypt_message(Message src, boost::python::list extra, int enc_format, |
|
||||
int flags) |
|
||||
{ |
|
||||
Identity _from = src.from(); |
|
||||
if (_from.address() == "") |
|
||||
throw invalid_argument("encrypt_message: src.from_.address empty"); |
|
||||
if (_from.username() == "") |
|
||||
throw invalid_argument("encrypt_message: src.from_.username empty"); |
|
||||
|
|
||||
if (_from.user_id() == "") |
|
||||
src.from().user_id(_from.address()); |
|
||||
|
|
||||
stringlist_t *_extra = to_stringlist(extra); |
|
||||
PEP_enc_format _enc_format = (PEP_enc_format) enc_format; |
|
||||
PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags; |
|
||||
message *_dst = NULL; |
|
||||
|
|
||||
message *_src = src; |
|
||||
PEP_STATUS status = encrypt_message(adapter.session(), _src, _extra, &_dst, |
|
||||
_enc_format, _flags); |
|
||||
free_stringlist(_extra); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
if (!_dst || _dst == _src) |
|
||||
return Message(_src); |
|
||||
|
|
||||
return Message(_dst); |
|
||||
} |
|
||||
|
|
||||
boost::python::tuple decrypt_message(Message src, int flags) |
|
||||
{ |
|
||||
message *_dst = NULL; |
|
||||
stringlist_t *_keylist = NULL; |
|
||||
PEP_rating _rating = PEP_rating_undefined; |
|
||||
PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t) flags; |
|
||||
message *_src = src; |
|
||||
|
|
||||
PEP_STATUS status = ::decrypt_message(adapter.session(), _src, &_dst, &_keylist, |
|
||||
&_rating, &_flags); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
boost::python::list keylist; |
|
||||
if (_keylist) { |
|
||||
keylist = from_stringlist(_keylist); |
|
||||
free_stringlist(_keylist); |
|
||||
} |
|
||||
|
|
||||
Message dst = _dst ? Message(_dst) : Message(src); |
|
||||
return boost::python::make_tuple(dst, keylist, _rating, _flags); |
|
||||
} |
|
||||
|
|
||||
PEP_color _color(int rating) |
|
||||
{ |
|
||||
return ::color_from_rating((PEP_rating) rating); |
|
||||
} |
|
||||
|
|
||||
boost::python::tuple sync_decode(object buffer) |
|
||||
{ |
|
||||
Py_buffer src; |
|
||||
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); |
|
||||
if (result) |
|
||||
throw invalid_argument("need a contiguous buffer to read"); |
|
||||
|
|
||||
char *dst = NULL; |
|
||||
PEP_STATUS status = PER_to_XER_Sync_msg((char *) src.buf, src.len, &dst); |
|
||||
PyBuffer_Release(&src); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
string _dst(dst); |
|
||||
free(dst); |
|
||||
return boost::python::make_tuple(_dst, 0); |
|
||||
} |
|
||||
|
|
||||
static boost::python::tuple sync_encode(string text) |
|
||||
{ |
|
||||
char *data = NULL; |
|
||||
size_t size = 0; |
|
||||
PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
PyObject *ba = PyBytes_FromStringAndSize(data, size); |
|
||||
free(data); |
|
||||
if (!ba) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
return boost::python::make_tuple(object(handle<>(ba)), 0); |
|
||||
} |
|
||||
|
|
||||
boost::python::tuple Distribution_decode(object buffer) |
|
||||
{ |
|
||||
Py_buffer src; |
|
||||
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); |
|
||||
if (result) |
|
||||
throw invalid_argument("need a contiguous buffer to read"); |
|
||||
|
|
||||
char *dst = NULL; |
|
||||
PEP_STATUS status = PER_to_XER_Distribution_msg((char *) src.buf, src.len, &dst); |
|
||||
PyBuffer_Release(&src); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
string _dst(dst); |
|
||||
free(dst); |
|
||||
return boost::python::make_tuple(_dst, 0); |
|
||||
} |
|
||||
|
|
||||
static boost::python::tuple Distribution_encode(string text) |
|
||||
{ |
|
||||
char *data = NULL; |
|
||||
size_t size = 0; |
|
||||
PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size); |
|
||||
_throw_status(status); |
|
||||
|
|
||||
PyObject *ba = PyBytes_FromStringAndSize(data, size); |
|
||||
free(data); |
|
||||
if (!ba) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
return boost::python::make_tuple(object(handle<>(ba)), 0); |
|
||||
} |
|
||||
|
|
||||
object sync_search(string name) |
|
||||
{ |
|
||||
if (name != "pep.sync") { |
|
||||
return object(); |
|
||||
} |
|
||||
else { |
|
||||
object codecs = import("codecs"); |
|
||||
object CodecInfo = codecs.attr("CodecInfo"); |
|
||||
|
|
||||
object _sync_decode = make_function(sync_decode); |
|
||||
object _sync_encode = make_function(sync_encode); |
|
||||
|
|
||||
return call< object >(CodecInfo.ptr(), _sync_encode, _sync_decode); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
object distribution_search(string name) |
|
||||
{ |
|
||||
if (name != "pep.distribution") { |
|
||||
return object(); |
|
||||
} |
|
||||
else { |
|
||||
object codecs = import("codecs"); |
|
||||
object CodecInfo = codecs.attr("CodecInfo"); |
|
||||
|
|
||||
object _distribution_decode = make_function(Distribution_decode); |
|
||||
object _distribution_encode = make_function(Distribution_encode); |
|
||||
|
|
||||
return call< object >(CodecInfo.ptr(), _distribution_encode, _distribution_decode); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,17 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include "pEpmodule.hh" |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
Message encrypt_message(Message src, boost::python::list extra = boost::python::list(), |
|
||||
int enc_format = 4, int flags = 0); |
|
||||
boost::python::tuple decrypt_message(Message src, int flags=0); |
|
||||
PEP_color _color(int rating); |
|
||||
object sync_search(string name); |
|
||||
object distribution_search(string name); |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,52 @@ |
|||||
|
# pEp package |
||||
|
# This file is being exectued upon 'import pEp' |
||||
|
# |
||||
|
# __all__ could be used to limit the symbols exported when using from <pkg> import * |
||||
|
|
||||
|
|
||||
|
# Import all symbols EXCEPT the ones beginning with underscore into the current namespace |
||||
|
from native_pEp import * |
||||
|
# TODO: inter-pkg ref to make sure which native_pEp in sys.path gets loaded |
||||
|
# like: pEp.native_pEp |
||||
|
# import the module |
||||
|
import native_pEp |
||||
|
|
||||
|
# Executed on module import |
||||
|
def init(): |
||||
|
print(init, "called") |
||||
|
native_pEp._init_after_main_module() |
||||
|
|
||||
|
|
||||
|
def message_to_send(msg): |
||||
|
""" |
||||
|
message_to_send(msg) |
||||
|
override pEp.message_to_send(msg) with your own implementation |
||||
|
this callback is being called when a p≡p management message needs to be sent |
||||
|
GIL CAVEAT |
||||
|
""" |
||||
|
print("message_to_send() - default callback\n") |
||||
|
print("overwrite this method") |
||||
|
|
||||
|
|
||||
|
def notify_handshake(me, partner, signal): |
||||
|
""" |
||||
|
notifyHandshake(self, me, partner) |
||||
|
me own identity |
||||
|
partner identity of communication partner |
||||
|
signal the handshake signal |
||||
|
overwrite this method with an implementation of a handshake dialog |
||||
|
GIL CAVEAT |
||||
|
""" |
||||
|
print("message_to_send() - default callback\n") |
||||
|
print("overwrite this method") |
||||
|
|
||||
|
|
||||
|
# Executed when run as script |
||||
|
def main(): |
||||
|
print("I am being run as a script") |
||||
|
|
||||
|
# MAIN |
||||
|
if __name__ == "__main__": |
||||
|
main() |
||||
|
else: |
||||
|
init() |
||||
@ -0,0 +1,172 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// System
|
||||
|
#include <sstream> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/keymanagement.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
#include <pEp/Adapter.hh> |
||||
|
|
||||
|
// local
|
||||
|
#include "basic_api.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
|
||||
|
void update_identity(Identity& ident) |
||||
|
{ |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.user_id() == PEP_OWN_USERID) |
||||
|
throw runtime_error("update_identity: '" PEP_OWN_USERID |
||||
|
"' may only be used for own identities"); |
||||
|
|
||||
|
PEP_STATUS status = update_identity(Adapter::session(), ident); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void myself(Identity& ident) |
||||
|
{ |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.username() == "") |
||||
|
throw invalid_argument("username needed"); |
||||
|
|
||||
|
if (ident.user_id() == "") |
||||
|
ident.user_id(ident.address()); |
||||
|
|
||||
|
PEP_STATUS status = myself(Adapter::session(), ident); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
string _trustwords(Identity me, Identity partner, string lang, bool full) |
||||
|
{ |
||||
|
if (me.fpr() == "" || partner.fpr() == "") |
||||
|
throw invalid_argument("fingerprint needed in Identities"); |
||||
|
|
||||
|
if (lang == "" && me.lang() == partner.lang()) |
||||
|
lang = me.lang(); |
||||
|
|
||||
|
char *words = NULL; |
||||
|
size_t size = 0; |
||||
|
PEP_STATUS status = get_trustwords(Adapter::session(), me, partner, |
||||
|
lang.c_str(),&words, &size, full); |
||||
|
_throw_status(status); |
||||
|
return words; |
||||
|
} |
||||
|
|
||||
|
void trust_personal_key(Identity ident) |
||||
|
{ |
||||
|
if (ident.fpr() == "") |
||||
|
throw invalid_argument("fingerprint needed in Identities"); |
||||
|
if (ident.user_id() == "") |
||||
|
throw invalid_argument("user_id must be provided"); |
||||
|
|
||||
|
PEP_STATUS status = trust_personal_key(Adapter::session(), ident); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void set_identity_flags(Identity ident, identity_flags_t flags) |
||||
|
{ |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.user_id() == "") |
||||
|
throw invalid_argument("user_id needed"); |
||||
|
|
||||
|
PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void unset_identity_flags(Identity ident, identity_flags_t flags) |
||||
|
{ |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.user_id() == "") |
||||
|
throw invalid_argument("user_id needed"); |
||||
|
|
||||
|
PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void key_reset_trust(Identity ident) |
||||
|
{ |
||||
|
if (ident.fpr() == "") |
||||
|
throw invalid_argument("fpr needed"); |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.user_id() == "") |
||||
|
throw invalid_argument("user_id needed"); |
||||
|
|
||||
|
PEP_STATUS status = key_reset_trust(Adapter::session(), ident); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
|
boost::python::list import_key(string key_data) |
||||
|
{ |
||||
|
::identity_list *private_keys = NULL; |
||||
|
PEP_STATUS status = ::import_key(Adapter::session(), key_data.c_str(), key_data.size(), &private_keys); |
||||
|
if (status && status != PEP_KEY_IMPORTED) |
||||
|
_throw_status(status); |
||||
|
|
||||
|
auto result = boost::python::list(); |
||||
|
for (::identity_list *il = private_keys; il && il->ident; il=il->next) { |
||||
|
::pEp_identity *ident = ::identity_dup(il->ident); |
||||
|
if (!ident) { |
||||
|
free_identity_list(private_keys); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
result.append(Identity(ident)); |
||||
|
} |
||||
|
|
||||
|
free_identity_list(private_keys); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
string export_key(Identity ident) |
||||
|
{ |
||||
|
PEP_STATUS status = PEP_STATUS_OK; |
||||
|
char* key_data = NULL; |
||||
|
size_t size; |
||||
|
status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size); |
||||
|
|
||||
|
_throw_status(status); |
||||
|
return key_data; |
||||
|
} |
||||
|
|
||||
|
string export_secret_key(Identity ident) |
||||
|
{ |
||||
|
PEP_STATUS status = PEP_STATUS_OK; |
||||
|
char* key_data = NULL; |
||||
|
size_t size; |
||||
|
status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size); |
||||
|
|
||||
|
_throw_status(status); |
||||
|
return key_data; |
||||
|
} |
||||
|
|
||||
|
void set_own_key(Identity& ident, string fpr) |
||||
|
{ |
||||
|
if (ident.address() == "") |
||||
|
throw invalid_argument("address needed"); |
||||
|
if (ident.username() == "") |
||||
|
throw invalid_argument("username needed"); |
||||
|
if (ident.user_id() == "") |
||||
|
throw invalid_argument("user_id needed"); |
||||
|
if (fpr == "") |
||||
|
throw invalid_argument("fpr needed"); |
||||
|
|
||||
|
|
||||
|
const char* fpr_c = fpr.c_str(); |
||||
|
PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
|
|
||||
|
|
||||
@ -0,0 +1,30 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef BASIC_API_HH |
||||
|
#define BASIC_API_HH |
||||
|
|
||||
|
#include "pEpmodule.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
|
||||
|
void update_identity(Identity& ident); |
||||
|
void myself(Identity& ident); |
||||
|
string _trustwords(Identity me, Identity partner, string lang, bool full); |
||||
|
void trust_personal_key(Identity ident); |
||||
|
|
||||
|
void set_identity_flags(Identity ident, identity_flags_t flags); |
||||
|
void unset_identity_flags(Identity ident, identity_flags_t flags); |
||||
|
|
||||
|
void key_reset_trust(Identity ident); |
||||
|
|
||||
|
boost::python::list import_key(string key_data); |
||||
|
string export_key(Identity ident); |
||||
|
string export_secret_key(Identity ident); |
||||
|
void set_own_key(Identity& ident, string fpr); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* BASIC_API_HH */ |
||||
@ -0,0 +1,285 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// System
|
||||
|
#include <typeinfo> |
||||
|
#include <sstream> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/identity_list.h> |
||||
|
#include <pEp/keymanagement.h> |
||||
|
#include <pEp/key_reset.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "identity.hh" |
||||
|
#include "pEpmodule.hh" |
||||
|
#include "basic_api.hh" |
||||
|
#include "message_api.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
using namespace boost::python; |
||||
|
|
||||
|
Identity::Identity(string address, string username, string user_id, |
||||
|
string fpr, int comm_type, string lang, identity_flags_t flags) |
||||
|
: _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), |
||||
|
username.c_str()), &::free_identity) |
||||
|
{ |
||||
|
if (!_ident) |
||||
|
throw bad_alloc(); |
||||
|
_ident->comm_type = (PEP_comm_type) comm_type; |
||||
|
_ident->flags = (identity_flags_t) flags; |
||||
|
this->lang(lang); |
||||
|
} |
||||
|
|
||||
|
Identity::Identity(const Identity& second) |
||||
|
: _ident(second._ident) |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Identity::Identity(pEp_identity *ident) |
||||
|
: _ident(ident, &::free_identity) |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Identity::~Identity() |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Identity::operator pEp_identity *() |
||||
|
{ |
||||
|
return _ident.get(); |
||||
|
} |
||||
|
|
||||
|
Identity::operator const pEp_identity *() const |
||||
|
{ |
||||
|
return _ident.get(); |
||||
|
} |
||||
|
|
||||
|
string Identity::_repr() |
||||
|
{ |
||||
|
stringstream build; |
||||
|
build << "Identity("; |
||||
|
string address; |
||||
|
if (_ident->address) |
||||
|
address = string(_ident->address); |
||||
|
build << repr(address) << ", "; |
||||
|
string username; |
||||
|
if (_ident->username) |
||||
|
username = string(_ident->username); |
||||
|
build << repr(username) << ", "; |
||||
|
string user_id; |
||||
|
if (_ident->user_id) |
||||
|
user_id = string(_ident->user_id); |
||||
|
build << repr(user_id) << ", "; |
||||
|
string fpr; |
||||
|
if (_ident->fpr) |
||||
|
fpr = string(_ident->fpr); |
||||
|
build << repr(fpr) << ", "; |
||||
|
build << (int) _ident->comm_type << ", "; |
||||
|
string lang = _ident->lang; |
||||
|
build << repr(lang) << ")"; |
||||
|
return build.str(); |
||||
|
} |
||||
|
|
||||
|
string Identity::_str() |
||||
|
{ |
||||
|
if (!(_ident->address && _ident->address[0])) |
||||
|
return ""; |
||||
|
if (!(_ident->username && _ident->username[0])) |
||||
|
return _ident->address; |
||||
|
return string(_ident->username) + " <" + _ident->address + ">"; |
||||
|
} |
||||
|
|
||||
|
void Identity::username(string value) |
||||
|
{ |
||||
|
if (value.length() && value.length() < 5) |
||||
|
throw length_error("username must be at least 5 characters"); |
||||
|
|
||||
|
str_attr(_ident->username, value); |
||||
|
} |
||||
|
|
||||
|
void Identity::lang(string value) |
||||
|
{ |
||||
|
if (value == "") |
||||
|
memset(_ident->lang, 0, 3); |
||||
|
else if (value.length() != 2) |
||||
|
throw length_error("length of lang must be 2"); |
||||
|
else |
||||
|
memcpy(_ident->lang, value.c_str(), 3); |
||||
|
} |
||||
|
|
||||
|
string Identity::lang() |
||||
|
{ |
||||
|
return _ident->lang; |
||||
|
} |
||||
|
|
||||
|
int Identity::rating() |
||||
|
{ |
||||
|
if (!(_ident->address)) |
||||
|
throw invalid_argument("address must be given"); |
||||
|
|
||||
|
PEP_rating rating = PEP_rating_undefined; |
||||
|
PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
return (int) rating; |
||||
|
} |
||||
|
|
||||
|
PEP_color Identity::color() |
||||
|
{ |
||||
|
return _color(rating()); |
||||
|
} |
||||
|
|
||||
|
Identity Identity::copy() |
||||
|
{ |
||||
|
pEp_identity *dup = ::identity_dup(*this); |
||||
|
if (!dup) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
return Identity(dup); |
||||
|
} |
||||
|
|
||||
|
Identity Identity::deepcopy(dict&) |
||||
|
{ |
||||
|
return copy(); |
||||
|
} |
||||
|
|
||||
|
void Identity::update() |
||||
|
{ |
||||
|
update_identity(*this); |
||||
|
} |
||||
|
|
||||
|
void Identity::key_reset(string fpr) |
||||
|
{ |
||||
|
PEP_STATUS status = ::key_reset_identity(Adapter::session(), *this, |
||||
|
fpr != "" ? fpr.c_str() : nullptr); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void Identity::key_mistrusted() |
||||
|
{ |
||||
|
PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
bool Identity::is_pEp_user() |
||||
|
{ |
||||
|
bool result; |
||||
|
PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result); |
||||
|
_throw_status(status); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
void Identity::enable_for_sync() |
||||
|
{ |
||||
|
PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
void Identity::disable_for_sync() |
||||
|
{ |
||||
|
PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
Myself::Myself(string address, string username, string user_id, string lang) |
||||
|
: Identity(address, username, user_id, "", 0, lang) |
||||
|
|
||||
|
{ |
||||
|
if (!(address.length() && username.length())) |
||||
|
throw invalid_argument("address and username must be set"); |
||||
|
if (lang.length() && lang.length() != 2) |
||||
|
throw length_error("lang must be an ISO 639-1 language code or empty"); |
||||
|
|
||||
|
// FIXME: should set .me
|
||||
|
// _ident->me = true;
|
||||
|
if (user_id.length()) |
||||
|
throw runtime_error("user_id feature not yet implemented for Myself"); |
||||
|
} |
||||
|
|
||||
|
void Myself::update() |
||||
|
{ |
||||
|
pEp::PythonAdapter::myself(*this); |
||||
|
} |
||||
|
|
||||
|
Identity identity_attr(pEp_identity *&ident) |
||||
|
{ |
||||
|
if (!ident) |
||||
|
throw out_of_range("no identity assigned"); |
||||
|
|
||||
|
pEp_identity *_dup = identity_dup(ident); |
||||
|
if (!_dup) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
Identity _ident(_dup); |
||||
|
return _ident; |
||||
|
} |
||||
|
|
||||
|
void identity_attr(pEp_identity *&ident, object value) |
||||
|
{ |
||||
|
Identity& _ident = extract< Identity& >(value); |
||||
|
pEp_identity *_dup = ::identity_dup(_ident); |
||||
|
if (!_dup) |
||||
|
throw bad_alloc(); |
||||
|
PEP_STATUS status = update_identity(Adapter::session(), _dup); |
||||
|
_throw_status(status); |
||||
|
free_identity(ident); |
||||
|
ident = _dup; |
||||
|
} |
||||
|
|
||||
|
boost::python::list identitylist_attr(identity_list *&il) |
||||
|
{ |
||||
|
boost::python::list result; |
||||
|
|
||||
|
for (identity_list *_il = il; _il && _il->ident; _il = _il->next) { |
||||
|
pEp_identity *ident = ::identity_dup(_il->ident); |
||||
|
if (!ident) |
||||
|
throw bad_alloc(); |
||||
|
result.append(object(Identity(ident))); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
void identitylist_attr(identity_list *&il, boost::python::list value) |
||||
|
{ |
||||
|
identity_list *_il = new_identity_list(NULL); |
||||
|
if (!_il) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
identity_list *_i = _il; |
||||
|
for (int i=0; i<len(value); i++) { |
||||
|
extract< Identity& > extract_identity(value[i]); |
||||
|
if (!extract_identity.check()) { |
||||
|
free_identity_list(_il); |
||||
|
} |
||||
|
pEp_identity *_ident = extract_identity(); |
||||
|
pEp_identity *_dup = ::identity_dup(_ident); |
||||
|
if (!_dup) { |
||||
|
free_identity_list(_il); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
PEP_STATUS status = update_identity(Adapter::session(), _dup); |
||||
|
if (status != PEP_STATUS_OK) { |
||||
|
free_identity_list(_il); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
_i = identity_list_add(_i, _dup); |
||||
|
if (!_i) { |
||||
|
free_identity_list(_il); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
free_identity_list(il); |
||||
|
il = _il; |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
|
|
||||
@ -0,0 +1,102 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef IDENTITY_HH |
||||
|
#define IDENTITY_HH |
||||
|
|
||||
|
// System
|
||||
|
#include <boost/python.hpp> |
||||
|
#include <string> |
||||
|
#include <memory> |
||||
|
#include <cstddef> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/pEpEngine.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
|
||||
|
//libpEpAdapter
|
||||
|
#include "pEp/Adapter.hh" |
||||
|
|
||||
|
// local
|
||||
|
#include "str_attr.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
|
||||
|
using std::string; |
||||
|
using std::shared_ptr; |
||||
|
|
||||
|
// Identity is owning a pEp_identity
|
||||
|
|
||||
|
class Identity { |
||||
|
protected: |
||||
|
shared_ptr< pEp_identity > _ident; |
||||
|
|
||||
|
public: |
||||
|
Identity(string address = "", string username = "", |
||||
|
string user_id = "", string fpr = "", int comm_type = 0, |
||||
|
string lang = "", identity_flags_t flags = 0); |
||||
|
|
||||
|
Identity(const Identity& second); |
||||
|
Identity(pEp_identity *ident); |
||||
|
virtual ~Identity(); |
||||
|
operator pEp_identity *(); |
||||
|
operator const pEp_identity *() const; |
||||
|
|
||||
|
string _repr(); |
||||
|
string _str(); |
||||
|
|
||||
|
string address() { return str_attr(_ident->address); } |
||||
|
void address(string value) { str_attr(_ident->address, value); } |
||||
|
|
||||
|
string fpr() { return str_attr(_ident->fpr); } |
||||
|
void fpr(string value) { str_attr(_ident->fpr, value); } |
||||
|
|
||||
|
string user_id() { return str_attr(_ident->user_id); } |
||||
|
void user_id(string value) { str_attr(_ident->user_id, value); } |
||||
|
|
||||
|
string username() { return str_attr(_ident->username); } |
||||
|
void username(string value); |
||||
|
|
||||
|
PEP_comm_type comm_type() { return _ident->comm_type; } |
||||
|
void comm_type(PEP_comm_type value) { _ident->comm_type = value; }; |
||||
|
|
||||
|
std::string lang(); |
||||
|
void lang(std::string value); |
||||
|
|
||||
|
identity_flags_t flags() { return _ident->flags; } |
||||
|
void flags(identity_flags_t flags) { _ident->flags = flags; } |
||||
|
|
||||
|
int rating(); |
||||
|
PEP_color color(); |
||||
|
|
||||
|
Identity copy(); |
||||
|
Identity deepcopy(dict& memo); |
||||
|
|
||||
|
virtual void update(); |
||||
|
|
||||
|
void key_reset(string fpr=""); |
||||
|
void key_mistrusted(); |
||||
|
|
||||
|
bool is_pEp_user(); |
||||
|
|
||||
|
void enable_for_sync(); |
||||
|
void disable_for_sync(); |
||||
|
}; |
||||
|
|
||||
|
class Myself : public Identity { |
||||
|
public: |
||||
|
Myself(string address, string username, string user_id="", string lang=""); |
||||
|
virtual void update(); |
||||
|
}; |
||||
|
|
||||
|
Identity identity_attr(pEp_identity *&ident); |
||||
|
void identity_attr(pEp_identity *&ident, object value); |
||||
|
|
||||
|
boost::python::list identitylist_attr(identity_list *&il); |
||||
|
void identitylist_attr(identity_list *&il, boost::python::list value); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* IDENTITY_HH */ |
||||
@ -0,0 +1,413 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// System
|
||||
|
#include <cstdlib> |
||||
|
#include <cstring> |
||||
|
#include <stdexcept> |
||||
|
#include <sstream> |
||||
|
#include <vector> |
||||
|
#include <Python.h> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/mime.h> |
||||
|
#include <pEp/keymanagement.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "message.hh" |
||||
|
#include "message_api.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
using namespace boost::python; |
||||
|
|
||||
|
Message::Blob::Blob(bloblist_t *bl, bool chained) : |
||||
|
_bl(bl), part_of_chain(chained) |
||||
|
{ |
||||
|
if (!_bl) |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
|
||||
|
Message::Blob::Blob(object data, string mime_type, string filename) : |
||||
|
_bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) |
||||
|
{ |
||||
|
if (!_bl) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
Py_buffer src; |
||||
|
int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO); |
||||
|
if (result) |
||||
|
throw invalid_argument("need a contiguous buffer to read"); |
||||
|
|
||||
|
char *mem = (char *)malloc(src.len); |
||||
|
if (!mem) { |
||||
|
PyBuffer_Release(&src); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
|
||||
|
memcpy(mem, src.buf, src.len); |
||||
|
free(_bl->value); |
||||
|
_bl->size = src.len; |
||||
|
_bl->value = mem; |
||||
|
|
||||
|
PyBuffer_Release(&src); |
||||
|
|
||||
|
this->mime_type(mime_type); |
||||
|
this->filename(filename); |
||||
|
} |
||||
|
|
||||
|
Message::Blob::Blob(const Message::Blob& second) : |
||||
|
_bl(second._bl), part_of_chain(true) |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Message::Blob::~Blob() |
||||
|
{ |
||||
|
if (!part_of_chain) { |
||||
|
free(_bl->value); |
||||
|
free(_bl); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
string Message::Blob::_repr() |
||||
|
{ |
||||
|
stringstream build; |
||||
|
build << "Blob("; |
||||
|
if (!_bl) { |
||||
|
build << "b'', '', ''"; |
||||
|
} |
||||
|
else { |
||||
|
build << "bytes(" << _bl->size << "), "; |
||||
|
string mime_type; |
||||
|
if (_bl->mime_type) |
||||
|
mime_type = string(_bl->mime_type); |
||||
|
string filename; |
||||
|
if (_bl->filename) |
||||
|
filename = string(_bl->filename); |
||||
|
build << repr(mime_type) << ", "; |
||||
|
build << repr(filename); |
||||
|
} |
||||
|
build << ")"; |
||||
|
return build.str(); |
||||
|
} |
||||
|
|
||||
|
int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) { |
||||
|
bloblist_t *bl = NULL; |
||||
|
|
||||
|
try { |
||||
|
Message::Blob& blob = extract< Message::Blob& >(self); |
||||
|
bl = blob._bl; |
||||
|
} |
||||
|
catch (exception& e) { |
||||
|
PyErr_SetString(PyExc_RuntimeError, "extract not possible"); |
||||
|
view->obj = NULL; |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
if (!(bl && bl->value)) { |
||||
|
PyErr_SetString(PyExc_RuntimeError, "no data available"); |
||||
|
view->obj = NULL; |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags); |
||||
|
} |
||||
|
|
||||
|
string Message::Blob::decode(string encoding) |
||||
|
{ |
||||
|
if (encoding == "") { |
||||
|
string _mime_type = _bl->mime_type ? _bl->mime_type : ""; |
||||
|
encoding = "ascii"; |
||||
|
|
||||
|
if (_mime_type == "application/pEp.sync") |
||||
|
encoding = "pep.sync"; |
||||
|
|
||||
|
if (_mime_type == "application/pEp.keyreset") |
||||
|
encoding = "pep.distribution"; |
||||
|
|
||||
|
} |
||||
|
object codecs = import("codecs"); |
||||
|
object _decode = codecs.attr("decode"); |
||||
|
return call< string >(_decode.ptr(), this, encoding); |
||||
|
} |
||||
|
|
||||
|
PyBufferProcs Message::Blob::bp = { getbuffer, NULL }; |
||||
|
|
||||
|
Message::Message(int dir, Identity *from) |
||||
|
: _msg(new_message((PEP_msg_direction) dir), &free_message) |
||||
|
{ |
||||
|
if (!_msg) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
if (from) { |
||||
|
_msg->from = ::identity_dup(*from); |
||||
|
if (!_msg->from) |
||||
|
throw bad_alloc(); |
||||
|
_msg->dir = (PEP_msg_direction) dir; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Message::Message(string mimetext) |
||||
|
: _msg(NULL, &free_message) |
||||
|
{ |
||||
|
message *_cpy; |
||||
|
PEP_STATUS status = mime_decode_message(mimetext.c_str(), |
||||
|
mimetext.size(), &_cpy, NULL); |
||||
|
switch (status) { |
||||
|
case PEP_STATUS_OK: |
||||
|
if (_cpy) |
||||
|
_cpy->dir = PEP_dir_outgoing; |
||||
|
else |
||||
|
_cpy = new_message(PEP_dir_outgoing); |
||||
|
|
||||
|
if (!_cpy) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
_msg = shared_ptr< message >(_cpy); |
||||
|
break; |
||||
|
|
||||
|
case PEP_BUFFER_TOO_SMALL: |
||||
|
throw runtime_error("mime_decode_message: buffer too small"); |
||||
|
|
||||
|
case PEP_CANNOT_CREATE_TEMP_FILE: |
||||
|
throw runtime_error("mime_decode_message: cannot create temp file"); |
||||
|
|
||||
|
case PEP_OUT_OF_MEMORY: |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
default: |
||||
|
stringstream build; |
||||
|
build << "mime_decode_message: unknown error (" << (int) status << ")"; |
||||
|
throw runtime_error(build.str()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Message::Message(const Message& second) |
||||
|
: _msg(second._msg) |
||||
|
{ |
||||
|
if (!_msg.get()) |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
|
||||
|
Message::Message(message *msg) |
||||
|
: _msg(::message_dup(msg), &free_message) |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Message::~Message() |
||||
|
{ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
Message::operator message *() |
||||
|
{ |
||||
|
return _msg.get(); |
||||
|
} |
||||
|
|
||||
|
Message::operator const message *() const |
||||
|
{ |
||||
|
return _msg.get(); |
||||
|
} |
||||
|
|
||||
|
string Message::_str() |
||||
|
{ |
||||
|
if (!(_msg->from && _msg->from->address && _msg->from->address[0])) |
||||
|
throw out_of_range(".from_.address missing"); |
||||
|
|
||||
|
char *mimetext; |
||||
|
string result; |
||||
|
|
||||
|
PEP_STATUS status = mime_encode_message(*this, false, &mimetext, false); |
||||
|
switch (status) { |
||||
|
case PEP_STATUS_OK: |
||||
|
result = mimetext; |
||||
|
free(mimetext); |
||||
|
break; |
||||
|
|
||||
|
case PEP_BUFFER_TOO_SMALL: |
||||
|
throw runtime_error("mime_encode_message: buffer too small"); |
||||
|
|
||||
|
case PEP_CANNOT_CREATE_TEMP_FILE: |
||||
|
throw runtime_error("mime_encode_message: cannot create temp file"); |
||||
|
|
||||
|
case PEP_OUT_OF_MEMORY: |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
default: |
||||
|
stringstream build; |
||||
|
build << "mime_encode_message: unknown error (" << (int) status << ")"; |
||||
|
throw runtime_error(build.str()); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
string Message::_repr() |
||||
|
{ |
||||
|
stringstream build; |
||||
|
build << "Message(" << repr(_str()) << ")"; |
||||
|
return build.str(); |
||||
|
} |
||||
|
|
||||
|
boost::python::tuple Message::attachments() |
||||
|
{ |
||||
|
boost::python::list l; |
||||
|
|
||||
|
for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = |
||||
|
bl->next) { |
||||
|
l.append(Blob(bl, true)); |
||||
|
} |
||||
|
|
||||
|
return boost::python::tuple(l); |
||||
|
} |
||||
|
|
||||
|
void Message::attachments(boost::python::list value) |
||||
|
{ |
||||
|
bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); |
||||
|
if (!bl) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
bloblist_t *_l = bl; |
||||
|
for (int i=0; i<len(value); i++) { |
||||
|
Message::Blob& blob = extract< Message::Blob& >(value[i]); |
||||
|
_l = bloblist_add(_l, blob._bl->value, blob._bl->size, |
||||
|
blob._bl->mime_type, blob._bl->filename); |
||||
|
if (!_l) { |
||||
|
for (_l = bl; _l && _l->value; ) { |
||||
|
free(_l->mime_type); |
||||
|
free(_l->filename); |
||||
|
bloblist_t *_ll = _l; |
||||
|
_l = _l->next; |
||||
|
free(_ll); |
||||
|
} |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (int i=0; i<len(value); i++) { |
||||
|
Message::Blob& blob = extract< Message::Blob& >(value[i]); |
||||
|
blob._bl->value = NULL; |
||||
|
blob._bl->size = 0; |
||||
|
free(blob._bl->mime_type); |
||||
|
blob._bl->mime_type = NULL; |
||||
|
free(blob._bl->filename); |
||||
|
blob._bl->filename = NULL; |
||||
|
} |
||||
|
|
||||
|
free_bloblist(_msg->attachments); |
||||
|
_msg->attachments = bl; |
||||
|
} |
||||
|
|
||||
|
Message Message::encrypt() |
||||
|
{ |
||||
|
boost::python::list extra; |
||||
|
return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0); |
||||
|
} |
||||
|
|
||||
|
Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) |
||||
|
{ |
||||
|
if (!enc_format) |
||||
|
enc_format = PEP_enc_PGP_MIME; |
||||
|
return encrypt_message(*this, extra, enc_format, flags); |
||||
|
} |
||||
|
|
||||
|
boost::python::tuple Message::decrypt(int flags) { |
||||
|
return pEp::PythonAdapter::decrypt_message(*this, flags); |
||||
|
} |
||||
|
|
||||
|
PEP_rating Message::outgoing_rating() |
||||
|
{ |
||||
|
if (_msg->dir != PEP_dir_outgoing) |
||||
|
throw invalid_argument("Message.dir must be outgoing"); |
||||
|
|
||||
|
if (from().address() == "") |
||||
|
throw invalid_argument("from.address needed"); |
||||
|
if (from().username() == "") |
||||
|
throw invalid_argument("from.username needed"); |
||||
|
|
||||
|
if (len(to()) + len(cc()) == 0) |
||||
|
throw invalid_argument("either to or cc needed"); |
||||
|
|
||||
|
PEP_STATUS status = myself(Adapter::session(), _msg->from); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
PEP_rating rating = PEP_rating_undefined; |
||||
|
status = outgoing_message_rating(Adapter::session(), *this, &rating); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
return rating; |
||||
|
} |
||||
|
|
||||
|
PEP_color Message::outgoing_color() |
||||
|
{ |
||||
|
return _color(outgoing_rating()); |
||||
|
} |
||||
|
|
||||
|
Message Message::copy() |
||||
|
{ |
||||
|
message *dup = message_dup(*this); |
||||
|
if (!dup) |
||||
|
throw bad_alloc(); |
||||
|
return Message(dup); |
||||
|
} |
||||
|
|
||||
|
Message Message::deepcopy(dict&) |
||||
|
{ |
||||
|
return copy(); |
||||
|
} |
||||
|
|
||||
|
Message outgoing_message(Identity me) |
||||
|
{ |
||||
|
if (me.address().empty() || me.user_id().empty()) |
||||
|
throw runtime_error("at least address and user_id of own user needed"); |
||||
|
|
||||
|
::myself(Adapter::session(), me); |
||||
|
auto m = Message(PEP_dir_outgoing, &me); |
||||
|
return m; |
||||
|
} |
||||
|
|
||||
|
static object update(Identity ident) |
||||
|
{ |
||||
|
if (ident.address().empty()) |
||||
|
throw runtime_error("at least address needed"); |
||||
|
update_identity(Adapter::session(), ident); |
||||
|
return object(ident); |
||||
|
} |
||||
|
|
||||
|
static boost::python::list update(boost::python::list il) |
||||
|
{ |
||||
|
for (int i=0; i<len(il); i++) { |
||||
|
update(extract< Identity >(il[i])); |
||||
|
} |
||||
|
|
||||
|
return il; |
||||
|
} |
||||
|
|
||||
|
Message incoming_message(string mime_text) |
||||
|
{ |
||||
|
auto m = Message(mime_text); |
||||
|
m.dir(PEP_dir_incoming); |
||||
|
|
||||
|
try { |
||||
|
m.from(update(m.from())); |
||||
|
} |
||||
|
catch (out_of_range&) { } |
||||
|
|
||||
|
try { |
||||
|
m.recv_by(update(m.recv_by())); |
||||
|
} |
||||
|
catch (out_of_range&) { } |
||||
|
|
||||
|
m.to(update(m.to())); |
||||
|
m.cc(update(m.cc())); |
||||
|
m.reply_to(update(m.reply_to())); |
||||
|
|
||||
|
return m; |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
@ -0,0 +1,154 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef MESSAGE_HH |
||||
|
#define MESSAGE_HH |
||||
|
|
||||
|
// System
|
||||
|
#include <string> |
||||
|
#include <boost/python.hpp> |
||||
|
#include <boost/lexical_cast.hpp> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/message.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "str_attr.hh" |
||||
|
#include "identity.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using std::string; |
||||
|
using std::runtime_error; |
||||
|
using std::invalid_argument; |
||||
|
using boost::lexical_cast; |
||||
|
|
||||
|
// Message is owning a message struct
|
||||
|
|
||||
|
class Message { |
||||
|
shared_ptr< ::message > _msg; |
||||
|
|
||||
|
public: |
||||
|
// Blob is owning a bloblist_t struct - or not and just managing
|
||||
|
// one depending on part_of_chain
|
||||
|
|
||||
|
class Blob { |
||||
|
bloblist_t *_bl; |
||||
|
bool part_of_chain; |
||||
|
|
||||
|
public: |
||||
|
Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), |
||||
|
bool chained = false); |
||||
|
Blob(object data, string mime_type = "", string filename = ""); |
||||
|
Blob(const Blob& second); |
||||
|
~Blob(); |
||||
|
|
||||
|
string _repr(); |
||||
|
|
||||
|
string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; } |
||||
|
void mime_type(string value) { str_attr(_bl->mime_type, value); } |
||||
|
|
||||
|
string filename() { return str_attr(_bl->filename); } |
||||
|
void filename(string value) { str_attr(_bl->filename, value); } |
||||
|
|
||||
|
size_t size() { return _bl->size; } |
||||
|
string decode(string encoding); |
||||
|
string decode() { return decode(""); } |
||||
|
|
||||
|
static PyBufferProcs bp; |
||||
|
|
||||
|
friend class Message; |
||||
|
|
||||
|
protected: |
||||
|
static int getbuffer(PyObject *self, Py_buffer *view, int flags); |
||||
|
}; |
||||
|
|
||||
|
Message(int dir = PEP_dir_outgoing, Identity *from = NULL); |
||||
|
Message(string mimetext); |
||||
|
Message(const Message& second); |
||||
|
Message(message *msg); |
||||
|
~Message(); |
||||
|
operator message *(); |
||||
|
operator const message *() const; |
||||
|
|
||||
|
string _str(); |
||||
|
string _repr(); |
||||
|
|
||||
|
PEP_msg_direction dir() { return _msg->dir; } |
||||
|
void dir(PEP_msg_direction value) { _msg->dir = value; } |
||||
|
|
||||
|
string id() { return str_attr(_msg->id); } |
||||
|
void id(string value) { str_attr(_msg->id, value); } |
||||
|
|
||||
|
string shortmsg() { return str_attr(_msg->shortmsg); } |
||||
|
void shortmsg(string value) { str_attr(_msg->shortmsg, value); } |
||||
|
|
||||
|
string longmsg() { return str_attr(_msg->longmsg); } |
||||
|
void longmsg(string value) { str_attr(_msg->longmsg, value); } |
||||
|
|
||||
|
string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); } |
||||
|
void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); } |
||||
|
|
||||
|
boost::python::tuple attachments(); |
||||
|
void attachments(boost::python::list value); |
||||
|
|
||||
|
time_t sent() { return timestamp_attr(_msg->sent); } |
||||
|
void sent(time_t value) { timestamp_attr(_msg->sent, value); } |
||||
|
|
||||
|
time_t recv() { return timestamp_attr(_msg->recv); } |
||||
|
void recv(time_t value) { timestamp_attr(_msg->recv, value); } |
||||
|
|
||||
|
Identity from() { return identity_attr(_msg->from); } |
||||
|
void from(object value) { identity_attr(_msg->from, value); } |
||||
|
|
||||
|
boost::python::list to() { return identitylist_attr(_msg->to); } |
||||
|
void to(boost::python::list value) { identitylist_attr(_msg->to, value); } |
||||
|
|
||||
|
Identity recv_by() { return identity_attr(_msg->recv_by); } |
||||
|
void recv_by(object value) { identity_attr(_msg->recv_by, value); } |
||||
|
|
||||
|
boost::python::list cc() { return identitylist_attr(_msg->cc); } |
||||
|
void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); } |
||||
|
|
||||
|
boost::python::list bcc() { return identitylist_attr(_msg->bcc); } |
||||
|
void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); } |
||||
|
|
||||
|
boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); } |
||||
|
void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); } |
||||
|
|
||||
|
boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); } |
||||
|
void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); } |
||||
|
|
||||
|
boost::python::list references() { return strlist_attr(_msg->references); } |
||||
|
void references(boost::python::list value) { strlist_attr(_msg->references, value); } |
||||
|
|
||||
|
boost::python::list keywords() { return strlist_attr(_msg->keywords); } |
||||
|
void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); } |
||||
|
|
||||
|
string comments() { return str_attr(_msg->comments); } |
||||
|
void comments(string value) { str_attr(_msg->comments, value); } |
||||
|
|
||||
|
dict opt_fields() { return strdict_attr(_msg->opt_fields); } |
||||
|
void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); } |
||||
|
|
||||
|
PEP_enc_format enc_format() { return _msg->enc_format; } |
||||
|
void enc_format(PEP_enc_format value) { _msg->enc_format = value; } |
||||
|
|
||||
|
Message encrypt(); |
||||
|
Message _encrypt(boost::python::list extra, int enc_format=4, int flags=0); |
||||
|
|
||||
|
boost::python::tuple decrypt(int flags=0); |
||||
|
PEP_rating outgoing_rating(); |
||||
|
PEP_color outgoing_color(); |
||||
|
Message deepcopy(dict& memo); |
||||
|
Message copy(); |
||||
|
}; |
||||
|
|
||||
|
Message outgoing_message(Identity me); |
||||
|
Message incoming_message(string mime_text); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* MESSAGE_HH */ |
||||
@ -0,0 +1,172 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/pEpEngine.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
#include <pEp/sync_api.h> |
||||
|
#include <pEp/sync_codec.h> |
||||
|
#include <pEp/distribution_codec.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "message_api.hh" |
||||
|
#include "basic_api.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
using namespace boost::python; |
||||
|
|
||||
|
Message encrypt_message(Message src, boost::python::list extra, int enc_format, int flags) |
||||
|
{ |
||||
|
Identity _from = src.from(); |
||||
|
if (_from.address() == "") |
||||
|
throw invalid_argument("encrypt_message: src.from_.address empty"); |
||||
|
if (_from.username() == "") |
||||
|
throw invalid_argument("encrypt_message: src.from_.username empty"); |
||||
|
|
||||
|
if (_from.user_id() == "") |
||||
|
src.from().user_id(_from.address()); |
||||
|
|
||||
|
stringlist_t *_extra = to_stringlist(extra); |
||||
|
PEP_enc_format _enc_format = (PEP_enc_format) enc_format; |
||||
|
PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags; |
||||
|
message *_dst = NULL; |
||||
|
|
||||
|
message *_src = src; |
||||
|
PEP_STATUS status = encrypt_message(Adapter::session(), _src, _extra, &_dst, |
||||
|
_enc_format, _flags); |
||||
|
free_stringlist(_extra); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
if (!_dst || _dst == _src) |
||||
|
return Message(_src); |
||||
|
|
||||
|
return Message(_dst); |
||||
|
} |
||||
|
|
||||
|
boost::python::tuple decrypt_message(Message src, int flags) |
||||
|
{ |
||||
|
message *_dst = NULL; |
||||
|
stringlist_t *_keylist = NULL; |
||||
|
PEP_rating _rating = PEP_rating_undefined; |
||||
|
PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t) flags; |
||||
|
message *_src = src; |
||||
|
|
||||
|
PEP_STATUS status = ::decrypt_message(Adapter::session(), _src, &_dst, &_keylist, |
||||
|
&_rating, &_flags); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
boost::python::list keylist; |
||||
|
if (_keylist) { |
||||
|
keylist = from_stringlist(_keylist); |
||||
|
free_stringlist(_keylist); |
||||
|
} |
||||
|
|
||||
|
Message dst = _dst ? Message(_dst) : Message(src); |
||||
|
return boost::python::make_tuple(dst, keylist, _rating, _flags); |
||||
|
} |
||||
|
|
||||
|
PEP_color _color(int rating) |
||||
|
{ |
||||
|
return ::color_from_rating((PEP_rating) rating); |
||||
|
} |
||||
|
|
||||
|
boost::python::tuple sync_decode(object buffer) |
||||
|
{ |
||||
|
Py_buffer src; |
||||
|
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); |
||||
|
if (result) |
||||
|
throw invalid_argument("need a contiguous buffer to read"); |
||||
|
|
||||
|
char *dst = NULL; |
||||
|
PEP_STATUS status = PER_to_XER_Sync_msg((char *) src.buf, src.len, &dst); |
||||
|
PyBuffer_Release(&src); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
string _dst(dst); |
||||
|
free(dst); |
||||
|
return boost::python::make_tuple(_dst, 0); |
||||
|
} |
||||
|
|
||||
|
static boost::python::tuple sync_encode(string text) |
||||
|
{ |
||||
|
char *data = NULL; |
||||
|
size_t size = 0; |
||||
|
PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
PyObject *ba = PyBytes_FromStringAndSize(data, size); |
||||
|
free(data); |
||||
|
if (!ba) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
return boost::python::make_tuple(object(handle<>(ba)), 0); |
||||
|
} |
||||
|
|
||||
|
boost::python::tuple Distribution_decode(object buffer) |
||||
|
{ |
||||
|
Py_buffer src; |
||||
|
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); |
||||
|
if (result) |
||||
|
throw invalid_argument("need a contiguous buffer to read"); |
||||
|
|
||||
|
char *dst = NULL; |
||||
|
PEP_STATUS status = PER_to_XER_Distribution_msg((char *) src.buf, src.len, &dst); |
||||
|
PyBuffer_Release(&src); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
string _dst(dst); |
||||
|
free(dst); |
||||
|
return boost::python::make_tuple(_dst, 0); |
||||
|
} |
||||
|
|
||||
|
static boost::python::tuple Distribution_encode(string text) |
||||
|
{ |
||||
|
char *data = NULL; |
||||
|
size_t size = 0; |
||||
|
PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size); |
||||
|
_throw_status(status); |
||||
|
|
||||
|
PyObject *ba = PyBytes_FromStringAndSize(data, size); |
||||
|
free(data); |
||||
|
if (!ba) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
return boost::python::make_tuple(object(handle<>(ba)), 0); |
||||
|
} |
||||
|
|
||||
|
object sync_search(string name) |
||||
|
{ |
||||
|
if (name != "pep.sync") { |
||||
|
return object(); |
||||
|
} |
||||
|
else { |
||||
|
object codecs = import("codecs"); |
||||
|
object CodecInfo = codecs.attr("CodecInfo"); |
||||
|
|
||||
|
object _sync_decode = make_function(sync_decode); |
||||
|
object _sync_encode = make_function(sync_encode); |
||||
|
|
||||
|
return call< object >(CodecInfo.ptr(), _sync_encode, _sync_decode); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
object distribution_search(string name) |
||||
|
{ |
||||
|
if (name != "pep.distribution") { |
||||
|
return object(); |
||||
|
} |
||||
|
else { |
||||
|
object codecs = import("codecs"); |
||||
|
object CodecInfo = codecs.attr("CodecInfo"); |
||||
|
|
||||
|
object _distribution_decode = make_function(Distribution_decode); |
||||
|
object _distribution_encode = make_function(Distribution_encode); |
||||
|
|
||||
|
return call< object >(CodecInfo.ptr(), _distribution_encode, _distribution_decode); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
@ -0,0 +1,27 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef MESSAGE_API_HH |
||||
|
#define MESSAGE_API_HH |
||||
|
|
||||
|
#include "pEpmodule.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
|
||||
|
Message encrypt_message( |
||||
|
Message src, |
||||
|
boost::python::list extra = boost::python::list(), |
||||
|
int enc_format = 4, |
||||
|
int flags = 0 |
||||
|
); |
||||
|
|
||||
|
boost::python::tuple decrypt_message(Message src, int flags=0); |
||||
|
PEP_color _color(int rating); |
||||
|
object sync_search(string name); |
||||
|
object distribution_search(string name); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* MESSAGE_API_HH */ |
||||
@ -0,0 +1,28 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef PEPMODULE_HH |
||||
|
#define PEPMODULE_HH |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/pEpEngine.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "message.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
|
||||
|
extern string device_name; |
||||
|
void config_passive_mode(bool enable); |
||||
|
void config_unencrypted_subject(bool enable); |
||||
|
void key_reset_user(string user_id, string fpr); |
||||
|
void key_reset_all_own_keys(); |
||||
|
void _throw_status(PEP_STATUS status); |
||||
|
PEP_STATUS _messageToSend(::message *msg); |
||||
|
PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* PEPMODULE_HH */ |
||||
@ -0,0 +1,184 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// System
|
||||
|
#include <cstdlib> |
||||
|
#include <boost/python.hpp> |
||||
|
#include <boost/locale.hpp> |
||||
|
|
||||
|
// local
|
||||
|
#include "str_attr.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
using namespace boost::python; |
||||
|
using namespace boost::locale; |
||||
|
|
||||
|
object repr(object s) |
||||
|
{ |
||||
|
return s.attr("__repr__")(); |
||||
|
} |
||||
|
|
||||
|
string repr(string s) |
||||
|
{ |
||||
|
str _s = s.c_str(); |
||||
|
object _r = _s.attr("__repr__")(); |
||||
|
string r = extract< string >(_r); |
||||
|
return r; |
||||
|
} |
||||
|
|
||||
|
string str_attr(char *&str) |
||||
|
{ |
||||
|
if (!str) |
||||
|
return string(""); |
||||
|
return string(str); |
||||
|
} |
||||
|
|
||||
|
void str_attr(char *&str, string value) |
||||
|
{ |
||||
|
string normalized = normalize(value, norm_nfc); |
||||
|
free(str); |
||||
|
str = strdup(normalized.c_str()); |
||||
|
if (!str) |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
|
||||
|
time_t timestamp_attr(timestamp *&ts) |
||||
|
{ |
||||
|
if (!ts) |
||||
|
return 0; |
||||
|
|
||||
|
return timegm(ts); |
||||
|
} |
||||
|
|
||||
|
void timestamp_attr(timestamp *&ts, time_t value) |
||||
|
{ |
||||
|
free_timestamp(ts); |
||||
|
ts = new_timestamp(value); |
||||
|
} |
||||
|
|
||||
|
boost::python::list strlist_attr(stringlist_t *&sl) |
||||
|
{ |
||||
|
boost::python::list result; |
||||
|
|
||||
|
for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { |
||||
|
string s(_sl->value); |
||||
|
result.append(object(s)); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
void strlist_attr(stringlist_t *&sl, boost::python::list value) |
||||
|
{ |
||||
|
stringlist_t *_sl = new_stringlist(NULL); |
||||
|
if (!_sl) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
stringlist_t *_s = _sl; |
||||
|
for (int i=0; i<len(value); i++) { |
||||
|
extract< string > extract_string(value[i]); |
||||
|
if (!extract_string.check()) { |
||||
|
free_stringlist(_sl); |
||||
|
} |
||||
|
string s = extract_string(); |
||||
|
s = normalize(s, norm_nfc); |
||||
|
_s = stringlist_add(_s, s.c_str()); |
||||
|
if (!_s) { |
||||
|
free_stringlist(_sl); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
free_stringlist(sl); |
||||
|
sl = _sl; |
||||
|
} |
||||
|
|
||||
|
dict strdict_attr(stringpair_list_t *&spl) |
||||
|
{ |
||||
|
dict result; |
||||
|
|
||||
|
for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = |
||||
|
_spl->next) { |
||||
|
stringpair_t *p = _spl->value; |
||||
|
if (p->key && p->value) { |
||||
|
string key(p->key); |
||||
|
string value(p->value); |
||||
|
|
||||
|
result[key] = value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
void strdict_attr(stringpair_list_t *&spl, dict value) |
||||
|
{ |
||||
|
stringpair_list_t *_spl = new_stringpair_list(NULL); |
||||
|
if (!_spl) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
stringpair_list_t *_s = _spl; |
||||
|
for (int i=0; i<len(value); i++) { |
||||
|
extract< string > extract_key(value.keys()[i]); |
||||
|
extract< string > extract_value(value.values()[i]); |
||||
|
|
||||
|
if (!(extract_key.check() && extract_value.check())) |
||||
|
free_stringpair_list(_spl); |
||||
|
|
||||
|
string key = extract_key(); |
||||
|
key = normalize(key, norm_nfc); |
||||
|
string _value = extract_value(); |
||||
|
_value = normalize(_value, norm_nfc); |
||||
|
stringpair_t *pair = new_stringpair(key.c_str(), _value.c_str()); |
||||
|
if (!pair) { |
||||
|
free_stringpair_list(_spl); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
_s = stringpair_list_add(_s, pair); |
||||
|
if (!_s) { |
||||
|
free_stringpair_list(_spl); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
free_stringpair_list(spl); |
||||
|
spl = _spl; |
||||
|
} |
||||
|
|
||||
|
stringlist_t *to_stringlist(boost::python::list l) |
||||
|
{ |
||||
|
stringlist_t *result = new_stringlist(NULL); |
||||
|
if (!result) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
stringlist_t *_s = result; |
||||
|
for (int i=0; i<len(l); i++) { |
||||
|
extract< string > extract_string(l[i]); |
||||
|
if (!extract_string.check()) |
||||
|
free_stringlist(result); |
||||
|
string s = extract_string(); |
||||
|
_s = stringlist_add(_s, s.c_str()); |
||||
|
if (!_s) { |
||||
|
free_stringlist(result); |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::python::list from_stringlist(const stringlist_t *sl) |
||||
|
{ |
||||
|
boost::python::list result; |
||||
|
for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { |
||||
|
string s = _sl->value; |
||||
|
result.append(s); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
|
|
||||
@ -0,0 +1,43 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef STR_ATTR_HH |
||||
|
#define STR_ATTR_HH |
||||
|
|
||||
|
// System
|
||||
|
#include <string> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/pEpEngine.h> |
||||
|
#include <pEp/timestamp.h> |
||||
|
#include <pEp/stringlist.h> |
||||
|
#include <pEp/stringpair.h> |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using std::string; |
||||
|
using boost::python::object; |
||||
|
using boost::python::dict; |
||||
|
|
||||
|
object repr(object s); |
||||
|
string repr(string s); |
||||
|
|
||||
|
string str_attr(char *&str); |
||||
|
void str_attr(char *&str, string value); |
||||
|
|
||||
|
time_t timestamp_attr(timestamp *&ts); |
||||
|
void timestamp_attr(timestamp *&ts, time_t value); |
||||
|
|
||||
|
boost::python::list strlist_attr(stringlist_t *&sl); |
||||
|
void strlist_attr(stringlist_t *&sl, boost::python::list value); |
||||
|
|
||||
|
dict strdict_attr(stringpair_list_t *&spl); |
||||
|
void strdict_attr(stringpair_list_t *&spl, dict value); |
||||
|
|
||||
|
stringlist_t *to_stringlist(boost::python::list l); |
||||
|
boost::python::list from_stringlist(const stringlist_t *sl); |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* STR_ATTR_HH */ |
||||
@ -0,0 +1,130 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
// System
|
||||
|
#include <cassert> |
||||
|
|
||||
|
// local
|
||||
|
#include "user_interface.hh" |
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
using namespace std; |
||||
|
using namespace boost::python; |
||||
|
|
||||
|
UserInterface *UserInterface::_ui = nullptr; |
||||
|
|
||||
|
UserInterface::UserInterface() |
||||
|
{ |
||||
|
if (_ui) |
||||
|
throw runtime_error("only one UserInterface thread allowed"); |
||||
|
_ui = this; |
||||
|
} |
||||
|
|
||||
|
UserInterface::~UserInterface() |
||||
|
{ |
||||
|
_ui = nullptr; |
||||
|
} |
||||
|
|
||||
|
UserInterface_callback::UserInterface_callback(PyObject *self) : |
||||
|
UserInterface(), _self(self) |
||||
|
{ |
||||
|
// adapter.ui_object(self);
|
||||
|
// PEP_STATUS status = ::register_sync_callbacks(Adapter::session(),
|
||||
|
// (void *) this, _notifyHandshake, retrieve_next_sync_event);
|
||||
|
// assert(status == PEP_STATUS_OK);
|
||||
|
// if (status)
|
||||
|
// _throw_status(status);
|
||||
|
} |
||||
|
|
||||
|
UserInterface_callback::~UserInterface_callback() |
||||
|
{ |
||||
|
// ::unregister_sync_callbacks(Adapter::session());
|
||||
|
} |
||||
|
|
||||
|
PEP_STATUS UserInterface::_notifyHandshake( |
||||
|
pEp_identity *me, pEp_identity *partner, |
||||
|
sync_handshake_signal signal |
||||
|
) |
||||
|
{ |
||||
|
if (!(me && partner)) |
||||
|
return PEP_ILLEGAL_VALUE; |
||||
|
|
||||
|
auto that = dynamic_cast< UserInterface_callback * >(_ui); |
||||
|
that->notifyHandshake(Identity(me), Identity(partner), signal); |
||||
|
|
||||
|
return PEP_STATUS_OK; |
||||
|
} |
||||
|
|
||||
|
void UserInterface::deliverHandshakeResult(int result, object identities) |
||||
|
{ |
||||
|
identity_list *shared_identities = nullptr; |
||||
|
if (identities != boost::python::api::object() && boost::python::len(identities)) { |
||||
|
shared_identities = new_identity_list(nullptr); |
||||
|
if (!shared_identities) |
||||
|
throw bad_alloc(); |
||||
|
|
||||
|
try { |
||||
|
identity_list *si = shared_identities; |
||||
|
for (int i=0; i < boost::python::len(identities); ++i) { |
||||
|
Identity ident = extract< Identity >(identities[i]); |
||||
|
si = identity_list_add(si, ident); |
||||
|
if (!si) |
||||
|
throw bad_alloc(); |
||||
|
} |
||||
|
} |
||||
|
catch (exception& ex) { |
||||
|
free_identity_list(shared_identities); |
||||
|
throw ex; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), |
||||
|
(sync_handshake_result) result, shared_identities); |
||||
|
free_identity_list(shared_identities); |
||||
|
_throw_status(status); |
||||
|
} |
||||
|
|
||||
|
//PEP_rating UserInterface::get_key_rating_for_user(string user_id, string fpr)
|
||||
|
//{
|
||||
|
// PEP_rating result;
|
||||
|
// PEP_STATUS status =
|
||||
|
// ::get_key_rating_for_user(Adapter::session(),
|
||||
|
// user_id.c_str(), fpr.c_str(), &result);
|
||||
|
// _throw_status(status);
|
||||
|
// return result;
|
||||
|
//}
|
||||
|
|
||||
|
//SYNC_EVENT UserInterface::retrieve_next_sync_event(void *management, unsigned threshold)
|
||||
|
//{
|
||||
|
// time_t started = time(nullptr);
|
||||
|
// bool timeout = false;
|
||||
|
//
|
||||
|
// while (adapter.queue().empty()) {
|
||||
|
// int i = 0;
|
||||
|
// ++i;
|
||||
|
// if (i > 10) {
|
||||
|
// if (time(nullptr) > started + threshold) {
|
||||
|
// timeout = true;
|
||||
|
// break;
|
||||
|
// }
|
||||
|
// i = 0;
|
||||
|
// }
|
||||
|
// nanosleep((const struct timespec[]){{0, 100000000L}}, NULL);
|
||||
|
// }
|
||||
|
//
|
||||
|
// if (timeout)
|
||||
|
// return new_sync_timeout_event();
|
||||
|
//
|
||||
|
// return adapter.queue().pop_front();
|
||||
|
//}
|
||||
|
|
||||
|
void UserInterface_callback::notifyHandshake( |
||||
|
Identity me, Identity partner, sync_handshake_signal signal) |
||||
|
{ |
||||
|
call_method< void >(_self, "notifyHandshake", me, partner, signal); |
||||
|
} |
||||
|
|
||||
|
} // namespace PythonAdapter
|
||||
|
} // namespace pEp {
|
||||
|
|
||||
@ -0,0 +1,60 @@ |
|||||
|
// This file is under GNU Affero General Public License 3.0
|
||||
|
// see LICENSE.txt
|
||||
|
|
||||
|
#ifndef USER_INTERFACE_HH |
||||
|
#define USER_INTERFACE_HH |
||||
|
|
||||
|
// System
|
||||
|
#include <csetjmp> |
||||
|
|
||||
|
// Engine
|
||||
|
#include <pEp/sync_api.h> |
||||
|
#include <pEp/message_api.h> |
||||
|
|
||||
|
// local
|
||||
|
#include "pEpmodule.hh" |
||||
|
|
||||
|
|
||||
|
namespace pEp { |
||||
|
namespace PythonAdapter { |
||||
|
|
||||
|
class UserInterface { |
||||
|
static UserInterface *_ui; |
||||
|
public: |
||||
|
UserInterface(); |
||||
|
virtual ~UserInterface(); |
||||
|
|
||||
|
virtual void notifyHandshake( |
||||
|
Identity me, |
||||
|
Identity partner, |
||||
|
sync_handshake_signal signal) |
||||
|
{ |
||||
|
throw runtime_error("override this method"); |
||||
|
} |
||||
|
|
||||
|
virtual void deliverHandshakeResult(int result, object identities); |
||||
|
|
||||
|
// PEP_rating get_key_rating_for_user(string user_id, string fpr);
|
||||
|
|
||||
|
protected: |
||||
|
static PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal); |
||||
|
}; |
||||
|
|
||||
|
class UserInterface_callback : public UserInterface { |
||||
|
PyObject *_self; |
||||
|
public: |
||||
|
UserInterface_callback(PyObject *self); |
||||
|
~UserInterface_callback(); |
||||
|
|
||||
|
void notifyHandshake( |
||||
|
Identity me, |
||||
|
Identity partner, |
||||
|
sync_handshake_signal signal |
||||
|
); |
||||
|
}; |
||||
|
|
||||
|
} /* namespace PythonAdapter */ |
||||
|
} /* namespace pEp */ |
||||
|
|
||||
|
#endif /* USER_INTERFACE_HH */ |
||||
|
|
||||
@ -1,23 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <boost/python.hpp> |
|
||||
#include "identity.hh" |
|
||||
#include "message.hh" |
|
||||
#include "adapter.hh" |
|
||||
#include <pEp/pEpEngine.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
extern string device_name; |
|
||||
void config_passive_mode(bool enable); |
|
||||
void config_unencrypted_subject(bool enable); |
|
||||
void key_reset_user(string user_id, string fpr); |
|
||||
void key_reset_all_own_keys(); |
|
||||
void _throw_status(PEP_STATUS status); |
|
||||
void messageToSend(Message msg); |
|
||||
PEP_STATUS _messageToSend(::message *msg); |
|
||||
void do_sync_protocol(); |
|
||||
extern Adapter adapter; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,179 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include <boost/python.hpp> |
|
||||
#include <boost/locale.hpp> |
|
||||
#include "str_attr.hh" |
|
||||
#include <stdlib.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace utility { |
|
||||
using namespace std; |
|
||||
using namespace boost::locale; |
|
||||
|
|
||||
object repr(object s) |
|
||||
{ |
|
||||
return s.attr("__repr__")(); |
|
||||
} |
|
||||
|
|
||||
string repr(string s) |
|
||||
{ |
|
||||
str _s = s.c_str(); |
|
||||
object _r = _s.attr("__repr__")(); |
|
||||
string r = extract< string >(_r); |
|
||||
return r; |
|
||||
} |
|
||||
|
|
||||
string str_attr(char *&str) |
|
||||
{ |
|
||||
if (!str) |
|
||||
return string(""); |
|
||||
return string(str); |
|
||||
} |
|
||||
|
|
||||
void str_attr(char *&str, string value) |
|
||||
{ |
|
||||
string normalized = normalize(value, norm_nfc); |
|
||||
free(str); |
|
||||
str = strdup(normalized.c_str()); |
|
||||
if (!str) |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
|
|
||||
time_t timestamp_attr(timestamp *&ts) |
|
||||
{ |
|
||||
if (!ts) |
|
||||
return 0; |
|
||||
|
|
||||
return timegm(ts); |
|
||||
} |
|
||||
|
|
||||
void timestamp_attr(timestamp *&ts, time_t value) |
|
||||
{ |
|
||||
free_timestamp(ts); |
|
||||
ts = new_timestamp(value); |
|
||||
} |
|
||||
|
|
||||
boost::python::list strlist_attr(stringlist_t *&sl) |
|
||||
{ |
|
||||
boost::python::list result; |
|
||||
|
|
||||
for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { |
|
||||
string s(_sl->value); |
|
||||
result.append(object(s)); |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
void strlist_attr(stringlist_t *&sl, boost::python::list value) |
|
||||
{ |
|
||||
stringlist_t *_sl = new_stringlist(NULL); |
|
||||
if (!_sl) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
stringlist_t *_s = _sl; |
|
||||
for (int i=0; i<len(value); i++) { |
|
||||
extract< string > extract_string(value[i]); |
|
||||
if (!extract_string.check()) { |
|
||||
free_stringlist(_sl); |
|
||||
} |
|
||||
string s = extract_string(); |
|
||||
s = normalize(s, norm_nfc); |
|
||||
_s = stringlist_add(_s, s.c_str()); |
|
||||
if (!_s) { |
|
||||
free_stringlist(_sl); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
free_stringlist(sl); |
|
||||
sl = _sl; |
|
||||
} |
|
||||
|
|
||||
dict strdict_attr(stringpair_list_t *&spl) |
|
||||
{ |
|
||||
dict result; |
|
||||
|
|
||||
for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = |
|
||||
_spl->next) { |
|
||||
stringpair_t *p = _spl->value; |
|
||||
if (p->key && p->value) { |
|
||||
string key(p->key); |
|
||||
string value(p->value); |
|
||||
|
|
||||
result[key] = value; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
void strdict_attr(stringpair_list_t *&spl, dict value) |
|
||||
{ |
|
||||
stringpair_list_t *_spl = new_stringpair_list(NULL); |
|
||||
if (!_spl) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
stringpair_list_t *_s = _spl; |
|
||||
for (int i=0; i<len(value); i++) { |
|
||||
extract< string > extract_key(value.keys()[i]); |
|
||||
extract< string > extract_value(value.values()[i]); |
|
||||
|
|
||||
if (!(extract_key.check() && extract_value.check())) |
|
||||
free_stringpair_list(_spl); |
|
||||
|
|
||||
string key = extract_key(); |
|
||||
key = normalize(key, norm_nfc); |
|
||||
string _value = extract_value(); |
|
||||
_value = normalize(_value, norm_nfc); |
|
||||
stringpair_t *pair = new_stringpair(key.c_str(), _value.c_str()); |
|
||||
if (!pair) { |
|
||||
free_stringpair_list(_spl); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
_s = stringpair_list_add(_s, pair); |
|
||||
if (!_s) { |
|
||||
free_stringpair_list(_spl); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
free_stringpair_list(spl); |
|
||||
spl = _spl; |
|
||||
} |
|
||||
|
|
||||
stringlist_t *to_stringlist(boost::python::list l) |
|
||||
{ |
|
||||
stringlist_t *result = new_stringlist(NULL); |
|
||||
if (!result) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
stringlist_t *_s = result; |
|
||||
for (int i=0; i<len(l); i++) { |
|
||||
extract< string > extract_string(l[i]); |
|
||||
if (!extract_string.check()) |
|
||||
free_stringlist(result); |
|
||||
string s = extract_string(); |
|
||||
_s = stringlist_add(_s, s.c_str()); |
|
||||
if (!_s) { |
|
||||
free_stringlist(result); |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
boost::python::list from_stringlist(const stringlist_t *sl) |
|
||||
{ |
|
||||
boost::python::list result; |
|
||||
for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { |
|
||||
string s = _sl->value; |
|
||||
result.append(s); |
|
||||
} |
|
||||
return result; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,36 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <string> |
|
||||
#include <pEp/pEpEngine.h> |
|
||||
#include <pEp/timestamp.h> |
|
||||
#include <pEp/stringlist.h> |
|
||||
#include <pEp/stringpair.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace utility { |
|
||||
using namespace std; |
|
||||
using namespace boost::python; |
|
||||
|
|
||||
object repr(object s); |
|
||||
string repr(string s); |
|
||||
|
|
||||
string str_attr(char *&str); |
|
||||
void str_attr(char *&str, string value); |
|
||||
|
|
||||
time_t timestamp_attr(timestamp *&ts); |
|
||||
void timestamp_attr(timestamp *&ts, time_t value); |
|
||||
|
|
||||
boost::python::list strlist_attr(stringlist_t *&sl); |
|
||||
void strlist_attr(stringlist_t *&sl, boost::python::list value); |
|
||||
|
|
||||
dict strdict_attr(stringpair_list_t *&spl); |
|
||||
void strdict_attr(stringpair_list_t *&spl, dict value); |
|
||||
|
|
||||
stringlist_t *to_stringlist(boost::python::list l); |
|
||||
boost::python::list from_stringlist(const stringlist_t *sl); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,125 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#include "user_interface.hh" |
|
||||
#include <assert.h> |
|
||||
#include <time.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
UserInterface *UserInterface::_ui = nullptr; |
|
||||
|
|
||||
UserInterface::UserInterface() |
|
||||
{ |
|
||||
if (_ui) |
|
||||
throw runtime_error("only one UserInterface thread allowed"); |
|
||||
_ui = this; |
|
||||
} |
|
||||
|
|
||||
UserInterface::~UserInterface() |
|
||||
{ |
|
||||
_ui = nullptr; |
|
||||
} |
|
||||
|
|
||||
UserInterface_callback::UserInterface_callback(PyObject *self) : |
|
||||
UserInterface(), _self(self) |
|
||||
{ |
|
||||
adapter.ui_object(self); |
|
||||
PEP_STATUS status = ::register_sync_callbacks(adapter.session(), |
|
||||
(void *) this, _notifyHandshake, retrieve_next_sync_event); |
|
||||
assert(status == PEP_STATUS_OK); |
|
||||
if (status) |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
UserInterface_callback::~UserInterface_callback() |
|
||||
{ |
|
||||
::unregister_sync_callbacks(adapter.session()); |
|
||||
} |
|
||||
|
|
||||
PEP_STATUS UserInterface::_notifyHandshake( |
|
||||
pEp_identity *me, pEp_identity *partner, |
|
||||
sync_handshake_signal signal |
|
||||
) |
|
||||
{ |
|
||||
if (!(me && partner)) |
|
||||
return PEP_ILLEGAL_VALUE; |
|
||||
|
|
||||
auto that = dynamic_cast< UserInterface_callback * >(_ui); |
|
||||
that->notifyHandshake(Identity(me), Identity(partner), signal); |
|
||||
|
|
||||
return PEP_STATUS_OK; |
|
||||
} |
|
||||
|
|
||||
void UserInterface::deliverHandshakeResult(int result, object identities) |
|
||||
{ |
|
||||
identity_list *shared_identities = nullptr; |
|
||||
if (identities != boost::python::api::object() && |
|
||||
boost::python::len(identities)) { |
|
||||
shared_identities = new_identity_list(nullptr); |
|
||||
if (!shared_identities) |
|
||||
throw bad_alloc(); |
|
||||
|
|
||||
try { |
|
||||
identity_list *si = shared_identities; |
|
||||
for (int i=0; i < boost::python::len(identities); ++i) { |
|
||||
Identity ident = extract< Identity >(identities[i]); |
|
||||
si = identity_list_add(si, ident); |
|
||||
if (!si) |
|
||||
throw bad_alloc(); |
|
||||
} |
|
||||
} |
|
||||
catch (exception& ex) { |
|
||||
free_identity_list(shared_identities); |
|
||||
throw ex; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
PEP_STATUS status = ::deliverHandshakeResult(adapter.session(), |
|
||||
(sync_handshake_result) result, shared_identities); |
|
||||
free_identity_list(shared_identities); |
|
||||
_throw_status(status); |
|
||||
} |
|
||||
|
|
||||
PEP_rating UserInterface::get_key_rating_for_user(string user_id, string fpr) |
|
||||
{ |
|
||||
PEP_rating result; |
|
||||
PEP_STATUS status = |
|
||||
::get_key_rating_for_user(adapter.session(), |
|
||||
user_id.c_str(), fpr.c_str(), &result); |
|
||||
_throw_status(status); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
SYNC_EVENT UserInterface::retrieve_next_sync_event(void *management, unsigned threshold) |
|
||||
{ |
|
||||
time_t started = time(nullptr); |
|
||||
bool timeout = false; |
|
||||
|
|
||||
while (adapter.queue().empty()) { |
|
||||
int i = 0; |
|
||||
++i; |
|
||||
if (i > 10) { |
|
||||
if (time(nullptr) > started + threshold) { |
|
||||
timeout = true; |
|
||||
break; |
|
||||
} |
|
||||
i = 0; |
|
||||
} |
|
||||
nanosleep((const struct timespec[]){{0, 100000000L}}, NULL); |
|
||||
} |
|
||||
|
|
||||
if (timeout) |
|
||||
return new_sync_timeout_event(); |
|
||||
|
|
||||
return adapter.queue().pop_front(); |
|
||||
} |
|
||||
|
|
||||
void UserInterface_callback::notifyHandshake( |
|
||||
Identity me, Identity partner, sync_handshake_signal signal) |
|
||||
{ |
|
||||
call_method< void >(_self, "notifyHandshake", me, partner, signal); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,50 +0,0 @@ |
|||||
// This file is under GNU Affero General Public License 3.0
|
|
||||
// see LICENSE.txt
|
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include "pEpmodule.hh" |
|
||||
#include <setjmp.h> |
|
||||
#include <pEp/sync_api.h> |
|
||||
#include <pEp/message_api.h> |
|
||||
|
|
||||
namespace pEp { |
|
||||
namespace PythonAdapter { |
|
||||
class UserInterface { |
|
||||
static UserInterface *_ui; |
|
||||
public: |
|
||||
UserInterface(); |
|
||||
virtual ~UserInterface(); |
|
||||
|
|
||||
virtual void notifyHandshake( |
|
||||
pEp::PythonAdapter::Identity me, |
|
||||
pEp::PythonAdapter::Identity partner, |
|
||||
sync_handshake_signal signal) |
|
||||
{ |
|
||||
throw runtime_error("override this method"); |
|
||||
} |
|
||||
|
|
||||
virtual void deliverHandshakeResult(int result, object identities); |
|
||||
|
|
||||
PEP_rating get_key_rating_for_user(string user_id, string fpr); |
|
||||
|
|
||||
protected: |
|
||||
static PEP_STATUS _notifyHandshake(pEp_identity *me, |
|
||||
pEp_identity *partner, sync_handshake_signal signal); |
|
||||
static SYNC_EVENT retrieve_next_sync_event(void *management, unsigned threshold); |
|
||||
}; |
|
||||
|
|
||||
class UserInterface_callback : public UserInterface { |
|
||||
PyObject *_self; |
|
||||
public: |
|
||||
UserInterface_callback(PyObject *self); |
|
||||
~UserInterface_callback(); |
|
||||
|
|
||||
void notifyHandshake( |
|
||||
pEp::PythonAdapter::Identity me, |
|
||||
pEp::PythonAdapter::Identity partner, |
|
||||
sync_handshake_signal signal); |
|
||||
}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -0,0 +1,47 @@ |
|||||
|
#!/usr/bin/env python3 |
||||
|
# -*- coding: utf-8 -*- |
||||
|
|
||||
|
import pEp |
||||
|
import time |
||||
|
|
||||
|
def message_to_send(msg): |
||||
|
print("User defined message_to_send() called") |
||||
|
m, keys, rating, flags = msg.decrypt() |
||||
|
try: |
||||
|
print(m.attachments[0].decode()) |
||||
|
except UnicodeDecodeError as e: |
||||
|
print("decode failed") |
||||
|
|
||||
|
def notify_handshake(me, partner, signal): |
||||
|
print("User defined notify_handshake() called") |
||||
|
print(me) |
||||
|
print(partner) |
||||
|
print(signal) |
||||
|
|
||||
|
def start_stop_sync(duration): |
||||
|
pEp.start_sync() |
||||
|
time.sleep(duration) |
||||
|
pEp.shutdown_sync() |
||||
|
|
||||
|
|
||||
|
alice = pEp.Identity("test@alice.com", "alice", "23") |
||||
|
pEp.myself(alice) |
||||
|
print(alice.fpr) |
||||
|
|
||||
|
dir(pEp) |
||||
|
|
||||
|
# test default callback |
||||
|
start_stop_sync(1) |
||||
|
|
||||
|
# test user defined callback |
||||
|
pEp.message_to_send = message_to_send |
||||
|
# pEp.notify_handshake = notify_handshake |
||||
|
|
||||
|
start_stop_sync(1) |
||||
|
|
||||
|
# pEp.start_sync() |
||||
|
# while(True): |
||||
|
# print("is_sync_active: {}".format(pEp.is_sync_active())) |
||||
|
# time.sleep(3) |
||||
|
# pEp.key_reset_all_own_keys() |
||||
|
# time.sleep(3) |
||||
Loading…
Reference in new issue