You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
761 lines
39 KiB
761 lines
39 KiB
// This file is under GNU Affero General Public License 3.0
|
|
// see LICENSE.txt
|
|
|
|
// System
|
|
#include <boost/python.hpp>
|
|
#include <boost/locale.hpp>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <mutex>
|
|
|
|
// Engine
|
|
#include <pEp/key_reset.h>
|
|
#include <pEp/message_api.h>
|
|
#include <pEp/sync_api.h>
|
|
#include <pEp/status_to_string.h>
|
|
|
|
// libpEpAdapter
|
|
#include <pEp/Adapter.hh>
|
|
#include <pEp/callback_dispatcher.hh>
|
|
#include <pEp/pEpLog.hh>
|
|
|
|
// local
|
|
#include "pEpmodule.hh"
|
|
#include "basic_api.hh"
|
|
#include "message_api.hh"
|
|
//#include "user_interface.hh"
|
|
|
|
namespace pEp {
|
|
namespace PythonAdapter {
|
|
using namespace boost::python;
|
|
|
|
static const char *version_string = "p≡p Python adapter version 0.3";
|
|
|
|
void _init_callbackdispatcher()
|
|
{
|
|
pEpLog("called");
|
|
callback_dispatcher.add(_messageToSend, _notifyHandshake, nullptr, nullptr);
|
|
}
|
|
|
|
void _init_session(bool mode_async)
|
|
{
|
|
pEpLog("called");
|
|
if (mode_async) {
|
|
Adapter::session.initialize(pEp::Adapter::SyncModes::Async, true);
|
|
} else {
|
|
Adapter::session.initialize(pEp::Adapter::SyncModes::Sync, true);
|
|
}
|
|
}
|
|
|
|
void config_passive_mode(bool enable)
|
|
{
|
|
::config_passive_mode(Adapter::session(), enable);
|
|
}
|
|
|
|
void config_unencrypted_subject(bool enable)
|
|
{
|
|
::config_unencrypted_subject(Adapter::session(), enable);
|
|
}
|
|
|
|
void key_reset_user(string user_id, string fpr)
|
|
{
|
|
if (user_id == "") {
|
|
throw invalid_argument("user_id required");
|
|
}
|
|
|
|
PEP_STATUS status = ::key_reset_user(
|
|
Adapter::session(),
|
|
user_id.c_str(),
|
|
fpr != "" ? fpr.c_str() : nullptr);
|
|
_throw_status(status);
|
|
}
|
|
|
|
void key_reset_all_own_keys()
|
|
{
|
|
PEP_STATUS status = ::key_reset_all_own_keys(Adapter::session());
|
|
_throw_status(status);
|
|
}
|
|
|
|
static string about()
|
|
{
|
|
string version = string(version_string) + "\np≡p version " + PEP_VERSION + "\n";
|
|
return version;
|
|
}
|
|
|
|
void _throw_status(PEP_STATUS status)
|
|
{
|
|
if (status == PEP_STATUS_OK) {
|
|
return;
|
|
}
|
|
if (status >= 0x400 && status <= 0x4ff) {
|
|
return;
|
|
}
|
|
if (status == PEP_OUT_OF_MEMORY) {
|
|
throw std::bad_alloc();
|
|
}
|
|
if (status == PEP_ILLEGAL_VALUE) {
|
|
throw invalid_argument("illegal value");
|
|
}
|
|
if (string(pEp_status_to_string(status)) == "unknown status code") {
|
|
std::stringstream build;
|
|
build << std::setfill('0') << "p≡p 0x" << std::setw(4) << std::hex << status;
|
|
throw runtime_error(build.str());
|
|
} else {
|
|
throw runtime_error(pEp_status_to_string(status));
|
|
}
|
|
}
|
|
|
|
PEP_STATUS _messageToSend(::message *msg)
|
|
{
|
|
pEpLog("called");
|
|
object modref = import("pEp");
|
|
object funcref = modref.attr("message_to_send");
|
|
call<void>(funcref.ptr(), Message(msg));
|
|
return PEP_STATUS_OK;
|
|
}
|
|
|
|
PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
|
|
{
|
|
pEpLog("called");
|
|
object modref = import("pEp");
|
|
object funcref = modref.attr("notify_handshake");
|
|
call<void>(funcref.ptr(), Identity(me), Identity(partner), signal);
|
|
return PEP_STATUS_OK;
|
|
}
|
|
|
|
bool _do_protocol_step_from_queue()
|
|
{
|
|
pEpLog("called");
|
|
SYNC_EVENT event = Adapter::_cb_retrieve_next_sync_event_dequeue_next_sync_event(
|
|
nullptr,
|
|
0);
|
|
if (event != NULL) {
|
|
::do_sync_protocol_step(Adapter::session(), event);
|
|
return true;
|
|
} else {
|
|
pEpLog("null event, signaling sync shutdown");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void _free_session()
|
|
{
|
|
::unregister_sync_callbacks(Adapter::session());
|
|
Adapter::session.release();
|
|
}
|
|
|
|
// TODO: Integrate this (currently SEGFAULTING)
|
|
void _notifyHandshake_sync_start()
|
|
{
|
|
pEpLog("all targets signal: SYNC_NOTIFY_START");
|
|
CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_START);
|
|
}
|
|
|
|
// TODO: Integrate this (currently SEGFAULTING)
|
|
void _notifyHandshake_sync_stop()
|
|
{
|
|
pEpLog("all targets signal: SYNC_NOTIFY_STOP");
|
|
CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_STOP);
|
|
}
|
|
|
|
void debug_color(int ansi_color)
|
|
{
|
|
::set_debug_color(Adapter::session(), ansi_color);
|
|
}
|
|
|
|
void leave_device_group()
|
|
{
|
|
::leave_device_group(Adapter::session());
|
|
}
|
|
|
|
void disable_all_sync_channels()
|
|
{
|
|
::disable_all_sync_channels(Adapter::session());
|
|
}
|
|
|
|
void 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 std::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 std::bad_alloc();
|
|
}
|
|
}
|
|
} catch (std::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);
|
|
}
|
|
|
|
void _log(const std::string& msg) {
|
|
pEpLog(msg);
|
|
}
|
|
|
|
BOOST_PYTHON_MODULE(_pEp)
|
|
{
|
|
def("_init_callbackdispatcher", _init_callbackdispatcher);
|
|
|
|
docstring_options doc_options(true, false, false);
|
|
boost::locale::generator gen;
|
|
std::locale::global(gen(""));
|
|
|
|
scope().attr("about") = about();
|
|
scope().attr("per_user_directory") = per_user_directory();
|
|
scope().attr("per_machine_directory") = per_machine_directory();
|
|
scope().attr("engine_version") = get_engine_version();
|
|
scope().attr("protocol_version") = get_protocol_version();
|
|
|
|
def("set_debug_log_enabled", &Adapter::pEpLog::set_enabled, "Switch debug logging on/off");
|
|
def("_log", _log);
|
|
|
|
def("_init_session", _init_session);
|
|
def("_free_session", _free_session);
|
|
def("_do_protocol_step_from_queue", _do_protocol_step_from_queue);
|
|
def("_inject_sync_shutdown", Adapter::inject_sync_shutdown);
|
|
def("_notifyHandshake_sync_start", _notifyHandshake_sync_start);
|
|
def("_notifyHandshake_sync_stop", _notifyHandshake_sync_stop);
|
|
|
|
def("passive_mode", config_passive_mode, "do not attach pub keys to all messages");
|
|
|
|
def("unencrypted_subject",
|
|
config_unencrypted_subject,
|
|
"do not encrypt the subject of messages");
|
|
|
|
def("key_reset",
|
|
key_reset_user,
|
|
"reset the default database status for the user / keypair provided\n"
|
|
"This will effectively perform key_reset on each identity\n"
|
|
"associated with the key and user_id, if a key is provided, and for\n"
|
|
"each key (and all of their identities) if an fpr is not.");
|
|
|
|
def("key_reset_all_own_keys",
|
|
key_reset_all_own_keys,
|
|
"revoke and mistrust all own keys, generate new keys for all\n"
|
|
"own identities, and opportunistically communicate key reset\n"
|
|
"information to people we have recently contacted.");
|
|
|
|
auto
|
|
identity_class = class_<Identity>(
|
|
"Identity",
|
|
"Identity(address, username, user_id='', fpr='', comm_type=0, lang='en')\n"
|
|
"\n"
|
|
"represents a p≡p identity\n"
|
|
"\n"
|
|
"an identity is a network address, under which a user is represented in\n"
|
|
"the network\n"
|
|
"\n"
|
|
" address network address, either an SMTP address or a URI\n"
|
|
" username real name or nickname for user\n"
|
|
" user_id ID this user is handled by the application\n"
|
|
" fpr full fingerprint of the key being used as key ID,\n"
|
|
" hex encoded\n"
|
|
" comm_type first rating level of this communication channel\n"
|
|
" lang ISO 639-1 language code for language being preferred\n"
|
|
" on this communication channel\n")
|
|
.def(boost::python::init<string>())
|
|
.def(boost::python::init<string, string>())
|
|
.def(boost::python::init<string, string, string>())
|
|
.def(boost::python::init<string, string, string, string>())
|
|
.def(boost::python::init<string, string, string, string, int>())
|
|
.def(boost::python::init<string, string, string, string, int, string>())
|
|
.def("__repr__", &Identity::_repr)
|
|
.def(
|
|
"__str__",
|
|
&Identity::_str,
|
|
"string representation of this identity\n"
|
|
"following the pattern 'username < address >'\n")
|
|
.def(
|
|
"key_reset",
|
|
&Identity::key_reset,
|
|
boost::python::arg("fpr") = object(""),
|
|
"reset the default database status for the identity / keypair provided. If this\n"
|
|
"corresponds to the own user and a private key, also revoke the key, generate a\n"
|
|
"new one, and communicate the reset to recently contacted pEp partners for this\n"
|
|
"identity. If it does not, remove the key from the keyring; the key's status is\n"
|
|
"completely fresh on next contact from the partner.")
|
|
|
|
.def(
|
|
"key_mistrusted",
|
|
&Identity::key_mistrusted,
|
|
boost::python::arg("fpr") = object(""),
|
|
"If you want updated trust on the identity, you ll have"
|
|
"to call update_identity or myself respectively after this."
|
|
"N.B. If you are calling this on a key that is the identity or user default,"
|
|
"it will be removed as the default key for ANY identity and user for which"
|
|
"it is the default. Please keep in mind that the undo in undo_last_mistrust"
|
|
"will only undo the current identity's / it's user's default, not any"
|
|
"other identities which may be impacted (this will not affect most use cases)")
|
|
|
|
.def(
|
|
"enable_for_sync",
|
|
&Identity::enable_for_sync,
|
|
"Enable own identity for p≡p sync.\n\n"
|
|
"Only use this on own identities, which are used as accounts.\n")
|
|
.def(
|
|
"disable_for_sync",
|
|
&Identity::disable_for_sync,
|
|
"Disable own identity for p≡p sync.\n\n"
|
|
"Only use this on own identities, which are used as accounts.\n")
|
|
|
|
.add_property(
|
|
"address",
|
|
(string(Identity::*)()) & Identity::address,
|
|
(void(Identity::*)(string)) & Identity::address,
|
|
"email address or URI")
|
|
.add_property(
|
|
"fpr",
|
|
(string(Identity::*)()) & Identity::fpr,
|
|
(void(Identity::*)(string)) & Identity::fpr,
|
|
"key ID (full fingerprint, hex encoded)")
|
|
.add_property(
|
|
"user_id",
|
|
(string(Identity::*)()) & Identity::user_id,
|
|
(void(Identity::*)(string)) & Identity::user_id,
|
|
"ID of person associated or 'pEp_own_userId' if own identity")
|
|
.add_property(
|
|
"username",
|
|
(string(Identity::*)()) & Identity::username,
|
|
(void(Identity::*)(string)) & Identity::username,
|
|
"name in full of person associated")
|
|
.add_property(
|
|
"comm_type",
|
|
(int(Identity::*)())(PEP_comm_type(Identity::*)()) &
|
|
Identity::comm_type,
|
|
(void(Identity::*)(int))(void(Identity::*)(PEP_comm_type)) &
|
|
Identity::comm_type,
|
|
"communication type, first rating level (p≡p internal)")
|
|
.add_property(
|
|
"lang",
|
|
(string(Identity::*)()) & Identity::lang,
|
|
(void(Identity::*)(string)) & Identity::lang,
|
|
"ISO 639-1 language code")
|
|
.add_property(
|
|
"flags",
|
|
(identity_flags_t(Identity::*)()) & Identity::flags,
|
|
(void(Identity::*)(identity_flags_t)) & Identity::flags,
|
|
"flags (p≡p internal)")
|
|
.add_property("rating", &Identity::rating, "rating of Identity")
|
|
.add_property(
|
|
"color",
|
|
&Identity::color,
|
|
"color of Identity as PEP_color")
|
|
.add_property(
|
|
"is_pEp_user",
|
|
&Identity::is_pEp_user,
|
|
"True if this is an identity of a pEp user")
|
|
.def("__deepcopy__", &Identity::deepcopy)
|
|
.def("update", &Identity::update, "update Identity")
|
|
.def("__copy__", &Identity::copy);
|
|
|
|
identity_class.attr("PEP_OWN_USERID") = "pEp_own_userId";
|
|
|
|
auto blob_class = class_<Message::Blob>(
|
|
"Blob",
|
|
"Blob(data, mime_type='', filename='')\n"
|
|
"\n"
|
|
"Binary large object\n"
|
|
"\n"
|
|
" data bytes-like object\n"
|
|
" mime_type MIME type for the data\n"
|
|
" filename filename to store the data\n",
|
|
boost::python::init<object, char const *, char const *>(
|
|
args("data", "mime_type", "filename")))
|
|
.def(boost::python::init<object, string>())
|
|
.def(boost::python::init<object>())
|
|
.def("__repr__", &Message::Blob::_repr)
|
|
.def("__len__", &Message::Blob::size, "size of Blob data in bytes")
|
|
.def("decode", (string(Message::Blob::*)()) & Message::Blob::decode)
|
|
.def(
|
|
"decode",
|
|
(string(Message::Blob::*)(string)) & Message::Blob::decode,
|
|
"text = blob.decode(encoding='')\n"
|
|
"\n"
|
|
"decode Blob data into string depending on MIME type if encoding=''\n"
|
|
"\n"
|
|
" mime_type='application/pEp.sync' decode as 'pEp.sync'\n"
|
|
" mime_type='application/pEp.keyreset' decode as 'pEp.keyreset'\n"
|
|
" other mime_type decode as 'ascii' by default\n")
|
|
.add_property(
|
|
"mime_type",
|
|
(string(Message::Blob::*)()) & Message::Blob::mime_type,
|
|
(void(Message::Blob::*)(string)) & Message::Blob::mime_type,
|
|
"MIME type of object in Blob")
|
|
.add_property(
|
|
"filename",
|
|
(string(Message::Blob::*)()) & Message::Blob::filename,
|
|
(void(Message::Blob::*)(string)) & Message::Blob::filename,
|
|
"filename of object in Blob");
|
|
|
|
((PyTypeObject *)(void *)blob_class.ptr())->tp_as_buffer = &Message::Blob::bp;
|
|
|
|
auto message_class = class_<Message>(
|
|
"Message",
|
|
"Message(dir=1, from=None)\n"
|
|
"\n"
|
|
"new p≡p message\n"
|
|
"\n"
|
|
" dir 1 for outgoing, 2 for incoming\n"
|
|
" from Identity() of sender\n"
|
|
"\n"
|
|
"Message(mime_text)\n"
|
|
"\n"
|
|
"new incoming p≡p message\n"
|
|
"\n"
|
|
" mime_text text in Multipurpose Internet Mail Extensions format\n")
|
|
.def(boost::python::init<int>())
|
|
.def(boost::python::init<int, Identity *>())
|
|
.def(boost::python::init<string>())
|
|
.def(
|
|
"__str__",
|
|
&Message::_str,
|
|
"the string representation of a Message is it's MIME text")
|
|
.def("__repr__", &Message::_repr)
|
|
.add_property(
|
|
"dir",
|
|
(int(Message::*)())(PEP_msg_direction(Message::*)()) &
|
|
Message::dir,
|
|
(void(Message::*)(int))(void(Message::*)(PEP_msg_direction)) &
|
|
Message::dir,
|
|
"0: incoming, 1: outgoing message")
|
|
.add_property(
|
|
"id",
|
|
(string(Message::*)()) & Message::id,
|
|
(void(Message::*)(string)) & Message::id,
|
|
"message ID")
|
|
.add_property(
|
|
"shortmsg",
|
|
(string(Message::*)()) & Message::shortmsg,
|
|
(void(Message::*)(string)) & Message::shortmsg,
|
|
"subject or short message")
|
|
.add_property(
|
|
"longmsg",
|
|
(string(Message::*)()) & Message::longmsg,
|
|
(void(Message::*)(string)) & Message::longmsg,
|
|
"body or long version of message")
|
|
.add_property(
|
|
"longmsg_formatted",
|
|
(string(Message::*)()) & Message::longmsg_formatted,
|
|
(void(Message::*)(string)) & Message::longmsg_formatted,
|
|
"HTML body or fromatted long version of message")
|
|
.add_property(
|
|
"attachments",
|
|
(boost::python::tuple(Message::*)()) & Message::attachments,
|
|
(void(Message::*)(boost::python::list)) &
|
|
Message::attachments,
|
|
"tuple of Blobs with attachments; setting moves Blobs to attachment tuple")
|
|
.add_property(
|
|
"sent",
|
|
(time_t(Message::*)()) & Message::sent,
|
|
(void(Message::*)(time_t)) & Message::sent,
|
|
"time when message was sent in UTC seconds since epoch")
|
|
.add_property(
|
|
"recv",
|
|
(time_t(Message::*)()) & Message::recv,
|
|
(void(Message::*)(time_t)) & Message::recv,
|
|
"time when message was received in UTC seconds since epoch")
|
|
.add_property(
|
|
"from_",
|
|
(Identity(Message::*)()) & Message::from,
|
|
(void(Message::*)(object)) & Message::from,
|
|
"identity where message is from")
|
|
.add_property(
|
|
"to",
|
|
(boost::python::list(Message::*)()) & Message::to,
|
|
(void(Message::*)(boost::python::list)) & Message::to,
|
|
"list of identities message is going to")
|
|
.add_property(
|
|
"recv_by",
|
|
(Identity(Message::*)()) & Message::recv_by,
|
|
(void(Message::*)(object)) & Message::recv_by,
|
|
"identity where message was received by")
|
|
.add_property(
|
|
"cc",
|
|
(boost::python::list(Message::*)()) & Message::cc,
|
|
(void(Message::*)(boost::python::list)) & Message::cc,
|
|
"list of identities message is going cc")
|
|
.add_property(
|
|
"bcc",
|
|
(boost::python::list(Message::*)()) & Message::bcc,
|
|
(void(Message::*)(boost::python::list)) & Message::bcc,
|
|
"list of identities message is going bcc")
|
|
.add_property(
|
|
"reply_to",
|
|
(boost::python::list(Message::*)()) & Message::reply_to,
|
|
(void(Message::*)(boost::python::list)) & Message::reply_to,
|
|
"list of identities where message will be replied to")
|
|
.add_property(
|
|
"in_reply_to",
|
|
(boost::python::list(Message::*)()) & Message::in_reply_to,
|
|
(void(Message::*)(boost::python::list)) &
|
|
Message::in_reply_to,
|
|
"in_reply_to list")
|
|
.add_property(
|
|
"references",
|
|
(boost::python::list(Message::*)()) & Message::references,
|
|
(void(Message::*)(boost::python::list)) & Message::references,
|
|
"message IDs of messages this one is referring to")
|
|
.add_property(
|
|
"keywords",
|
|
(boost::python::list(Message::*)()) & Message::keywords,
|
|
(void(Message::*)(boost::python::list)) & Message::keywords,
|
|
"keywords this message should be stored under")
|
|
.add_property(
|
|
"comments",
|
|
(string(Message::*)()) & Message::comments,
|
|
(void(Message::*)(string)) & Message::comments,
|
|
"comments added to message")
|
|
.add_property(
|
|
"opt_fields",
|
|
(dict(Message::*)()) & Message::opt_fields,
|
|
(void(Message::*)(dict)) & Message::opt_fields,
|
|
"opt_fields of message")
|
|
.add_property(
|
|
"enc_format",
|
|
(int(Message::*)())(PEP_enc_format(Message::*)()) &
|
|
Message::enc_format,
|
|
(void(Message::*)(int))(void(Message::*)(PEP_enc_format)) &
|
|
Message::enc_format,
|
|
"0: unencrypted, 1: inline PGP, 2: S/MIME, 3: PGP/MIME, 4: p≡p format")
|
|
.def("encrypt", (Message(Message::*)()) & Message::encrypt)
|
|
.def(
|
|
"encrypt",
|
|
(Message(Message::*)(boost::python::list)) &
|
|
Message::_encrypt)
|
|
.def(
|
|
"encrypt",
|
|
(Message(Message::*)(boost::python::list, int)) &
|
|
Message::_encrypt)
|
|
.def(
|
|
"encrypt",
|
|
(Message(Message::*)(boost::python::list, int, int)) &
|
|
Message::_encrypt,
|
|
"msg2 = msg1.encrypt(extra_keys=[], enc_format='pEp', flags=0)\n"
|
|
"\n"
|
|
"encrypts a p≡p message and returns the encrypted message\n"
|
|
"\n"
|
|
" extra_keys list of strings with fingerprints for extra keys to use\n"
|
|
" for encryption\n"
|
|
" enc_format 0 for none, 1 for partitioned, 2 for S/MIME,\n"
|
|
" 3 for PGP/MIME, 4 for pEp\n"
|
|
" flags 1 is force encryption\n")
|
|
.def(
|
|
"decrypt",
|
|
&Message::decrypt,
|
|
boost::python::arg("flags") = 0,
|
|
"msg2, keys, rating, flags = msg1.decrypt()\n"
|
|
"\n"
|
|
"decrypts a p≡p message and returns a tuple with data\n"
|
|
"\n"
|
|
" msg the decrypted p≡p message\n"
|
|
" keys a list of keys being used\n"
|
|
" rating the rating of the message as integer\n"
|
|
" flags flags set while decryption\n")
|
|
.add_property(
|
|
"outgoing_rating",
|
|
&Message::outgoing_rating,
|
|
"rating outgoing message will have")
|
|
.add_property(
|
|
"outgoing_color",
|
|
&Message::outgoing_color,
|
|
"color outgoing message will have as PEP_color")
|
|
.def("__deepcopy__", &Message::deepcopy)
|
|
.def("__copy__", &Message::copy);
|
|
|
|
// basic API and key management API
|
|
|
|
def("update_identity",
|
|
&update_identity,
|
|
"update_identity(ident)\n"
|
|
"\n"
|
|
"update identity information\n"
|
|
"call this to complete identity information when you at least have an address\n");
|
|
def("myself",
|
|
&myself,
|
|
"myself(ident)\n"
|
|
"\n"
|
|
"ensures that the own identity is being complete\n"
|
|
"supply ident.address and ident.username\n");
|
|
def("trust_personal_key",
|
|
&trust_personal_key,
|
|
"trust_personal_key(ident)\n"
|
|
"\n"
|
|
"mark a key as trusted with a person\n");
|
|
|
|
enum_<identity_flags>("identity_flags")
|
|
.value("PEP_idf_not_for_sync", PEP_idf_not_for_sync)
|
|
.value("PEP_idf_list", PEP_idf_list)
|
|
.value("PEP_idf_devicegroup", PEP_idf_devicegroup);
|
|
|
|
def("set_identity_flags",
|
|
&set_identity_flags,
|
|
"set_identity_flags(ident, flags)\n"
|
|
"\n"
|
|
"set identity flags\n");
|
|
|
|
def("unset_identity_flags",
|
|
&unset_identity_flags,
|
|
"unset_identity_flags(ident, flags)\n"
|
|
"\n"
|
|
"unset identity flags\n");
|
|
|
|
def("key_reset_trust",
|
|
&key_reset_trust,
|
|
"key_reset_trust(ident)\n"
|
|
"\n"
|
|
"reset trust bit or explicitly mistrusted status for an identity and "
|
|
"its accompanying key/user_id pair\n");
|
|
|
|
def("import_key",
|
|
&import_key,
|
|
"imported_keys, affected_own_identities = import_key(key_data)\n"
|
|
"\n"
|
|
"import key(s) from key_data\n");
|
|
|
|
def("export_key",
|
|
&export_key,
|
|
"key_data = export_key(identity)\n"
|
|
"\n"
|
|
"export key(s) of identity\n");
|
|
|
|
def("export_secret_key",
|
|
&export_secret_key,
|
|
"key_data = export_seret_key(identity)\n"
|
|
"\n"
|
|
"export secret key(s) of identity\n");
|
|
|
|
def("set_own_key",
|
|
&set_own_key,
|
|
"set_own_key(me, fpr)\n"
|
|
"\n"
|
|
"mark a key as an own key, and make it the default key\n"
|
|
"\n"
|
|
"me Own identity for which to add the existing key\n"
|
|
"fpr The fingerprint of the key to be added\n"
|
|
"\n"
|
|
"me->address, me->user_id and me->username must be set to valid data\n"
|
|
"myself() is called by set_own_key() without key generation\n"
|
|
"me->flags are ignored\n"
|
|
"me->address must not be an alias\n"
|
|
"me->fpr will be ignored and replaced by fpr\n");
|
|
|
|
def("set_comm_partner_key",
|
|
&set_comm_partner_key,
|
|
"set_comm_partner_key(ident, fpr)\n"
|
|
"\n"
|
|
"Mark a key the default for a comm partner\n"
|
|
"\n"
|
|
"ident partner identity this key is used for\n"
|
|
"fpr fingerprint of the key to set as the identity default\n");
|
|
|
|
// message API
|
|
|
|
enum_<PEP_rating>("rating")
|
|
.value("_undefined", PEP_rating_undefined)
|
|
.value("cannot_decrypt", PEP_rating_cannot_decrypt)
|
|
.value("have_no_key", PEP_rating_have_no_key)
|
|
.value("unencrypted", PEP_rating_unencrypted)
|
|
.value("unreliable", PEP_rating_unreliable)
|
|
.value("reliable", PEP_rating_reliable)
|
|
.value("trusted", PEP_rating_trusted)
|
|
.value("trusted_and_anonymized", PEP_rating_trusted_and_anonymized)
|
|
.value("fully_anonymous", PEP_rating_fully_anonymous)
|
|
.value("mistrust", PEP_rating_mistrust)
|
|
.value("b0rken", PEP_rating_b0rken)
|
|
.value("under_attack", PEP_rating_under_attack);
|
|
|
|
enum_<PEP_color>("colorvalue")
|
|
.value("no_color", PEP_color_no_color)
|
|
.value("yellow", PEP_color_yellow)
|
|
.value("green", PEP_color_green)
|
|
.value("red", PEP_color_red);
|
|
|
|
|
|
def("incoming_message",
|
|
&incoming_message,
|
|
"msg = incoming_message(mime_text)\n"
|
|
"\n"
|
|
"create an incoming message from a MIME text");
|
|
def("outgoing_message",
|
|
&outgoing_message,
|
|
"msg = outgoing_message(ident)\n"
|
|
"\n"
|
|
"create an outgoing message using an own identity");
|
|
def("color",
|
|
&_color,
|
|
"c = color(rating)\n"
|
|
"\n"
|
|
"calculate color value out of rating. Returns PEP_color");
|
|
def("trustwords",
|
|
&_trustwords,
|
|
"text = trustwords(ident_own, ident_partner)\n"
|
|
"\n"
|
|
"calculate trustwords for two Identities");
|
|
|
|
// Sync API
|
|
|
|
enum_<sync_handshake_signal>("sync_handshake_signal")
|
|
.value("SYNC_NOTIFY_UNDEFINED", SYNC_NOTIFY_UNDEFINED)
|
|
.value("SYNC_NOTIFY_INIT_ADD_OUR_DEVICE", SYNC_NOTIFY_INIT_ADD_OUR_DEVICE)
|
|
.value("SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE", SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE)
|
|
.value("SYNC_NOTIFY_INIT_FORM_GROUP", SYNC_NOTIFY_INIT_FORM_GROUP)
|
|
.value("SYNC_NOTIFY_TIMEOUT", SYNC_NOTIFY_TIMEOUT)
|
|
.value("SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED", SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED)
|
|
.value("SYNC_NOTIFY_ACCEPTED_GROUP_CREATED", SYNC_NOTIFY_ACCEPTED_GROUP_CREATED)
|
|
.value("SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED", SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED)
|
|
.value("SYNC_NOTIFY_SOLE", SYNC_NOTIFY_SOLE)
|
|
.value("SYNC_NOTIFY_IN_GROUP", SYNC_NOTIFY_IN_GROUP);
|
|
|
|
def("deliver_handshake_result",
|
|
&deliverHandshakeResult,
|
|
boost::python::arg("identities") = object(),
|
|
"deliverHandshakeResult(self, result, identities=None)\n"
|
|
"\n"
|
|
" result -1: cancel, 0: accepted, 1: rejected\n"
|
|
" identities list of identities to share or None for all\n"
|
|
"\n"
|
|
"call to deliver the handshake result of the handshake dialog");
|
|
|
|
def("debug_color", &debug_color, "for debug builds set ANSI color value");
|
|
|
|
def("leave_device_group",
|
|
&leave_device_group,
|
|
"leave_device_group()\n"
|
|
"\n"
|
|
"call this for a grouped device, which should leave\n");
|
|
|
|
def("disable_all_sync_channels",
|
|
&disable_all_sync_channels,
|
|
"disable_all_sync_channels()\n"
|
|
"\n"
|
|
"Disable sync for all identities\n");
|
|
|
|
// codecs
|
|
call<object>(
|
|
((object)(import("codecs").attr("register"))).ptr(),
|
|
make_function(sync_search));
|
|
call<object>(
|
|
((object)(import("codecs").attr("register"))).ptr(),
|
|
make_function(distribution_search));
|
|
}
|
|
|
|
} // namespace PythonAdapter
|
|
} // namespace pEp
|
|
|