pEp.foundation
/
pEpPythonAdapter
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

FROMATTING: reformat cxx codebase

pull/14/head
heck 4 years ago
parent
e4bfbf2c7d
commit
4f13825991
10 changed files with 1132 additions and 725 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 54
      src/pEp/_pEp/basic_api.cc
  2. 155
      src/pEp/_pEp/identity.cc
  3. 87
      src/pEp/_pEp/identity.hh
  4. 180
      src/pEp/_pEp/message.cc
  5. 301
      src/pEp/_pEp/message.hh
  6. 72
      src/pEp/_pEp/message_api.cc
  7. 3
      src/pEp/_pEp/message_api.hh
  8. 467
      src/pEp/_pEp/pEpmodule.cc
  9. 66
      src/pEp/_pEp/str_attr.cc
  10. 4
      src/pEp/_pEp/str_attr.hh

54
src/pEp/_pEp/basic_api.cc
View File

@ -16,19 +16,20 @@ namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
using namespace std; using namespace std;
void update_identity(Identity &ident) { void update_identity(Identity &ident)
{
if (ident.address() == "") if (ident.address() == "")
throw invalid_argument("address needed"); throw invalid_argument("address needed");
if (ident.user_id() == PEP_OWN_USERID) if (ident.user_id() == PEP_OWN_USERID)
throw runtime_error("update_identity: '" throw runtime_error("update_identity: '" PEP_OWN_USERID
PEP_OWN_USERID
"' may only be used for own identities"); "' may only be used for own identities");
PEP_STATUS status = update_identity(Adapter::session(), ident); PEP_STATUS status = update_identity(Adapter::session(), ident);
_throw_status(status); _throw_status(status);
} }
void myself(Identity &ident) { void myself(Identity &ident)
{
if (ident.address() == "") if (ident.address() == "")
throw invalid_argument("address needed"); throw invalid_argument("address needed");
if (ident.username() == "") if (ident.username() == "")
@ -41,7 +42,8 @@ namespace pEp {
_throw_status(status); _throw_status(status);
} }
string _trustwords(Identity me, Identity partner, string lang, bool full) { string _trustwords(Identity me, Identity partner, string lang, bool full)
{
if (me.fpr() == "" || partner.fpr() == "") if (me.fpr() == "" || partner.fpr() == "")
throw invalid_argument("fingerprint needed in Identities"); throw invalid_argument("fingerprint needed in Identities");
@ -50,13 +52,20 @@ namespace pEp {
char *words = NULL; char *words = NULL;
size_t size = 0; size_t size = 0;
PEP_STATUS status = get_trustwords(Adapter::session(), me, partner, PEP_STATUS status = get_trustwords(
lang.c_str(), &words, &size, full); Adapter::session(),
me,
partner,
lang.c_str(),
&words,
&size,
full);
_throw_status(status); _throw_status(status);
return words; return words;
} }
void trust_personal_key(Identity ident) { void trust_personal_key(Identity ident)
{
if (ident.fpr() == "") if (ident.fpr() == "")
throw invalid_argument("fingerprint needed in Identities"); throw invalid_argument("fingerprint needed in Identities");
if (ident.user_id() == "") if (ident.user_id() == "")
@ -66,7 +75,8 @@ namespace pEp {
_throw_status(status); _throw_status(status);
} }
void set_identity_flags(Identity ident, identity_flags_t flags) { void set_identity_flags(Identity ident, identity_flags_t flags)
{
if (ident.address() == "") if (ident.address() == "")
throw invalid_argument("address needed"); throw invalid_argument("address needed");
if (ident.user_id() == "") if (ident.user_id() == "")
@ -76,7 +86,8 @@ namespace pEp {
_throw_status(status); _throw_status(status);
} }
void unset_identity_flags(Identity ident, identity_flags_t flags) { void unset_identity_flags(Identity ident, identity_flags_t flags)
{
if (ident.address() == "") if (ident.address() == "")
throw invalid_argument("address needed"); throw invalid_argument("address needed");
if (ident.user_id() == "") if (ident.user_id() == "")
@ -86,7 +97,8 @@ namespace pEp {
_throw_status(status); _throw_status(status);
} }
void key_reset_trust(Identity ident) { void key_reset_trust(Identity ident)
{
if (ident.fpr() == "") if (ident.fpr() == "")
throw invalid_argument("fpr needed"); throw invalid_argument("fpr needed");
if (ident.address() == "") if (ident.address() == "")
@ -99,9 +111,14 @@ namespace pEp {
} }
boost::python::list import_key(string key_data) { boost::python::list import_key(string key_data)
{
::identity_list *private_keys = NULL; ::identity_list *private_keys = NULL;
PEP_STATUS status = ::import_key(Adapter::session(), key_data.c_str(), key_data.size(), &private_keys); PEP_STATUS status = ::import_key(
Adapter::session(),
key_data.c_str(),
key_data.size(),
&private_keys);
if (status && status != PEP_KEY_IMPORTED) if (status && status != PEP_KEY_IMPORTED)
_throw_status(status); _throw_status(status);
@ -119,7 +136,8 @@ namespace pEp {
return result; return result;
} }
string export_key(Identity ident) { string export_key(Identity ident)
{
PEP_STATUS status = PEP_STATUS_OK; PEP_STATUS status = PEP_STATUS_OK;
char *key_data = NULL; char *key_data = NULL;
size_t size; size_t size;
@ -129,7 +147,8 @@ namespace pEp {
return key_data; return key_data;
} }
string export_secret_key(Identity ident) { string export_secret_key(Identity ident)
{
PEP_STATUS status = PEP_STATUS_OK; PEP_STATUS status = PEP_STATUS_OK;
char *key_data = NULL; char *key_data = NULL;
size_t size; size_t size;
@ -139,7 +158,8 @@ namespace pEp {
return key_data; return key_data;
} }
void set_own_key(Identity &ident, string fpr) { void set_own_key(Identity &ident, string fpr)
{
if (ident.address() == "") if (ident.address() == "")
throw invalid_argument("address needed"); throw invalid_argument("address needed");
if (ident.username() == "") if (ident.username() == "")
@ -157,5 +177,3 @@ namespace pEp {
} // namespace PythonAdapter } // namespace PythonAdapter
} // namespace pEp } // namespace pEp

155
src/pEp/_pEp/identity.cc
View File

@ -21,40 +21,44 @@ namespace pEp {
using namespace std; using namespace std;
using namespace boost::python; using namespace boost::python;
Identity::Identity(string address, string username, string user_id, Identity::Identity(
string fpr, int comm_type, string lang, identity_flags_t flags) string address,
: _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), string username,
username.c_str()), &::free_identity) { string user_id,
if (!_ident) 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(); throw bad_alloc();
}
_ident->comm_type = (PEP_comm_type)comm_type; _ident->comm_type = (PEP_comm_type)comm_type;
_ident->flags = (identity_flags_t)flags; _ident->flags = (identity_flags_t)flags;
this->lang(lang); this->lang(lang);
} }
Identity::Identity(const Identity &second) Identity::Identity(const Identity &second) : _ident(second._ident) {}
: _ident(second._ident) {
}
Identity::Identity(pEp_identity *ident)
: _ident(ident, &::free_identity) {
} Identity::Identity(pEp_identity *ident) : _ident(ident, &::free_identity) {}
Identity::~Identity() { Identity::~Identity() {}
} Identity::operator pEp_identity *()
{
Identity::operator pEp_identity *() {
return _ident.get(); return _ident.get();
} }
Identity::operator const pEp_identity *() const { Identity::operator const pEp_identity *() const
{
return _ident.get(); return _ident.get();
} }
string Identity::_repr() { string Identity::_repr()
{
stringstream build; stringstream build;
build << "Identity("; build << "Identity(";
string address; string address;
@ -79,37 +83,47 @@ namespace pEp {
return build.str(); return build.str();
} }
string Identity::_str() { string Identity::_str()
if (!(_ident->address && _ident->address[0])) {
if (!(_ident->address && _ident->address[0])) {
return ""; return "";
if (!(_ident->username && _ident->username[0])) }
if (!(_ident->username && _ident->username[0])) {
return _ident->address; return _ident->address;
}
return string(_ident->username) + " <" + _ident->address + ">"; return string(_ident->username) + " <" + _ident->address + ">";
} }
void Identity::username(string value) { void Identity::username(string value)
if (value.length() && value.length() < 5) {
if (value.length() && value.length() < 5) {
throw length_error("username must be at least 5 characters"); throw length_error("username must be at least 5 characters");
}
str_attr(_ident->username, value); str_attr(_ident->username, value);
} }
void Identity::lang(string value) { void Identity::lang(string value)
if (value == "") {
if (value == "") {
memset(_ident->lang, 0, 3); memset(_ident->lang, 0, 3);
else if (value.length() != 2) } else if (value.length() != 2) {
throw length_error("length of lang must be 2"); throw length_error("length of lang must be 2");
else } else {
memcpy(_ident->lang, value.c_str(), 3); memcpy(_ident->lang, value.c_str(), 3);
} }
}
string Identity::lang() { string Identity::lang()
{
return _ident->lang; return _ident->lang;
} }
int Identity::rating() { int Identity::rating()
if (!(_ident->address)) {
if (!(_ident->address)) {
throw invalid_argument("address must be given"); throw invalid_argument("address must be given");
}
PEP_rating rating = PEP_rating_undefined; PEP_rating rating = PEP_rating_undefined;
PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating); PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating);
@ -118,111 +132,115 @@ namespace pEp {
return (int)rating; return (int)rating;
} }
PEP_color Identity::color() { PEP_color Identity::color()
{
return _color(rating()); return _color(rating());
} }
Identity Identity::copy() { Identity Identity::copy()
{
pEp_identity *dup = ::identity_dup(*this); pEp_identity *dup = ::identity_dup(*this);
if (!dup) if (!dup) {
throw bad_alloc(); throw bad_alloc();
}
return Identity(dup); return Identity(dup);
} }
Identity Identity::deepcopy(dict &) { Identity Identity::deepcopy(dict &)
{
return copy(); return copy();
} }
void Identity::update() { void Identity::update()
{
update_identity(*this); update_identity(*this);
} }
void Identity::key_reset(string fpr) { void Identity::key_reset(string fpr)
PEP_STATUS status = ::key_reset_identity(Adapter::session(), *this, {
PEP_STATUS status = ::key_reset_identity(
Adapter::session(),
*this,
fpr != "" ? fpr.c_str() : nullptr); fpr != "" ? fpr.c_str() : nullptr);
_throw_status(status); _throw_status(status);
} }
void Identity::key_mistrusted() { void Identity::key_mistrusted()
{
PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this); PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this);
_throw_status(status); _throw_status(status);
} }
bool Identity::is_pEp_user() { bool Identity::is_pEp_user()
{
bool result; bool result;
PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result); PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result);
_throw_status(status); _throw_status(status);
return result; return result;
} }
void Identity::enable_for_sync() { void Identity::enable_for_sync()
{
PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this); PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this);
_throw_status(status); _throw_status(status);
} }
void Identity::disable_for_sync() { void Identity::disable_for_sync()
{
PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this); PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this);
_throw_status(status); _throw_status(status);
} }
// Myself::Myself(string address, string username, string user_id, string lang) Identity identity_attr(pEp_identity *&ident)
// : Identity(address, username, user_id, "", 0, lang) { {
// if (!(address.length() && username.length())) if (!ident) {
// 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"); throw out_of_range("no identity assigned");
}
pEp_identity *_dup = ::identity_dup(ident); pEp_identity *_dup = ::identity_dup(ident);
if (!_dup) if (!_dup) {
throw bad_alloc(); throw bad_alloc();
}
Identity _ident(_dup); Identity _ident(_dup);
return _ident; return _ident;
} }
void identity_attr(pEp_identity *&ident, object value) { void identity_attr(pEp_identity *&ident, object value)
{
Identity &_ident = extract<Identity &>(value); Identity &_ident = extract<Identity &>(value);
pEp_identity *_dup = ::identity_dup(_ident); pEp_identity *_dup = ::identity_dup(_ident);
if (!_dup) if (!_dup) {
throw bad_alloc(); throw bad_alloc();
}
PEP_STATUS status = ::update_identity(Adapter::session(), _dup); PEP_STATUS status = ::update_identity(Adapter::session(), _dup);
_throw_status(status); _throw_status(status);
::free_identity(ident); ::free_identity(ident);
ident = _dup; ident = _dup;
} }
boost::python::list identitylist_attr(identity_list *&il) { boost::python::list identitylist_attr(identity_list *&il)
{
boost::python::list result; boost::python::list result;
for (identity_list *_il = il; _il && _il->ident; _il = _il->next) { for (identity_list *_il = il; _il && _il->ident; _il = _il->next) {
pEp_identity *ident = ::identity_dup(_il->ident); pEp_identity *ident = ::identity_dup(_il->ident);
if (!ident) if (!ident) {
throw bad_alloc(); throw bad_alloc();
}
result.append(object(Identity(ident))); result.append(object(Identity(ident)));
} }
return result; return result;
} }
void identitylist_attr(identity_list *&il, boost::python::list value) { void identitylist_attr(identity_list *&il, boost::python::list value)
{
identity_list *_il = ::new_identity_list(NULL); identity_list *_il = ::new_identity_list(NULL);
if (!_il) if (!_il) {
throw bad_alloc(); throw bad_alloc();
}
identity_list *_i = _il; identity_list *_i = _il;
for (int i = 0; i < len(value); i++) { for (int i = 0; i < len(value); i++) {
@ -254,4 +272,3 @@ namespace pEp {
} // namespace PythonAdapter } // namespace PythonAdapter
} // namespace pEp } // namespace pEp

87
src/pEp/_pEp/identity.hh
View File

@ -23,8 +23,8 @@
namespace pEp { namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
using std::string;
using std::shared_ptr; using std::shared_ptr;
using std::string;
// Identity is owning a pEp_identity // Identity is owning a pEp_identity
@ -33,9 +33,14 @@ namespace pEp {
shared_ptr<pEp_identity> _ident; shared_ptr<pEp_identity> _ident;
public: public:
Identity(string address = "", string username = "", Identity(
string user_id = "", string fpr = "", int comm_type = 0, string address = "",
string lang = "", identity_flags_t flags = 0); string username = "",
string user_id = "",
string fpr = "",
int comm_type = 0,
string lang = "",
identity_flags_t flags = 0);
Identity(const Identity &second); Identity(const Identity &second);
@ -51,33 +56,66 @@ namespace pEp {
string _str(); string _str();
string address() { return str_attr(_ident->address); } string address()
{
void address(string value) { str_attr(_ident->address, value); } return str_attr(_ident->address);
}
string fpr() { return str_attr(_ident->fpr); }
void address(string value)
void fpr(string value) { str_attr(_ident->fpr, value); } {
str_attr(_ident->address, value);
string user_id() { return str_attr(_ident->user_id); } }
void user_id(string value) { str_attr(_ident->user_id, value); } string fpr()
{
string username() { return str_attr(_ident->username); } 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); void username(string value);
PEP_comm_type comm_type() { return _ident->comm_type; } PEP_comm_type comm_type()
{
return _ident->comm_type;
}
void comm_type(PEP_comm_type value) { _ident->comm_type = value; }; void comm_type(PEP_comm_type value)
{
_ident->comm_type = value;
};
std::string lang(); std::string lang();
void lang(std::string value); void lang(std::string value);
identity_flags_t flags() { return _ident->flags; } identity_flags_t flags()
{
return _ident->flags;
}
void flags(identity_flags_t flags) { _ident->flags = flags; } void flags(identity_flags_t flags)
{
_ident->flags = flags;
}
int rating(); int rating();
@ -100,13 +138,6 @@ namespace pEp {
void disable_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); Identity identity_attr(pEp_identity *&ident);
void identity_attr(pEp_identity *&ident, object value); void identity_attr(pEp_identity *&ident, object value);

180
src/pEp/_pEp/message.cc
View File

@ -23,21 +23,26 @@ namespace pEp {
using namespace std; using namespace std;
using namespace boost::python; using namespace boost::python;
Message::Blob::Blob(bloblist_t *bl, bool chained) : Message::Blob::Blob(bloblist_t *bl, bool chained) : _bl(bl), part_of_chain(chained)
_bl(bl), part_of_chain(chained) { {
if (!_bl) if (!_bl) {
throw bad_alloc(); throw bad_alloc();
} }
}
Message::Blob::Blob(object data, string mime_type, string filename) : Message::Blob::Blob(object data, string mime_type, string filename) :
_bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) { _bl(new_bloblist(NULL, 0, NULL, NULL)),
if (!_bl) part_of_chain(false)
{
if (!_bl) {
throw bad_alloc(); throw bad_alloc();
}
Py_buffer src; Py_buffer src;
int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO); int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO);
if (result) if (result) {
throw invalid_argument("need a contiguous buffer to read"); throw invalid_argument("need a contiguous buffer to read");
}
char *mem = (char *)malloc(src.len); char *mem = (char *)malloc(src.len);
if (!mem) { if (!mem) {
@ -56,19 +61,18 @@ namespace pEp {
this->filename(filename); this->filename(filename);
} }
Message::Blob::Blob(const Message::Blob &second) : Message::Blob::Blob(const Message::Blob &second) : _bl(second._bl), part_of_chain(true) {}
_bl(second._bl), part_of_chain(true) {
}
Message::Blob::~Blob() { Message::Blob::~Blob()
{
if (!part_of_chain) { if (!part_of_chain) {
free(_bl->value); free(_bl->value);
free(_bl); free(_bl);
} }
} }
string Message::Blob::_repr() { string Message::Blob::_repr()
{
stringstream build; stringstream build;
build << "Blob("; build << "Blob(";
if (!_bl) { if (!_bl) {
@ -88,14 +92,14 @@ namespace pEp {
return build.str(); return build.str();
} }
int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) { int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags)
{
bloblist_t *bl = NULL; bloblist_t *bl = NULL;
try { try {
Message::Blob &blob = extract<Message::Blob &>(self); Message::Blob &blob = extract<Message::Blob &>(self);
bl = blob._bl; bl = blob._bl;
} } catch (exception &e) {
catch (exception &e) {
PyErr_SetString(PyExc_RuntimeError, "extract not possible"); PyErr_SetString(PyExc_RuntimeError, "extract not possible");
view->obj = NULL; view->obj = NULL;
return -1; return -1;
@ -110,17 +114,19 @@ namespace pEp {
return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags); return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags);
} }
string Message::Blob::decode(string encoding) { string Message::Blob::decode(string encoding)
{
if (encoding == "") { if (encoding == "") {
string _mime_type = _bl->mime_type ? _bl->mime_type : ""; string _mime_type = _bl->mime_type ? _bl->mime_type : "";
encoding = "ascii"; encoding = "ascii";
if (_mime_type == "application/pEp.sync") if (_mime_type == "application/pEp.sync") {
encoding = "pep.sync"; encoding = "pep.sync";
}
if (_mime_type == "application/pEp.keyreset") if (_mime_type == "application/pEp.keyreset") {
encoding = "pep.distribution"; encoding = "pep.distribution";
}
} }
object codecs = import("codecs"); object codecs = import("codecs");
object _decode = codecs.attr("decode"); object _decode = codecs.attr("decode");
@ -129,33 +135,37 @@ namespace pEp {
PyBufferProcs Message::Blob::bp = { getbuffer, NULL }; PyBufferProcs Message::Blob::bp = { getbuffer, NULL };
Message::Message(int dir, Identity *from) Message::Message(int dir, Identity *from) :
: _msg(new_message((PEP_msg_direction) dir), &free_message) { _msg(new_message((PEP_msg_direction)dir), &free_message)
if (!_msg) {
if (!_msg) {
throw bad_alloc(); throw bad_alloc();
}
if (from) { if (from) {
_msg->from = ::identity_dup(*from); _msg->from = ::identity_dup(*from);
if (!_msg->from) if (!_msg->from) {
throw bad_alloc(); throw bad_alloc();
}
_msg->dir = (PEP_msg_direction)dir; _msg->dir = (PEP_msg_direction)dir;
} }
} }
Message::Message(string mimetext) Message::Message(string mimetext) : _msg(NULL, &free_message)
: _msg(NULL, &free_message) { {
message *_cpy; message *_cpy;
PEP_STATUS status = mime_decode_message(mimetext.c_str(), PEP_STATUS status = mime_decode_message(mimetext.c_str(), mimetext.size(), &_cpy, NULL);
mimetext.size(), &_cpy, NULL);
switch (status) { switch (status) {
case PEP_STATUS_OK: case PEP_STATUS_OK:
if (_cpy) if (_cpy) {
_cpy->dir = PEP_dir_outgoing; _cpy->dir = PEP_dir_outgoing;
else } else {
_cpy = new_message(PEP_dir_outgoing); _cpy = new_message(PEP_dir_outgoing);
}
if (!_cpy) if (!_cpy) {
throw bad_alloc(); throw bad_alloc();
}
_msg = shared_ptr<message>(_cpy); _msg = shared_ptr<message>(_cpy);
break; break;
@ -176,32 +186,32 @@ namespace pEp {
} }
} }
Message::Message(const Message &second) Message::Message(const Message &second) : _msg(second._msg)
: _msg(second._msg) { {
if (!_msg.get()) if (!_msg.get()) {
throw bad_alloc(); throw bad_alloc();
} }
Message::Message(message *msg)
: _msg(::message_dup(msg), &free_message) {
} }
Message::~Message() { Message::Message(message *msg) : _msg(::message_dup(msg), &free_message) {}
} Message::~Message() {}
Message::operator message *() { Message::operator message *()
{
return _msg.get(); return _msg.get();
} }
Message::operator const message *() const { Message::operator const message *() const
{
return _msg.get(); return _msg.get();
} }
string Message::_str() { string Message::_str()
if (!(_msg->from && _msg->from->address && _msg->from->address[0])) {
if (!(_msg->from && _msg->from->address && _msg->from->address[0])) {
throw out_of_range(".from_.address missing"); throw out_of_range(".from_.address missing");
}
char *mimetext; char *mimetext;
string result; string result;
@ -231,33 +241,40 @@ namespace pEp {
return result; return result;
} }
string Message::_repr() { string Message::_repr()
{
stringstream build; stringstream build;
build << "Message(" << repr(_str()) << ")"; build << "Message(" << repr(_str()) << ")";
return build.str(); return build.str();
} }
boost::python::tuple Message::attachments() { boost::python::tuple Message::attachments()
{
boost::python::list l; boost::python::list l;
for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = bl->next) {
bl->next) {
l.append(Blob(bl, true)); l.append(Blob(bl, true));
} }
return boost::python::tuple(l); return boost::python::tuple(l);
} }
void Message::attachments(boost::python::list value) { void Message::attachments(boost::python::list value)
{
bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL);
if (!bl) if (!bl) {
throw bad_alloc(); throw bad_alloc();
}
bloblist_t *_l = bl; bloblist_t *_l = bl;
for (int i = 0; i < len(value); i++) { for (int i = 0; i < len(value); i++) {
Message::Blob &blob = extract<Message::Blob &>(value[i]); Message::Blob &blob = extract<Message::Blob &>(value[i]);
_l = bloblist_add(_l, blob._bl->value, blob._bl->size, _l = bloblist_add(
blob._bl->mime_type, blob._bl->filename); _l,
blob._bl->value,
blob._bl->size,
blob._bl->mime_type,
blob._bl->filename);
if (!_l) { if (!_l) {
for (_l = bl; _l && _l->value;) { for (_l = bl; _l && _l->value;) {
free(_l->mime_type); free(_l->mime_type);
@ -284,32 +301,41 @@ namespace pEp {
_msg->attachments = bl; _msg->attachments = bl;
} }
Message Message::encrypt() { Message Message::encrypt()
{
boost::python::list extra; boost::python::list extra;
return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0); return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0);
} }
Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) { Message Message::_encrypt(boost::python::list extra, int enc_format, int flags)
if (!enc_format) {
if (!enc_format) {
enc_format = PEP_enc_PGP_MIME; enc_format = PEP_enc_PGP_MIME;
}
return encrypt_message(*this, extra, enc_format, flags); return encrypt_message(*this, extra, enc_format, flags);
} }
boost::python::tuple Message::decrypt(int flags) { boost::python::tuple Message::decrypt(int flags)
{
return pEp::PythonAdapter::decrypt_message(*this, flags); return pEp::PythonAdapter::decrypt_message(*this, flags);
} }
PEP_rating Message::outgoing_rating() { PEP_rating Message::outgoing_rating()
if (_msg->dir != PEP_dir_outgoing) {
if (_msg->dir != PEP_dir_outgoing) {
throw invalid_argument("Message.dir must be outgoing"); throw invalid_argument("Message.dir must be outgoing");
}
if (from().address() == "") if (from().address() == "") {
throw invalid_argument("from.address needed"); throw invalid_argument("from.address needed");
if (from().username() == "") }
if (from().username() == "") {
throw invalid_argument("from.username needed"); throw invalid_argument("from.username needed");
}
if (len(to()) + len(cc()) == 0) if (len(to()) + len(cc()) == 0) {
throw invalid_argument("either to or cc needed"); throw invalid_argument("either to or cc needed");
}
PEP_STATUS status = myself(Adapter::session(), _msg->from); PEP_STATUS status = myself(Adapter::session(), _msg->from);
_throw_status(status); _throw_status(status);
@ -321,38 +347,47 @@ namespace pEp {
return rating; return rating;
} }
PEP_color Message::outgoing_color() { PEP_color Message::outgoing_color()
{
return _color(outgoing_rating()); return _color(outgoing_rating());
} }
Message Message::copy() { Message Message::copy()
{
message *dup = message_dup(*this); message *dup = message_dup(*this);
if (!dup) if (!dup) {
throw bad_alloc(); throw bad_alloc();
}
return Message(dup); return Message(dup);
} }
Message Message::deepcopy(dict &) { Message Message::deepcopy(dict &)
{
return copy(); return copy();
} }
Message outgoing_message(Identity me) { Message outgoing_message(Identity me)
if (me.address().empty() || me.user_id().empty()) {
if (me.address().empty() || me.user_id().empty()) {
throw runtime_error("at least address and user_id of own user needed"); throw runtime_error("at least address and user_id of own user needed");
}
::myself(Adapter::session(), me); ::myself(Adapter::session(), me);
auto m = Message(PEP_dir_outgoing, &me); auto m = Message(PEP_dir_outgoing, &me);
return m; return m;
} }
static object update(Identity ident) { static object update(Identity ident)
if (ident.address().empty()) {
if (ident.address().empty()) {
throw runtime_error("at least address needed"); throw runtime_error("at least address needed");
}
update_identity(Adapter::session(), ident); update_identity(Adapter::session(), ident);
return object(ident); return object(ident);
} }
static boost::python::list update(boost::python::list il) { static boost::python::list update(boost::python::list il)
{
for (int i = 0; i < len(il); i++) { for (int i = 0; i < len(il); i++) {
update(extract<Identity>(il[i])); update(extract<Identity>(il[i]));
} }
@ -360,19 +395,20 @@ namespace pEp {
return il; return il;
} }
Message incoming_message(string mime_text) { Message incoming_message(string mime_text)
{
auto m = Message(mime_text); auto m = Message(mime_text);
m.dir(PEP_dir_incoming); m.dir(PEP_dir_incoming);
try { try {
m.from(update(m.from())); m.from(update(m.from()));
} catch (out_of_range &) {
} }
catch (out_of_range &) {}
try { try {
m.recv_by(update(m.recv_by())); m.recv_by(update(m.recv_by()));
} catch (out_of_range &) {
} }
catch (out_of_range &) {}
m.to(update(m.to())); m.to(update(m.to()));
m.cc(update(m.cc())); m.cc(update(m.cc()));

301
src/pEp/_pEp/message.hh
View File

@ -19,10 +19,10 @@
namespace pEp { namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
using std::string;
using std::runtime_error;
using std::invalid_argument;
using boost::lexical_cast; using boost::lexical_cast;
using std::invalid_argument;
using std::runtime_error;
using std::string;
// Message is owning a message struct // Message is owning a message struct
@ -38,8 +38,7 @@ namespace pEp {
bool part_of_chain; bool part_of_chain;
public: public:
Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), bool chained = false);
bool chained = false);
Blob(object data, string mime_type = "", string filename = ""); Blob(object data, string mime_type = "", string filename = "");
@ -49,19 +48,37 @@ namespace pEp {
string _repr(); string _repr();
string mime_type() { return _bl ? str_attr(_bl->mime_type) : ""; } string mime_type()
{
return _bl ? str_attr(_bl->mime_type) : "";
}
void mime_type(string value) { str_attr(_bl->mime_type, value); } void mime_type(string value)
{
str_attr(_bl->mime_type, value);
}
string filename() { return str_attr(_bl->filename); } string filename()
{
return str_attr(_bl->filename);
}
void filename(string value) { str_attr(_bl->filename, value); } void filename(string value)
{
str_attr(_bl->filename, value);
}
size_t size() { return _bl->size; } size_t size()
{
return _bl->size;
}
string decode(string encoding); string decode(string encoding);
string decode() { return decode(""); } string decode()
{
return decode("");
}
static PyBufferProcs bp; static PyBufferProcs bp;
@ -89,85 +106,199 @@ namespace pEp {
string _repr(); string _repr();
PEP_msg_direction dir() { return _msg->dir; } PEP_msg_direction dir()
{
void dir(PEP_msg_direction value) { _msg->dir = value; } return _msg->dir;
}
string id() { return str_attr(_msg->id); }
void dir(PEP_msg_direction value)
void id(string value) { str_attr(_msg->id, value); } {
_msg->dir = value;
string shortmsg() { return str_attr(_msg->shortmsg); } }
void shortmsg(string value) { str_attr(_msg->shortmsg, value); } string id()
{
string longmsg() { return str_attr(_msg->longmsg); } return str_attr(_msg->id);
}
void longmsg(string value) { str_attr(_msg->longmsg, value); }
void id(string value)
string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); } {
str_attr(_msg->id, value);
void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, 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(); boost::python::tuple attachments();
void attachments(boost::python::list value); void attachments(boost::python::list value);
time_t sent() { return timestamp_attr(_msg->sent); } time_t sent()
{
void sent(time_t value) { timestamp_attr(_msg->sent, value); } return timestamp_attr(_msg->sent);
}
time_t recv() { return timestamp_attr(_msg->recv); }
void sent(time_t value)
void recv(time_t value) { timestamp_attr(_msg->recv, value); } {
timestamp_attr(_msg->sent, value);
Identity from() { return identity_attr(_msg->from); } }
void from(object value) { identity_attr(_msg->from, value); } time_t recv()
{
boost::python::list to() { return identitylist_attr(_msg->to); } return timestamp_attr(_msg->recv);
}
void to(boost::python::list value) { identitylist_attr(_msg->to, value); }
void recv(time_t value)
Identity recv_by() { return identity_attr(_msg->recv_by); } {
timestamp_attr(_msg->recv, value);
void recv_by(object value) { identity_attr(_msg->recv_by, value); } }
boost::python::list cc() { return identitylist_attr(_msg->cc); } Identity from()
{
void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); } return identity_attr(_msg->from);
}
boost::python::list bcc() { return identitylist_attr(_msg->bcc); }
void from(object value)
void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); } {
identity_attr(_msg->from, 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 to()
{
boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); } return identitylist_attr(_msg->to);
}
void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); }
void to(boost::python::list value)
boost::python::list references() { return strlist_attr(_msg->references); } {
identitylist_attr(_msg->to, value);
void references(boost::python::list value) { strlist_attr(_msg->references, value); } }
boost::python::list keywords() { return strlist_attr(_msg->keywords); } Identity recv_by()
{
void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); } return identity_attr(_msg->recv_by);
}
string comments() { return str_attr(_msg->comments); }
void recv_by(object value)
void comments(string value) { str_attr(_msg->comments, value); } {
identity_attr(_msg->recv_by, value);
dict opt_fields() { return strdict_attr(_msg->opt_fields); } }
void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); } boost::python::list cc()
{
PEP_enc_format enc_format() { return _msg->enc_format; } return identitylist_attr(_msg->cc);
}
void enc_format(PEP_enc_format value) { _msg->enc_format = value; }
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();

72
src/pEp/_pEp/message_api.cc
View File

@ -17,15 +17,19 @@ namespace pEp {
using namespace std; using namespace std;
using namespace boost::python; using namespace boost::python;
Message encrypt_message(Message src, boost::python::list extra, int enc_format, int flags) { Message encrypt_message(Message src, boost::python::list extra, int enc_format, int flags)
{
Identity _from = src.from(); Identity _from = src.from();
if (_from.address() == "") if (_from.address() == "") {
throw invalid_argument("encrypt_message: src.from_.address empty"); throw invalid_argument("encrypt_message: src.from_.address empty");
if (_from.username() == "") }
if (_from.username() == "") {
throw invalid_argument("encrypt_message: src.from_.username empty"); throw invalid_argument("encrypt_message: src.from_.username empty");
}
if (_from.user_id() == "") if (_from.user_id() == "") {
src.from().user_id(_from.address()); src.from().user_id(_from.address());
}
stringlist_t *_extra = to_stringlist(extra); stringlist_t *_extra = to_stringlist(extra);
PEP_enc_format _enc_format = (PEP_enc_format)enc_format; PEP_enc_format _enc_format = (PEP_enc_format)enc_format;
@ -33,26 +37,38 @@ namespace pEp {
message *_dst = NULL; message *_dst = NULL;
message *_src = src; message *_src = src;
PEP_STATUS status = encrypt_message(Adapter::session(), _src, _extra, &_dst, PEP_STATUS status = encrypt_message(
_enc_format, _flags); Adapter::session(),
_src,
_extra,
&_dst,
_enc_format,
_flags);
free_stringlist(_extra); free_stringlist(_extra);
_throw_status(status); _throw_status(status);
if (!_dst || _dst == _src) if (!_dst || _dst == _src) {
return Message(_src); return Message(_src);
}
return Message(_dst); return Message(_dst);
} }
boost::python::tuple decrypt_message(Message src, int flags) { boost::python::tuple decrypt_message(Message src, int flags)
{
message *_dst = NULL; message *_dst = NULL;
stringlist_t *_keylist = NULL; stringlist_t *_keylist = NULL;
PEP_rating _rating = PEP_rating_undefined; PEP_rating _rating = PEP_rating_undefined;
PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t)flags; PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t)flags;
message *_src = src; message *_src = src;
PEP_STATUS status = ::decrypt_message(Adapter::session(), _src, &_dst, &_keylist, PEP_STATUS status = ::decrypt_message(
&_rating, &_flags); Adapter::session(),
_src,
&_dst,
&_keylist,
&_rating,
&_flags);
_throw_status(status); _throw_status(status);
boost::python::list keylist; boost::python::list keylist;
@ -65,15 +81,18 @@ namespace pEp {
return boost::python::make_tuple(dst, keylist, _rating, _flags); return boost::python::make_tuple(dst, keylist, _rating, _flags);
} }
PEP_color _color(int rating) { PEP_color _color(int rating)
{
return ::color_from_rating((PEP_rating)rating); return ::color_from_rating((PEP_rating)rating);
} }
boost::python::tuple sync_decode(object buffer) { boost::python::tuple sync_decode(object buffer)
{
Py_buffer src; Py_buffer src;
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
if (result) if (result) {
throw invalid_argument("need a contiguous buffer to read"); throw invalid_argument("need a contiguous buffer to read");
}
char *dst = NULL; char *dst = NULL;
PEP_STATUS status = PER_to_XER_Sync_msg((char *)src.buf, src.len, &dst); PEP_STATUS status = PER_to_XER_Sync_msg((char *)src.buf, src.len, &dst);
@ -85,7 +104,8 @@ namespace pEp {
return boost::python::make_tuple(_dst, 0); return boost::python::make_tuple(_dst, 0);
} }
static boost::python::tuple sync_encode(string text) { static boost::python::tuple sync_encode(string text)
{
char *data = NULL; char *data = NULL;
size_t size = 0; size_t size = 0;
PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size); PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size);
@ -93,17 +113,20 @@ namespace pEp {
PyObject *ba = PyBytes_FromStringAndSize(data, size); PyObject *ba = PyBytes_FromStringAndSize(data, size);
free(data); free(data);
if (!ba) if (!ba) {
throw bad_alloc(); throw bad_alloc();
}
return boost::python::make_tuple(object(handle<>(ba)), 0); return boost::python::make_tuple(object(handle<>(ba)), 0);
} }
boost::python::tuple Distribution_decode(object buffer) { boost::python::tuple Distribution_decode(object buffer)
{
Py_buffer src; Py_buffer src;
int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO);
if (result) if (result) {
throw invalid_argument("need a contiguous buffer to read"); throw invalid_argument("need a contiguous buffer to read");
}
char *dst = NULL; char *dst = NULL;
PEP_STATUS status = PER_to_XER_Distribution_msg((char *)src.buf, src.len, &dst); PEP_STATUS status = PER_to_XER_Distribution_msg((char *)src.buf, src.len, &dst);
@ -115,7 +138,8 @@ namespace pEp {
return boost::python::make_tuple(_dst, 0); return boost::python::make_tuple(_dst, 0);
} }
static boost::python::tuple Distribution_encode(string text) { static boost::python::tuple Distribution_encode(string text)
{
char *data = NULL; char *data = NULL;
size_t size = 0; size_t size = 0;
PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size); PEP_STATUS status = XER_to_PER_Distribution_msg(text.c_str(), &data, &size);
@ -123,13 +147,14 @@ namespace pEp {
PyObject *ba = PyBytes_FromStringAndSize(data, size); PyObject *ba = PyBytes_FromStringAndSize(data, size);
free(data); free(data);
if (!ba) if (!ba) {
throw bad_alloc(); throw bad_alloc();
}
return boost::python::make_tuple(object(handle<>(ba)), 0); return boost::python::make_tuple(object(handle<>(ba)), 0);
} }
object sync_search(string name) { object sync_search(string name)
{
if (name != "pep.sync") { if (name != "pep.sync") {
return object(); return object();
} else { } else {
@ -143,7 +168,8 @@ namespace pEp {
} }
} }
object distribution_search(string name) { object distribution_search(string name)
{
if (name != "pep.distribution") { if (name != "pep.distribution") {
return object(); return object();
} else { } else {
@ -158,4 +184,4 @@ namespace pEp {
} }
} // namespace PythonAdapter } // namespace PythonAdapter
} // namespace pEp { } // namespace pEp

3
src/pEp/_pEp/message_api.hh
View File

@ -13,8 +13,7 @@ namespace pEp {
Message src, Message src,
boost::python::list extra = boost::python::list(), boost::python::list extra = boost::python::list(),
int enc_format = 4, int enc_format = 4,
int flags = 0 int flags = 0);
);
boost::python::tuple decrypt_message(Message src, int flags = 0); boost::python::tuple decrypt_message(Message src, int flags = 0);

467
src/pEp/_pEp/pEpmodule.cc
View File

@ -33,12 +33,14 @@ namespace pEp {
static const char *version_string = "p≡p Python adapter version 0.3"; static const char *version_string = "p≡p Python adapter version 0.3";
void _init_callbackdispatcher() { void _init_callbackdispatcher()
{
pEpLog("called"); pEpLog("called");
callback_dispatcher.add(_messageToSend, _notifyHandshake, nullptr, nullptr); callback_dispatcher.add(_messageToSend, _notifyHandshake, nullptr, nullptr);
} }
void _init_session(bool mode_async) { void _init_session(bool mode_async)
{
pEpLog("called"); pEpLog("called");
if (mode_async) { if (mode_async) {
Adapter::session.initialize(pEp::Adapter::SyncModes::Async, true); Adapter::session.initialize(pEp::Adapter::SyncModes::Async, true);
@ -47,44 +49,55 @@ namespace pEp {
} }
} }
void config_passive_mode(bool enable) { void config_passive_mode(bool enable)
{
::config_passive_mode(Adapter::session(), enable); ::config_passive_mode(Adapter::session(), enable);
} }
void config_unencrypted_subject(bool enable) { void config_unencrypted_subject(bool enable)
{
::config_unencrypted_subject(Adapter::session(), enable); ::config_unencrypted_subject(Adapter::session(), enable);
} }
void key_reset_user(string user_id, string fpr) { void key_reset_user(string user_id, string fpr)
if (user_id == "") {
if (user_id == "") {
throw invalid_argument("user_id required"); throw invalid_argument("user_id required");
}
PEP_STATUS status = ::key_reset_user(Adapter::session(), PEP_STATUS status = ::key_reset_user(
user_id.c_str(), fpr != "" ? fpr.c_str() : nullptr); Adapter::session(),
user_id.c_str(),
fpr != "" ? fpr.c_str() : nullptr);
_throw_status(status); _throw_status(status);
} }
void key_reset_all_own_keys() { void key_reset_all_own_keys()
{
PEP_STATUS status = ::key_reset_all_own_keys(Adapter::session()); PEP_STATUS status = ::key_reset_all_own_keys(Adapter::session());
_throw_status(status); _throw_status(status);
} }
static string about() { static string about()
string version = string(version_string) + "\np≡p version " {
+ PEP_VERSION + "\n"; string version = string(version_string) + "\np≡p version " + PEP_VERSION + "\n";
return version; return version;
} }
void _throw_status(PEP_STATUS status) { void _throw_status(PEP_STATUS status)
if (status == PEP_STATUS_OK) {
if (status == PEP_STATUS_OK) {
return; return;
if (status >= 0x400 && status <= 0x4ff) }
if (status >= 0x400 && status <= 0x4ff) {
return; return;
if (status == PEP_OUT_OF_MEMORY) }
if (status == PEP_OUT_OF_MEMORY) {
throw bad_alloc(); throw bad_alloc();
if (status == PEP_ILLEGAL_VALUE) }
if (status == PEP_ILLEGAL_VALUE) {
throw invalid_argument("illegal value"); throw invalid_argument("illegal value");
}
if (string(pEp_status_to_string(status)) == "unknown status code") { if (string(pEp_status_to_string(status)) == "unknown status code") {
stringstream build; stringstream build;
build << setfill('0') << "p≡p 0x" << setw(4) << hex << status; build << setfill('0') << "p≡p 0x" << setw(4) << hex << status;
@ -95,7 +108,8 @@ namespace pEp {
} }
// TODO: GIL handling isnt really required here, i think // TODO: GIL handling isnt really required here, i think
PEP_STATUS _messageToSend(::message *msg) { PEP_STATUS _messageToSend(::message *msg)
{
pEpLog("called"); pEpLog("called");
try { try {
PyGILState_STATE gil = PyGILState_Ensure(); PyGILState_STATE gil = PyGILState_Ensure();
@ -105,13 +119,15 @@ namespace pEp {
call<void>(funcref.ptr(), Message(msg)); call<void>(funcref.ptr(), Message(msg));
PyGILState_Release(gil); PyGILState_Release(gil);
pEpLog("GIL released"); pEpLog("GIL released");
} catch (exception &e) {} } catch (exception &e) {
}
return PEP_STATUS_OK; return PEP_STATUS_OK;
} }
// TODO: GIL handling isnt really required here, i think // TODO: GIL handling isnt really required here, i think
PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) { PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
{
pEpLog("called"); pEpLog("called");
try { try {
PyGILState_STATE gil = PyGILState_Ensure(); PyGILState_STATE gil = PyGILState_Ensure();
@ -121,12 +137,14 @@ namespace pEp {
call<void>(funcref.ptr(), Identity(me), Identity(partner), signal); call<void>(funcref.ptr(), Identity(me), Identity(partner), signal);
PyGILState_Release(gil); PyGILState_Release(gil);
pEpLog("GIL released"); pEpLog("GIL released");
} catch (exception &e) {} } catch (exception &e) {
}
return PEP_STATUS_OK; return PEP_STATUS_OK;
} }
bool _do_protocol_step() { bool _do_protocol_step()
{
pEpLog("called"); pEpLog("called");
SYNC_EVENT event = Adapter::_retrieve_next_sync_event(nullptr, 0); SYNC_EVENT event = Adapter::_retrieve_next_sync_event(nullptr, 0);
if (event != NULL) { if (event != NULL) {
@ -138,41 +156,49 @@ namespace pEp {
} }
} }
void _free_session() { void _free_session()
{
::unregister_sync_callbacks(Adapter::session()); ::unregister_sync_callbacks(Adapter::session());
Adapter::session.release(); Adapter::session.release();
} }
// TODO: Integrate this (currently SEGFAULTING) // TODO: Integrate this (currently SEGFAULTING)
void _notifyHandshake_sync_start() { void _notifyHandshake_sync_start()
{
pEpLog("all targets signal: SYNC_NOTIFY_START"); pEpLog("all targets signal: SYNC_NOTIFY_START");
CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_START); CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_START);
} }
// TODO: Integrate this (currently SEGFAULTING) // TODO: Integrate this (currently SEGFAULTING)
void _notifyHandshake_sync_stop() { void _notifyHandshake_sync_stop()
{
pEpLog("all targets signal: SYNC_NOTIFY_STOP"); pEpLog("all targets signal: SYNC_NOTIFY_STOP");
CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_STOP); CallbackDispatcher::notifyHandshake(nullptr, nullptr, SYNC_NOTIFY_STOP);
} }
void debug_color(int ansi_color) { void debug_color(int ansi_color)
{
::set_debug_color(Adapter::session(), ansi_color); ::set_debug_color(Adapter::session(), ansi_color);
} }
void leave_device_group() { void leave_device_group()
{
::leave_device_group(Adapter::session()); ::leave_device_group(Adapter::session());
} }
void disable_all_sync_channels() { void disable_all_sync_channels()
{
::disable_all_sync_channels(Adapter::session()); ::disable_all_sync_channels(Adapter::session());
} }
void deliverHandshakeResult(int result, object identities) { void deliverHandshakeResult(int result, object identities)
{
identity_list *shared_identities = nullptr; identity_list *shared_identities = nullptr;
if (identities != boost::python::api::object() && boost::python::len(identities)) { if (identities != boost::python::api::object() && boost::python::len(identities)) {
shared_identities = new_identity_list(nullptr); shared_identities = new_identity_list(nullptr);
if (!shared_identities) if (!shared_identities) {
throw bad_alloc(); throw bad_alloc();
}
try { try {
identity_list *si = shared_identities; identity_list *si = shared_identities;
@ -182,19 +208,22 @@ namespace pEp {
if (!si) if (!si)
throw bad_alloc(); throw bad_alloc();
} }
} } catch (exception &ex) {
catch (exception &ex) {
free_identity_list(shared_identities); free_identity_list(shared_identities);
throw ex; throw ex;
} }
} }
PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), (sync_handshake_result) result, shared_identities); PEP_STATUS status = ::deliverHandshakeResult(
Adapter::session(),
(sync_handshake_result)result,
shared_identities);
free_identity_list(shared_identities); free_identity_list(shared_identities);
_throw_status(status); _throw_status(status);
} }
BOOST_PYTHON_MODULE(_pEp) { BOOST_PYTHON_MODULE(_pEp)
{
def("_init_callbackdispatcher", _init_callbackdispatcher); def("_init_callbackdispatcher", _init_callbackdispatcher);
docstring_options doc_options(true, false, false); docstring_options doc_options(true, false, false);
@ -207,8 +236,7 @@ namespace pEp {
scope().attr("engine_version") = get_engine_version(); scope().attr("engine_version") = get_engine_version();
scope().attr("protocol_version") = get_protocol_version(); scope().attr("protocol_version") = get_protocol_version();
def("set_debug_log_enabled", &Adapter::pEpLog::set_enabled, def("set_debug_log_enabled", &Adapter::pEpLog::set_enabled, "Switch debug logging on/off");
"Switch debug logging on/off");
def("_init_session", _init_session); def("_init_session", _init_session);
@ -218,24 +246,28 @@ namespace pEp {
def("_notifyHandshake_sync_start", _notifyHandshake_sync_start); def("_notifyHandshake_sync_start", _notifyHandshake_sync_start);
def("_notifyHandshake_sync_stop", _notifyHandshake_sync_stop); def("_notifyHandshake_sync_stop", _notifyHandshake_sync_stop);
def("passive_mode", config_passive_mode, def("passive_mode", config_passive_mode, "do not attach pub keys to all messages");
"do not attach pub keys to all messages");
def("unencrypted_subject", config_unencrypted_subject, def("unencrypted_subject",
config_unencrypted_subject,
"do not encrypt the subject of messages"); "do not encrypt the subject of messages");
def("key_reset", key_reset_user, def("key_reset",
key_reset_user,
"reset the default database status for the user / keypair provided\n" "reset the default database status for the user / keypair provided\n"
"This will effectively perform key_reset on each identity\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" "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."); "each key (and all of their identities) if an fpr is not.");
def("key_reset_all_own_keys", key_reset_all_own_keys, def("key_reset_all_own_keys",
key_reset_all_own_keys,
"revoke and mistrust all own keys, generate new keys for all\n" "revoke and mistrust all own keys, generate new keys for all\n"
"own identities, and opportunistically communicate key reset\n" "own identities, and opportunistically communicate key reset\n"
"information to people we have recently contacted."); "information to people we have recently contacted.");
auto identity_class = class_<Identity>("Identity", auto
identity_class = class_<Identity>(
"Identity",
"Identity(address, username, user_id='', fpr='', comm_type=0, lang='en')\n" "Identity(address, username, user_id='', fpr='', comm_type=0, lang='en')\n"
"\n" "\n"
"represents a p≡p identity\n" "represents a p≡p identity\n"
@ -250,8 +282,7 @@ namespace pEp {
" hex encoded\n" " hex encoded\n"
" comm_type first rating level of this communication channel\n" " comm_type first rating level of this communication channel\n"
" lang ISO 639-1 language code for language being preferred\n" " lang ISO 639-1 language code for language being preferred\n"
" on this communication channel\n" " on this communication channel\n")
)
.def(boost::python::init<string>()) .def(boost::python::init<string>())
.def(boost::python::init<string, string>()) .def(boost::python::init<string, string>())
.def(boost::python::init<string, string, string>()) .def(boost::python::init<string, string, string>())
@ -259,11 +290,14 @@ namespace pEp {
.def(boost::python::init<string, string, string, string, int>()) .def(boost::python::init<string, string, string, string, int>())
.def(boost::python::init<string, string, string, string, int, string>()) .def(boost::python::init<string, string, string, string, int, string>())
.def("__repr__", &Identity::_repr) .def("__repr__", &Identity::_repr)
.def("__str__", &Identity::_str, .def(
"__str__",
&Identity::_str,
"string representation of this identity\n" "string representation of this identity\n"
"following the pattern 'username < address >'\n" "following the pattern 'username < address >'\n")
) .def(
.def("key_reset", &Identity::key_reset, "key_reset",
&Identity::key_reset,
boost::python::arg("fpr") = object(""), boost::python::arg("fpr") = object(""),
"reset the default database status for the identity / keypair provided. If this\n" "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" "corresponds to the own user and a private key, also revoke the key, generate a\n"
@ -271,7 +305,9 @@ namespace pEp {
"identity. If it does not, remove the key from the keyring; the key's status is\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.") "completely fresh on next contact from the partner.")
.def("key_mistrusted", &Identity::key_mistrusted, .def(
"key_mistrusted",
&Identity::key_mistrusted,
boost::python::arg("fpr") = object(""), boost::python::arg("fpr") = object(""),
"If you want updated trust on the identity, you ll have" "If you want updated trust on the identity, you ll have"
"to call update_identity or myself respectively after this." "to call update_identity or myself respectively after this."
@ -281,46 +317,71 @@ namespace pEp {
"will only undo the current identity's / it's user's default, not any" "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)") "other identities which may be impacted (this will not affect most use cases)")
.def("enable_for_sync", &Identity::enable_for_sync, .def(
"enable_for_sync",
&Identity::enable_for_sync,
"Enable own identity for p≡p sync.\n\n" "Enable own identity for p≡p sync.\n\n"
"Only use this on own identities, which are used as accounts.\n") "Only use this on own identities, which are used as accounts.\n")
.def("disable_for_sync", &Identity::disable_for_sync, .def(
"disable_for_sync",
&Identity::disable_for_sync,
"Disable own identity for p≡p sync.\n\n" "Disable own identity for p≡p sync.\n\n"
"Only use this on own identities, which are used as accounts.\n") "Only use this on own identities, which are used as accounts.\n")
.add_property("address", (string(Identity::*)()) &Identity::address, .add_property(
"address",
(string(Identity::*)()) & Identity::address,
(void(Identity::*)(string)) & Identity::address, (void(Identity::*)(string)) & Identity::address,
"email address or URI") "email address or URI")
.add_property("fpr", (string(Identity::*)()) &Identity::fpr, .add_property(
"fpr",
(string(Identity::*)()) & Identity::fpr,
(void(Identity::*)(string)) & Identity::fpr, (void(Identity::*)(string)) & Identity::fpr,
"key ID (full fingerprint, hex encoded)") "key ID (full fingerprint, hex encoded)")
.add_property("user_id", (string(Identity::*)()) &Identity::user_id, .add_property(
"user_id",
(string(Identity::*)()) & Identity::user_id,
(void(Identity::*)(string)) & Identity::user_id, (void(Identity::*)(string)) & Identity::user_id,
"ID of person associated or 'pEp_own_userId' if own identity") "ID of person associated or 'pEp_own_userId' if own identity")
.add_property("username", (string(Identity::*)()) &Identity::username, .add_property(
"username",
(string(Identity::*)()) & Identity::username,
(void(Identity::*)(string)) & Identity::username, (void(Identity::*)(string)) & Identity::username,
"name in full of person associated") "name in full of person associated")
.add_property("comm_type", (int(Identity::*)()) .add_property(
(PEP_comm_type(Identity::*)()) &Identity::comm_type, "comm_type",
(void(Identity::*)(int)) (int(Identity::*)())(PEP_comm_type(Identity::*)()) &
(void(Identity::*)(PEP_comm_type)) &Identity::comm_type, Identity::comm_type,
(void(Identity::*)(int))(void(Identity::*)(PEP_comm_type)) &
Identity::comm_type,
"communication type, first rating level (p≡p internal)") "communication type, first rating level (p≡p internal)")
.add_property("lang", (string(Identity::*)()) &Identity::lang, .add_property(
"lang",
(string(Identity::*)()) & Identity::lang,
(void(Identity::*)(string)) & Identity::lang, (void(Identity::*)(string)) & Identity::lang,
"ISO 639-1 language code") "ISO 639-1 language code")
.add_property("flags", (identity_flags_t(Identity::*)()) &Identity::flags, .add_property(
"flags",
(identity_flags_t(Identity::*)()) & Identity::flags,
(void(Identity::*)(identity_flags_t)) & Identity::flags, (void(Identity::*)(identity_flags_t)) & Identity::flags,
"flags (p≡p internal)") "flags (p≡p internal)")
.add_property("rating", &Identity::rating, "rating of Identity") .add_property("rating", &Identity::rating, "rating of Identity")
.add_property("color", &Identity::color, "color of Identity as PEP_color") .add_property(
.add_property("is_pEp_user", &Identity::is_pEp_user, "True if this is an identity of a pEp user") "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("__deepcopy__", &Identity::deepcopy)
.def("update", &Identity::update, "update Identity") .def("update", &Identity::update, "update Identity")
.def("__copy__", &Identity::copy); .def("__copy__", &Identity::copy);
identity_class.attr("PEP_OWN_USERID") = "pEp_own_userId"; identity_class.attr("PEP_OWN_USERID") = "pEp_own_userId";
auto blob_class = class_<Message::Blob>("Blob", auto blob_class = class_<Message::Blob>(
"Blob",
"Blob(data, mime_type='', filename='')\n" "Blob(data, mime_type='', filename='')\n"
"\n" "\n"
"Binary large object\n" "Binary large object\n"
@ -328,31 +389,38 @@ namespace pEp {
" data bytes-like object\n" " data bytes-like object\n"
" mime_type MIME type for the data\n" " mime_type MIME type for the data\n"
" filename filename to store the data\n", " filename filename to store the data\n",
boost::python::init< object, char const*, char const* >(args("data", "mime_type", "filename"))) boost::python::init<object, char const *, char const *>(
args("data", "mime_type", "filename")))
.def(boost::python::init<object, string>()) .def(boost::python::init<object, string>())
.def(boost::python::init<object>()) .def(boost::python::init<object>())
.def("__repr__", &Message::Blob::_repr) .def("__repr__", &Message::Blob::_repr)
.def("__len__", &Message::Blob::size, "size of Blob data in bytes") .def("__len__", &Message::Blob::size, "size of Blob data in bytes")
.def("decode", (string(Message::Blob::*)()) & Message::Blob::decode) .def("decode", (string(Message::Blob::*)()) & Message::Blob::decode)
.def("decode", (string(Message::Blob::*)(string)) &Message::Blob::decode, .def(
"decode",
(string(Message::Blob::*)(string)) & Message::Blob::decode,
"text = blob.decode(encoding='')\n" "text = blob.decode(encoding='')\n"
"\n" "\n"
"decode Blob data into string depending on MIME type if encoding=''\n" "decode Blob data into string depending on MIME type if encoding=''\n"
"\n" "\n"
" mime_type='application/pEp.sync' decode as 'pEp.sync'\n" " mime_type='application/pEp.sync' decode as 'pEp.sync'\n"
" mime_type='application/pEp.keyreset' decode as 'pEp.keyreset'\n" " mime_type='application/pEp.keyreset' decode as 'pEp.keyreset'\n"
" other mime_type decode as 'ascii' by default\n" " other mime_type decode as 'ascii' by default\n")
) .add_property(
.add_property("mime_type", (string(Message::Blob::*)()) &Message::Blob::mime_type, "mime_type",
(string(Message::Blob::*)()) & Message::Blob::mime_type,
(void(Message::Blob::*)(string)) & Message::Blob::mime_type, (void(Message::Blob::*)(string)) & Message::Blob::mime_type,
"MIME type of object in Blob") "MIME type of object in Blob")
.add_property("filename", (string(Message::Blob::*)()) &Message::Blob::filename, .add_property(
"filename",
(string(Message::Blob::*)()) & Message::Blob::filename,
(void(Message::Blob::*)(string)) & Message::Blob::filename, (void(Message::Blob::*)(string)) & Message::Blob::filename,
"filename of object in Blob"); "filename of object in Blob");
((PyTypeObject *)(void *)blob_class.ptr())->tp_as_buffer = &Message::Blob::bp; ((PyTypeObject *)(void *)blob_class.ptr())->tp_as_buffer = &Message::Blob::bp;
auto message_class = class_<Message>("Message", auto message_class = class_<Message>(
"Message",
"Message(dir=1, from=None)\n" "Message(dir=1, from=None)\n"
"\n" "\n"
"new p≡p message\n" "new p≡p message\n"
@ -364,83 +432,134 @@ namespace pEp {
"\n" "\n"
"new incoming p≡p message\n" "new incoming p≡p message\n"
"\n" "\n"
" mime_text text in Multipurpose Internet Mail Extensions format\n" " mime_text text in Multipurpose Internet Mail Extensions format\n")
)
.def(boost::python::init<int>()) .def(boost::python::init<int>())
.def(boost::python::init<int, Identity *>()) .def(boost::python::init<int, Identity *>())
.def(boost::python::init<string>()) .def(boost::python::init<string>())
.def("__str__", &Message::_str, .def(
"the string representation of a Message is it's MIME text" "__str__",
) &Message::_str,
"the string representation of a Message is it's MIME text")
.def("__repr__", &Message::_repr) .def("__repr__", &Message::_repr)
.add_property("dir", (int(Message::*)()) .add_property(
(PEP_msg_direction(Message::*)()) &Message::dir, "dir",
(void(Message::*)(int)) (int(Message::*)())(PEP_msg_direction(Message::*)()) &
(void(Message::*)(PEP_msg_direction)) &Message::dir, Message::dir,
(void(Message::*)(int))(void(Message::*)(PEP_msg_direction)) &
Message::dir,
"0: incoming, 1: outgoing message") "0: incoming, 1: outgoing message")
.add_property("id", (string(Message::*)()) &Message::id, .add_property(
"id",
(string(Message::*)()) & Message::id,
(void(Message::*)(string)) & Message::id, (void(Message::*)(string)) & Message::id,
"message ID") "message ID")
.add_property("shortmsg", (string(Message::*)()) &Message::shortmsg, .add_property(
"shortmsg",
(string(Message::*)()) & Message::shortmsg,
(void(Message::*)(string)) & Message::shortmsg, (void(Message::*)(string)) & Message::shortmsg,
"subject or short message") "subject or short message")
.add_property("longmsg", (string(Message::*)()) &Message::longmsg, .add_property(
"longmsg",
(string(Message::*)()) & Message::longmsg,
(void(Message::*)(string)) & Message::longmsg, (void(Message::*)(string)) & Message::longmsg,
"body or long version of message") "body or long version of message")
.add_property("longmsg_formatted", (string(Message::*)()) &Message::longmsg_formatted, .add_property(
"longmsg_formatted",
(string(Message::*)()) & Message::longmsg_formatted,
(void(Message::*)(string)) & Message::longmsg_formatted, (void(Message::*)(string)) & Message::longmsg_formatted,
"HTML body or fromatted long version of message") "HTML body or fromatted long version of message")
.add_property("attachments", (boost::python::tuple(Message::*)()) &Message::attachments, .add_property(
(void(Message::*)(boost::python::list)) &Message::attachments, "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") "tuple of Blobs with attachments; setting moves Blobs to attachment tuple")
.add_property("sent", (time_t(Message::*)()) &Message::sent, .add_property(
"sent",
(time_t(Message::*)()) & Message::sent,
(void(Message::*)(time_t)) & Message::sent, (void(Message::*)(time_t)) & Message::sent,
"time when message was sent in UTC seconds since epoch") "time when message was sent in UTC seconds since epoch")
.add_property("recv", (time_t(Message::*)()) &Message::recv, .add_property(
"recv",
(time_t(Message::*)()) & Message::recv,
(void(Message::*)(time_t)) & Message::recv, (void(Message::*)(time_t)) & Message::recv,
"time when message was received in UTC seconds since epoch") "time when message was received in UTC seconds since epoch")
.add_property("from_", (Identity(Message::*)()) &Message::from, .add_property(
"from_",
(Identity(Message::*)()) & Message::from,
(void(Message::*)(object)) & Message::from, (void(Message::*)(object)) & Message::from,
"identity where message is from") "identity where message is from")
.add_property("to", (boost::python::list(Message::*)()) &Message::to, .add_property(
"to",
(boost::python::list(Message::*)()) & Message::to,
(void(Message::*)(boost::python::list)) & Message::to, (void(Message::*)(boost::python::list)) & Message::to,
"list of identities message is going to") "list of identities message is going to")
.add_property("recv_by", (Identity(Message::*)()) &Message::recv_by, .add_property(
"recv_by",
(Identity(Message::*)()) & Message::recv_by,
(void(Message::*)(object)) & Message::recv_by, (void(Message::*)(object)) & Message::recv_by,
"identity where message was received by") "identity where message was received by")
.add_property("cc", (boost::python::list(Message::*)()) &Message::cc, .add_property(
"cc",
(boost::python::list(Message::*)()) & Message::cc,
(void(Message::*)(boost::python::list)) & Message::cc, (void(Message::*)(boost::python::list)) & Message::cc,
"list of identities message is going cc") "list of identities message is going cc")
.add_property("bcc", (boost::python::list(Message::*)()) &Message::bcc, .add_property(
"bcc",
(boost::python::list(Message::*)()) & Message::bcc,
(void(Message::*)(boost::python::list)) & Message::bcc, (void(Message::*)(boost::python::list)) & Message::bcc,
"list of identities message is going bcc") "list of identities message is going bcc")
.add_property("reply_to", (boost::python::list(Message::*)()) &Message::reply_to, .add_property(
"reply_to",
(boost::python::list(Message::*)()) & Message::reply_to,
(void(Message::*)(boost::python::list)) & Message::reply_to, (void(Message::*)(boost::python::list)) & Message::reply_to,
"list of identities where message will be replied to") "list of identities where message will be replied to")
.add_property("in_reply_to", (boost::python::list(Message::*)()) &Message::in_reply_to, .add_property(
(void(Message::*)(boost::python::list)) &Message::in_reply_to, "in_reply_to",
(boost::python::list(Message::*)()) & Message::in_reply_to,
(void(Message::*)(boost::python::list)) &
Message::in_reply_to,
"in_reply_to list") "in_reply_to list")
.add_property("references", (boost::python::list(Message::*)()) &Message::references, .add_property(
"references",
(boost::python::list(Message::*)()) & Message::references,
(void(Message::*)(boost::python::list)) & Message::references, (void(Message::*)(boost::python::list)) & Message::references,
"message IDs of messages this one is referring to") "message IDs of messages this one is referring to")
.add_property("keywords", (boost::python::list(Message::*)()) &Message::keywords, .add_property(
"keywords",
(boost::python::list(Message::*)()) & Message::keywords,
(void(Message::*)(boost::python::list)) & Message::keywords, (void(Message::*)(boost::python::list)) & Message::keywords,
"keywords this message should be stored under") "keywords this message should be stored under")
.add_property("comments", (string(Message::*)()) &Message::comments, .add_property(
"comments",
(string(Message::*)()) & Message::comments,
(void(Message::*)(string)) & Message::comments, (void(Message::*)(string)) & Message::comments,
"comments added to message") "comments added to message")
.add_property("opt_fields", (dict(Message::*)()) &Message::opt_fields, .add_property(
"opt_fields",
(dict(Message::*)()) & Message::opt_fields,
(void(Message::*)(dict)) & Message::opt_fields, (void(Message::*)(dict)) & Message::opt_fields,
"opt_fields of message") "opt_fields of message")
.add_property("enc_format", (int(Message::*)()) .add_property(
(PEP_enc_format(Message::*)()) &Message::enc_format, "enc_format",
(void(Message::*)(int)) (int(Message::*)())(PEP_enc_format(Message::*)()) &
(void(Message::*)(PEP_enc_format)) &Message::enc_format, 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") "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::*)()) & Message::encrypt)
.def("encrypt", (Message(Message::*)(boost::python::list))&Message::_encrypt) .def(
.def("encrypt", (Message(Message::*)(boost::python::list, int))&Message::_encrypt) "encrypt",
.def("encrypt", (Message(Message::*)(boost::python::list, int, int))&Message::_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" "msg2 = msg1.encrypt(extra_keys=[], enc_format='pEp', flags=0)\n"
"\n" "\n"
"encrypts a p≡p message and returns the encrypted message\n" "encrypts a p≡p message and returns the encrypted message\n"
@ -449,9 +568,11 @@ namespace pEp {
" for encryption\n" " for encryption\n"
" enc_format 0 for none, 1 for partitioned, 2 for S/MIME,\n" " enc_format 0 for none, 1 for partitioned, 2 for S/MIME,\n"
" 3 for PGP/MIME, 4 for pEp\n" " 3 for PGP/MIME, 4 for pEp\n"
" flags 1 is force encryption\n" " flags 1 is force encryption\n")
) .def(
.def("decrypt", &Message::decrypt, boost::python::arg("flags")=0, "decrypt",
&Message::decrypt,
boost::python::arg("flags") = 0,
"msg2, keys, rating, flags = msg1.decrypt()\n" "msg2, keys, rating, flags = msg1.decrypt()\n"
"\n" "\n"
"decrypts a p≡p message and returns a tuple with data\n" "decrypts a p≡p message and returns a tuple with data\n"
@ -459,76 +580,82 @@ namespace pEp {
" msg the decrypted p≡p message\n" " msg the decrypted p≡p message\n"
" keys a list of keys being used\n" " keys a list of keys being used\n"
" rating the rating of the message as integer\n" " rating the rating of the message as integer\n"
" flags flags set while decryption\n" " flags flags set while decryption\n")
) .add_property(
.add_property("outgoing_rating", &Message::outgoing_rating, "rating outgoing message will have") "outgoing_rating",
.add_property("outgoing_color", &Message::outgoing_color, "color outgoing message will have as PEP_color") &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("__deepcopy__", &Message::deepcopy)
.def("__copy__", &Message::copy); .def("__copy__", &Message::copy);
// basic API and key management API // basic API and key management API
def("update_identity", &update_identity, def("update_identity",
&update_identity,
"update_identity(ident)\n" "update_identity(ident)\n"
"\n" "\n"
"update identity information\n" "update identity information\n"
"call this to complete identity information when you at least have an address\n" "call this to complete identity information when you at least have an address\n");
); def("myself",
def("myself", &myself, &myself,
"myself(ident)\n" "myself(ident)\n"
"\n" "\n"
"ensures that the own identity is being complete\n" "ensures that the own identity is being complete\n"
"supply ident.address and ident.username\n" "supply ident.address and ident.username\n");
); def("trust_personal_key",
def("trust_personal_key", &trust_personal_key, &trust_personal_key,
"trust_personal_key(ident)\n" "trust_personal_key(ident)\n"
"\n" "\n"
"mark a key as trusted with a person\n" "mark a key as trusted with a person\n");
);
enum_<identity_flags>("identity_flags") enum_<identity_flags>("identity_flags")
.value("PEP_idf_not_for_sync", PEP_idf_not_for_sync) .value("PEP_idf_not_for_sync", PEP_idf_not_for_sync)
.value("PEP_idf_list", PEP_idf_list) .value("PEP_idf_list", PEP_idf_list)
.value("PEP_idf_devicegroup", PEP_idf_devicegroup); .value("PEP_idf_devicegroup", PEP_idf_devicegroup);
def("set_identity_flags", &set_identity_flags, def("set_identity_flags",
&set_identity_flags,
"set_identity_flags(ident, flags)\n" "set_identity_flags(ident, flags)\n"
"\n" "\n"
"set identity flags\n" "set identity flags\n");
);
def("unset_identity_flags", &unset_identity_flags, def("unset_identity_flags",
&unset_identity_flags,
"unset_identity_flags(ident, flags)\n" "unset_identity_flags(ident, flags)\n"
"\n" "\n"
"unset identity flags\n" "unset identity flags\n");
);
def("key_reset_trust", &key_reset_trust, def("key_reset_trust",
&key_reset_trust,
"key_reset_trust(ident)\n" "key_reset_trust(ident)\n"
"\n" "\n"
"reset trust bit or explicitly mistrusted status for an identity and " "reset trust bit or explicitly mistrusted status for an identity and "
"its accompanying key/user_id pair\n" "its accompanying key/user_id pair\n");
);
def("import_key", &import_key, def("import_key",
&import_key,
"private_key_list = import_key(key_data)\n" "private_key_list = import_key(key_data)\n"
"\n" "\n"
"import key(s) from key_data\n" "import key(s) from key_data\n");
);
def("export_key", &export_key, def("export_key",
&export_key,
"key_data = export_key(identity)\n" "key_data = export_key(identity)\n"
"\n" "\n"
"export key(s) of identity\n" "export key(s) of identity\n");
);
def("export_secret_key", &export_secret_key, def("export_secret_key",
&export_secret_key,
"key_data = export_seret_key(identity)\n" "key_data = export_seret_key(identity)\n"
"\n" "\n"
"export secret key(s) of identity\n" "export secret key(s) of identity\n");
);
def("set_own_key", &set_own_key, def("set_own_key",
&set_own_key,
"set_own_key(me, fpr)\n" "set_own_key(me, fpr)\n"
"\n" "\n"
"mark a key as an own key, and make it the default key\n" "mark a key as an own key, and make it the default key\n"
@ -540,8 +667,7 @@ namespace pEp {
"myself() is called by set_own_key() without key generation\n" "myself() is called by set_own_key() without key generation\n"
"me->flags are ignored\n" "me->flags are ignored\n"
"me->address must not be an alias\n" "me->address must not be an alias\n"
"me->fpr will be ignored and replaced by fpr\n" "me->fpr will be ignored and replaced by fpr\n");
);
// message API // message API
@ -566,22 +692,23 @@ namespace pEp {
.value("red", PEP_color_red); .value("red", PEP_color_red);
def("incoming_message", &incoming_message, def("incoming_message",
&incoming_message,
"msg = incoming_message(mime_text)\n" "msg = incoming_message(mime_text)\n"
"\n" "\n"
"create an incoming message from a MIME text" "create an incoming message from a MIME text");
); def("outgoing_message",
def("outgoing_message", &outgoing_message, &outgoing_message,
"msg = outgoing_message(ident)\n" "msg = outgoing_message(ident)\n"
"\n" "\n"
"create an outgoing message using an own identity" "create an outgoing message using an own identity");
); def("color",
def("color", &_color, &_color,
"c = color(rating)\n" "c = color(rating)\n"
"\n" "\n"
"calculate color value out of rating. Returns PEP_color" "calculate color value out of rating. Returns PEP_color");
); def("trustwords",
def("trustwords", &_trustwords, &_trustwords,
"text = trustwords(ident_own, ident_partner)\n" "text = trustwords(ident_own, ident_partner)\n"
"\n" "\n"
"calculate trustwords for two Identities"); "calculate trustwords for two Identities");
@ -600,33 +727,37 @@ namespace pEp {
.value("SYNC_NOTIFY_SOLE", SYNC_NOTIFY_SOLE) .value("SYNC_NOTIFY_SOLE", SYNC_NOTIFY_SOLE)
.value("SYNC_NOTIFY_IN_GROUP", SYNC_NOTIFY_IN_GROUP); .value("SYNC_NOTIFY_IN_GROUP", SYNC_NOTIFY_IN_GROUP);
def("deliver_handshake_result", &deliverHandshakeResult, boost::python::arg("identities")=object(), def("deliver_handshake_result",
&deliverHandshakeResult,
boost::python::arg("identities") = object(),
"deliverHandshakeResult(self, result, identities=None)\n" "deliverHandshakeResult(self, result, identities=None)\n"
"\n" "\n"
" result -1: cancel, 0: accepted, 1: rejected\n" " result -1: cancel, 0: accepted, 1: rejected\n"
" identities list of identities to share or None for all\n" " identities list of identities to share or None for all\n"
"\n" "\n"
"call to deliver the handshake result of the handshake dialog" "call to deliver the handshake result of the handshake dialog");
);
def("debug_color", &debug_color, def("debug_color", &debug_color, "for debug builds set ANSI color value");
"for debug builds set ANSI color value");
def("leave_device_group", &leave_device_group, def("leave_device_group",
&leave_device_group,
"leave_device_group()\n" "leave_device_group()\n"
"\n" "\n"
"call this for a grouped device, which should leave\n" "call this for a grouped device, which should leave\n");
);
def("disable_all_sync_channels", &disable_all_sync_channels, def("disable_all_sync_channels",
&disable_all_sync_channels,
"disable_all_sync_channels()\n" "disable_all_sync_channels()\n"
"\n" "\n"
"Disable sync for all identities\n" "Disable sync for all identities\n");
);
// codecs // codecs
call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(sync_search)); call<object>(
call< object >(((object)(import("codecs").attr("register"))).ptr(), make_function(distribution_search)); ((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 PythonAdapter

66
src/pEp/_pEp/str_attr.cc
View File

@ -15,44 +15,54 @@ namespace pEp {
using namespace boost::python; using namespace boost::python;
using namespace boost::locale; using namespace boost::locale;
object repr(object s) { object repr(object s)
{
return s.attr("__repr__")(); return s.attr("__repr__")();
} }
string repr(string s) { string repr(string s)
{
str _s = s.c_str(); str _s = s.c_str();
object _r = _s.attr("__repr__")(); object _r = _s.attr("__repr__")();
string r = extract<string>(_r); string r = extract<string>(_r);
return r; return r;
} }
string str_attr(char *&str) { string str_attr(char *&str)
if (!str) {
if (!str) {
return string(""); return string("");
}
return string(str); return string(str);
} }
void str_attr(char *&str, string value) { void str_attr(char *&str, string value)
{
string normalized = normalize(value, norm_nfc); string normalized = normalize(value, norm_nfc);
free(str); free(str);
str = strdup(normalized.c_str()); str = strdup(normalized.c_str());
if (!str) if (!str) {
throw bad_alloc(); throw bad_alloc();
} }
}
time_t timestamp_attr(timestamp *&ts) { time_t timestamp_attr(timestamp *&ts)
if (!ts) {
if (!ts) {
return 0; return 0;
}
return timegm(ts); return timegm(ts);
} }
void timestamp_attr(timestamp *&ts, time_t value) { void timestamp_attr(timestamp *&ts, time_t value)
{
free_timestamp(ts); free_timestamp(ts);
ts = new_timestamp(value); ts = new_timestamp(value);
} }
boost::python::list strlist_attr(stringlist_t *&sl) { boost::python::list strlist_attr(stringlist_t *&sl)
{
boost::python::list result; boost::python::list result;
for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
@ -63,10 +73,12 @@ namespace pEp {
return result; return result;
} }
void strlist_attr(stringlist_t *&sl, boost::python::list value) { void strlist_attr(stringlist_t *&sl, boost::python::list value)
{
stringlist_t *_sl = new_stringlist(NULL); stringlist_t *_sl = new_stringlist(NULL);
if (!_sl) if (!_sl) {
throw bad_alloc(); throw bad_alloc();
}
stringlist_t *_s = _sl; stringlist_t *_s = _sl;
for (int i = 0; i < len(value); i++) { for (int i = 0; i < len(value); i++) {
@ -87,11 +99,11 @@ namespace pEp {
sl = _sl; sl = _sl;
} }
dict strdict_attr(stringpair_list_t *&spl) { dict strdict_attr(stringpair_list_t *&spl)
{
dict result; dict result;
for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = _spl->next) {
_spl->next) {
stringpair_t *p = _spl->value; stringpair_t *p = _spl->value;
if (p->key && p->value) { if (p->key && p->value) {
string key(p->key); string key(p->key);
@ -104,18 +116,21 @@ namespace pEp {
return result; return result;
} }
void strdict_attr(stringpair_list_t *&spl, dict value) { void strdict_attr(stringpair_list_t *&spl, dict value)
{
stringpair_list_t *_spl = new_stringpair_list(NULL); stringpair_list_t *_spl = new_stringpair_list(NULL);
if (!_spl) if (!_spl) {
throw bad_alloc(); throw bad_alloc();
}
stringpair_list_t *_s = _spl; stringpair_list_t *_s = _spl;
for (int i = 0; i < len(value); i++) { for (int i = 0; i < len(value); i++) {
extract<string> extract_key(value.keys()[i]); extract<string> extract_key(value.keys()[i]);
extract<string> extract_value(value.values()[i]); extract<string> extract_value(value.values()[i]);
if (!(extract_key.check() && extract_value.check())) if (!(extract_key.check() && extract_value.check())) {
free_stringpair_list(_spl); free_stringpair_list(_spl);
}
string key = extract_key(); string key = extract_key();
key = normalize(key, norm_nfc); key = normalize(key, norm_nfc);
@ -137,16 +152,19 @@ namespace pEp {
spl = _spl; spl = _spl;
} }
stringlist_t *to_stringlist(boost::python::list l) { stringlist_t *to_stringlist(boost::python::list l)
{
stringlist_t *result = new_stringlist(NULL); stringlist_t *result = new_stringlist(NULL);
if (!result) if (!result) {
throw bad_alloc(); throw bad_alloc();
}
stringlist_t *_s = result; stringlist_t *_s = result;
for (int i = 0; i < len(l); i++) { for (int i = 0; i < len(l); i++) {
extract<string> extract_string(l[i]); extract<string> extract_string(l[i]);
if (!extract_string.check()) if (!extract_string.check()) {
free_stringlist(result); free_stringlist(result);
}
string s = extract_string(); string s = extract_string();
_s = stringlist_add(_s, s.c_str()); _s = stringlist_add(_s, s.c_str());
if (!_s) { if (!_s) {
@ -158,7 +176,8 @@ namespace pEp {
return result; return result;
} }
boost::python::list from_stringlist(const stringlist_t *sl) { boost::python::list from_stringlist(const stringlist_t *sl)
{
boost::python::list result; boost::python::list result;
for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) {
string s = _sl->value; string s = _sl->value;
@ -168,5 +187,4 @@ namespace pEp {
} }
} // namespace PythonAdapter } // namespace PythonAdapter
} // namespace pEp { } // namespace pEp

4
src/pEp/_pEp/str_attr.hh
View File

@ -16,9 +16,9 @@
namespace pEp { namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
using std::string;
using boost::python::object;
using boost::python::dict; using boost::python::dict;
using boost::python::object;
using std::string;
object repr(object s); object repr(object s);
string repr(string s); string repr(string s);

Write Preview
Loading…
Cancel
Save