pEpPythonAdapter/src/pEp/_pEp/pEpmodule.cc

// 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 std;
        using namespace boost::python;

        static const char *version_string = "p≡p Python adapter version 0.3";

        void init_before_main_module() {
            pEpLog("called");
        }

        // hidden init function, wrapped by _pEp.init()
        void _init_after_main_module() {
            pEpLog("called");
            callback_dispatcher.add(_messageToSend, _notifyHandshake, nullptr, nullptr);
//            Adapter::sync_initialize(
//                    Adapter::SyncModes::Off,
//                    CallbackDispatcher::messageToSend,
//                    CallbackDispatcher::notifyHandshake,
//                    true);
            Adapter::sync_initialize(
                    Adapter::SyncModes::Off,
                    _messageToSend,
                    _notifyHandshake,
                    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_user2(string user_id) {
            key_reset_user(user_id, "");
        }

        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 bad_alloc();
            if (status == PEP_ILLEGAL_VALUE)
                throw invalid_argument("illegal value");

            if (string(pEp_status_to_string(status)) == "unknown status code") {
                stringstream build;
                build << setfill('0') << "p≡p 0x" << setw(4) << hex << status;
                throw runtime_error(build.str());
            } else {
                throw runtime_error(pEp_status_to_string(status));
            }
        }

        // TODO: GIL handling isnt really required here, i think
        PEP_STATUS _messageToSend(::message *msg) {
            pEpLog("called");
            try {
                PyGILState_STATE gil = PyGILState_Ensure();
                pEpLog("GIL Aquired");
                object modref = import("pEp");
                object funcref = modref.attr("message_to_send");
                call<void>(funcref.ptr(), Message(msg));
                PyGILState_Release(gil);
                pEpLog("GIL released");
            } catch (exception &e) {}

            return PEP_STATUS_OK;
        }

        // TODO: GIL handling isnt really required here, i think
        PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) {
            pEpLog("called");
            try {
                PyGILState_STATE gil = PyGILState_Ensure();
                pEpLog("GIL Aquired");
                object modref = import("pEp");
                object funcref = modref.attr("notify_handshake");
                call<void>(funcref.ptr(), Identity(me), Identity(partner), signal);
                PyGILState_Release(gil);
                pEpLog("GIL released");
            } catch (exception &e) {}

            return PEP_STATUS_OK;
        }

        bool _do_protocol_step() {
            pEpLog("called");
            SYNC_EVENT event = Adapter::_retrieve_next_sync_event(nullptr, 0);
            if (event != NULL) {
                ::do_sync_protocol_step(Adapter::session(), (void *)&callback_dispatcher, event);
                return true;
            } else {
                pEpLog("null event, signaling sync shutdown");
                return false;
            }
        }

        void _register_sync_callbacks() {
            pEpLog("called");
            Adapter::session();
            PEP_STATUS status = ::register_sync_callbacks(Adapter::session(), nullptr, Adapter::_notifyHandshake, Adapter::_retrieve_next_sync_event);
            _throw_status(status);
        }

        void _unregister_sync_callbacks() {
            ::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 testfunc() {
            _messageToSend(NULL);
        }

        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 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);
        }

        BOOST_PYTHON_MODULE(_pEp) {
                init_before_main_module();

                // Module init function called by pEp.init()
                def("_init_after_main_module", _init_after_main_module);
                def("testfunc", &testfunc);

                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("_register_sync_callbacks", _register_sync_callbacks,
                "");

                def("_unregister_sync_callbacks", _unregister_sync_callbacks,
                "");

                def("_do_protocol_step", _do_protocol_step,
                "");

                def("_inject_sync_shutdown", Adapter::inject_sync_shutdown,
                "");

                def("_notifyHandshake_sync_start", _notifyHandshake_sync_start,
                "");

                def("_notifyHandshake_sync_stop", _notifyHandshake_sync_stop,
                "");

                def("_set_sync_mode", pEp::Adapter::set_sync_mode,
                "");

                enum_<pEp::Adapter::SyncModes>("SyncModes")
                .value("Off", pEp::Adapter::SyncModes::Off)
                .value("Async", pEp::Adapter::SyncModes::Async)
                .value("Sync", pEp::Adapter::SyncModes::Sync);

                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", key_reset_user2,
                "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,
                "private_key_list = 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"
                );

                // 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