diff --git a/src/pEp/_pEp/basic_api.cc b/src/pEp/_pEp/basic_api.cc index 50cc802..aee8393 100644 --- a/src/pEp/_pEp/basic_api.cc +++ b/src/pEp/_pEp/basic_api.cc @@ -16,19 +16,20 @@ namespace pEp { namespace PythonAdapter { using namespace std; - void update_identity(Identity &ident) { + void update_identity(Identity &ident) + { if (ident.address() == "") throw invalid_argument("address needed"); if (ident.user_id() == PEP_OWN_USERID) - throw runtime_error("update_identity: '" - PEP_OWN_USERID - "' may only be used for own identities"); + throw runtime_error("update_identity: '" PEP_OWN_USERID + "' may only be used for own identities"); PEP_STATUS status = update_identity(Adapter::session(), ident); _throw_status(status); } - void myself(Identity &ident) { + void myself(Identity &ident) + { if (ident.address() == "") throw invalid_argument("address needed"); if (ident.username() == "") @@ -41,7 +42,8 @@ namespace pEp { _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() == "") throw invalid_argument("fingerprint needed in Identities"); @@ -50,13 +52,20 @@ namespace pEp { char *words = NULL; size_t size = 0; - PEP_STATUS status = get_trustwords(Adapter::session(), me, partner, - lang.c_str(), &words, &size, full); + PEP_STATUS status = get_trustwords( + Adapter::session(), + me, + partner, + lang.c_str(), + &words, + &size, + full); _throw_status(status); return words; } - void trust_personal_key(Identity ident) { + void trust_personal_key(Identity ident) + { if (ident.fpr() == "") throw invalid_argument("fingerprint needed in Identities"); if (ident.user_id() == "") @@ -66,7 +75,8 @@ namespace pEp { _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() == "") throw invalid_argument("address needed"); if (ident.user_id() == "") @@ -76,7 +86,8 @@ namespace pEp { _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() == "") throw invalid_argument("address needed"); if (ident.user_id() == "") @@ -86,7 +97,8 @@ namespace pEp { _throw_status(status); } - void key_reset_trust(Identity ident) { + void key_reset_trust(Identity ident) + { if (ident.fpr() == "") throw invalid_argument("fpr needed"); 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; - 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) _throw_status(status); @@ -119,7 +136,8 @@ namespace pEp { return result; } - string export_key(Identity ident) { + string export_key(Identity ident) + { PEP_STATUS status = PEP_STATUS_OK; char *key_data = NULL; size_t size; @@ -129,7 +147,8 @@ namespace pEp { return key_data; } - string export_secret_key(Identity ident) { + string export_secret_key(Identity ident) + { PEP_STATUS status = PEP_STATUS_OK; char *key_data = NULL; size_t size; @@ -139,7 +158,8 @@ namespace pEp { return key_data; } - void set_own_key(Identity &ident, string fpr) { + void set_own_key(Identity &ident, string fpr) + { if (ident.address() == "") throw invalid_argument("address needed"); if (ident.username() == "") @@ -157,5 +177,3 @@ namespace pEp { } // namespace PythonAdapter } // namespace pEp - - diff --git a/src/pEp/_pEp/identity.cc b/src/pEp/_pEp/identity.cc index 5274c1a..b7e077b 100644 --- a/src/pEp/_pEp/identity.cc +++ b/src/pEp/_pEp/identity.cc @@ -21,40 +21,44 @@ namespace pEp { using namespace std; using namespace boost::python; - Identity::Identity(string address, string username, string user_id, - string fpr, int comm_type, string lang, identity_flags_t flags) - : _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), - username.c_str()), &::free_identity) { - if (!_ident) + Identity::Identity( + string address, + string username, + string user_id, + string fpr, + int comm_type, + string lang, + identity_flags_t flags) : + _ident( + new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), username.c_str()), + &::free_identity) + { + if (!_ident) { throw bad_alloc(); - _ident->comm_type = (PEP_comm_type) comm_type; - _ident->flags = (identity_flags_t) flags; + } + _ident->comm_type = (PEP_comm_type)comm_type; + _ident->flags = (identity_flags_t)flags; this->lang(lang); } - Identity::Identity(const Identity &second) - : _ident(second._ident) { - - } - - Identity::Identity(pEp_identity *ident) - : _ident(ident, &::free_identity) { - - } + Identity::Identity(const Identity &second) : _ident(second._ident) {} - Identity::~Identity() { + Identity::Identity(pEp_identity *ident) : _ident(ident, &::free_identity) {} - } + Identity::~Identity() {} - Identity::operator pEp_identity *() { + Identity::operator pEp_identity *() + { return _ident.get(); } - Identity::operator const pEp_identity *() const { + Identity::operator const pEp_identity *() const + { return _ident.get(); } - string Identity::_repr() { + string Identity::_repr() + { stringstream build; build << "Identity("; string address; @@ -73,160 +77,174 @@ namespace pEp { if (_ident->fpr) fpr = string(_ident->fpr); build << repr(fpr) << ", "; - build << (int) _ident->comm_type << ", "; + build << (int)_ident->comm_type << ", "; string lang = _ident->lang; build << repr(lang) << ")"; return build.str(); } - string Identity::_str() { - if (!(_ident->address && _ident->address[0])) + string Identity::_str() + { + if (!(_ident->address && _ident->address[0])) { return ""; - if (!(_ident->username && _ident->username[0])) + } + if (!(_ident->username && _ident->username[0])) { return _ident->address; + } return string(_ident->username) + " <" + _ident->address + ">"; } - void Identity::username(string value) { - if (value.length() && value.length() < 5) + void Identity::username(string value) + { + if (value.length() && value.length() < 5) { throw length_error("username must be at least 5 characters"); + } str_attr(_ident->username, value); } - void Identity::lang(string value) { - if (value == "") + void Identity::lang(string value) + { + if (value == "") { memset(_ident->lang, 0, 3); - else if (value.length() != 2) + } else if (value.length() != 2) { throw length_error("length of lang must be 2"); - else + } else { memcpy(_ident->lang, value.c_str(), 3); + } } - string Identity::lang() { + string Identity::lang() + { return _ident->lang; } - int Identity::rating() { - if (!(_ident->address)) + int Identity::rating() + { + if (!(_ident->address)) { throw invalid_argument("address must be given"); + } PEP_rating rating = PEP_rating_undefined; PEP_STATUS status = ::identity_rating(Adapter::session(), _ident.get(), &rating); _throw_status(status); - return (int) rating; + return (int)rating; } - PEP_color Identity::color() { + PEP_color Identity::color() + { return _color(rating()); } - Identity Identity::copy() { + Identity Identity::copy() + { pEp_identity *dup = ::identity_dup(*this); - if (!dup) + if (!dup) { throw bad_alloc(); + } return Identity(dup); } - Identity Identity::deepcopy(dict &) { + Identity Identity::deepcopy(dict &) + { return copy(); } - void Identity::update() { + void Identity::update() + { update_identity(*this); } - void Identity::key_reset(string fpr) { - PEP_STATUS status = ::key_reset_identity(Adapter::session(), *this, - fpr != "" ? fpr.c_str() : nullptr); + void Identity::key_reset(string fpr) + { + PEP_STATUS status = ::key_reset_identity( + Adapter::session(), + *this, + fpr != "" ? fpr.c_str() : nullptr); _throw_status(status); } - void Identity::key_mistrusted() { + void Identity::key_mistrusted() + { PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this); _throw_status(status); } - bool Identity::is_pEp_user() { + bool Identity::is_pEp_user() + { bool result; PEP_STATUS status = ::is_pEp_user(Adapter::session(), *this, &result); _throw_status(status); return result; } - void Identity::enable_for_sync() { + void Identity::enable_for_sync() + { PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this); _throw_status(status); } - void Identity::disable_for_sync() { + void Identity::disable_for_sync() + { PEP_STATUS status = ::disable_identity_for_sync(Adapter::session(), *this); _throw_status(status); } -// Myself::Myself(string address, string username, string user_id, string lang) -// : Identity(address, username, user_id, "", 0, lang) { -// if (!(address.length() && username.length())) -// throw invalid_argument("address and username must be set"); -// if (lang.length() && lang.length() != 2) -// throw length_error("lang must be an ISO 639-1 language code or empty"); -// -// // FIXME: should set .me -// // _ident->me = true; -// if (user_id.length()) -// throw runtime_error("user_id feature not yet implemented for Myself"); -// } - -// void Myself::update() { -// pEp::PythonAdapter::myself(*this); -// } - - Identity identity_attr(pEp_identity *&ident) { - if (!ident) + Identity identity_attr(pEp_identity *&ident) + { + if (!ident) { throw out_of_range("no identity assigned"); + } pEp_identity *_dup = ::identity_dup(ident); - if (!_dup) + if (!_dup) { throw bad_alloc(); + } Identity _ident(_dup); return _ident; } - void identity_attr(pEp_identity *&ident, object value) { + void identity_attr(pEp_identity *&ident, object value) + { Identity &_ident = extract(value); pEp_identity *_dup = ::identity_dup(_ident); - if (!_dup) + if (!_dup) { throw bad_alloc(); + } PEP_STATUS status = ::update_identity(Adapter::session(), _dup); _throw_status(status); ::free_identity(ident); ident = _dup; } - boost::python::list identitylist_attr(identity_list *&il) { + boost::python::list identitylist_attr(identity_list *&il) + { boost::python::list result; for (identity_list *_il = il; _il && _il->ident; _il = _il->next) { pEp_identity *ident = ::identity_dup(_il->ident); - if (!ident) + if (!ident) { throw bad_alloc(); + } result.append(object(Identity(ident))); } 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); - if (!_il) + if (!_il) { throw bad_alloc(); + } identity_list *_i = _il; for (int i = 0; i < len(value); i++) { - extract < Identity & > extract_identity(value[i]); + extract extract_identity(value[i]); if (!extract_identity.check()) { free_identity_list(_il); } @@ -254,4 +272,3 @@ namespace pEp { } // namespace PythonAdapter } // namespace pEp - diff --git a/src/pEp/_pEp/identity.hh b/src/pEp/_pEp/identity.hh index 9149aaf..6bebccf 100644 --- a/src/pEp/_pEp/identity.hh +++ b/src/pEp/_pEp/identity.hh @@ -23,19 +23,24 @@ namespace pEp { namespace PythonAdapter { - using std::string; using std::shared_ptr; + using std::string; -// Identity is owning a pEp_identity + // Identity is owning a pEp_identity class Identity { protected: - shared_ptr _ident; + shared_ptr _ident; public: - Identity(string address = "", string username = "", - string user_id = "", string fpr = "", int comm_type = 0, - string lang = "", identity_flags_t flags = 0); + Identity( + string address = "", + string username = "", + string user_id = "", + string fpr = "", + int comm_type = 0, + string lang = "", + identity_flags_t flags = 0); Identity(const Identity &second); @@ -51,33 +56,66 @@ namespace pEp { string _str(); - string address() { return str_attr(_ident->address); } - - void address(string value) { str_attr(_ident->address, value); } - - string fpr() { return str_attr(_ident->fpr); } - - void fpr(string value) { str_attr(_ident->fpr, value); } - - string user_id() { return str_attr(_ident->user_id); } - - void user_id(string value) { str_attr(_ident->user_id, value); } - - string username() { return str_attr(_ident->username); } + string address() + { + return str_attr(_ident->address); + } + + void address(string value) + { + str_attr(_ident->address, value); + } + + string fpr() + { + return str_attr(_ident->fpr); + } + + void fpr(string value) + { + str_attr(_ident->fpr, value); + } + + string user_id() + { + return str_attr(_ident->user_id); + } + + void user_id(string value) + { + str_attr(_ident->user_id, value); + } + + string username() + { + return str_attr(_ident->username); + } void username(string value); - PEP_comm_type comm_type() { return _ident->comm_type; } + 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(); 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(); @@ -100,13 +138,6 @@ namespace pEp { void disable_for_sync(); }; -// class Myself : public Identity { -// public: -// Myself(string address, string username, string user_id = "", string lang = ""); -// -// virtual void update(); -// }; - Identity identity_attr(pEp_identity *&ident); void identity_attr(pEp_identity *&ident, object value); diff --git a/src/pEp/_pEp/message.cc b/src/pEp/_pEp/message.cc index ffdcca7..0694ea1 100644 --- a/src/pEp/_pEp/message.cc +++ b/src/pEp/_pEp/message.cc @@ -23,23 +23,28 @@ namespace pEp { using namespace std; using namespace boost::python; - Message::Blob::Blob(bloblist_t *bl, bool chained) : - _bl(bl), part_of_chain(chained) { - if (!_bl) + Message::Blob::Blob(bloblist_t *bl, bool chained) : _bl(bl), part_of_chain(chained) + { + if (!_bl) { throw bad_alloc(); + } } Message::Blob::Blob(object data, string mime_type, string filename) : - _bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) { - if (!_bl) + _bl(new_bloblist(NULL, 0, NULL, NULL)), + part_of_chain(false) + { + if (!_bl) { throw bad_alloc(); + } Py_buffer src; int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO); - if (result) + if (result) { throw invalid_argument("need a contiguous buffer to read"); + } - char *mem = (char *) malloc(src.len); + char *mem = (char *)malloc(src.len); if (!mem) { PyBuffer_Release(&src); throw bad_alloc(); @@ -56,19 +61,18 @@ namespace pEp { this->filename(filename); } - Message::Blob::Blob(const Message::Blob &second) : - _bl(second._bl), part_of_chain(true) { - - } + Message::Blob::Blob(const Message::Blob &second) : _bl(second._bl), part_of_chain(true) {} - Message::Blob::~Blob() { + Message::Blob::~Blob() + { if (!part_of_chain) { free(_bl->value); free(_bl); } } - string Message::Blob::_repr() { + string Message::Blob::_repr() + { stringstream build; build << "Blob("; if (!_bl) { @@ -88,14 +92,14 @@ namespace pEp { 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; try { Message::Blob &blob = extract(self); bl = blob._bl; - } - catch (exception &e) { + } catch (exception &e) { PyErr_SetString(PyExc_RuntimeError, "extract not possible"); view->obj = NULL; return -1; @@ -110,52 +114,58 @@ namespace pEp { 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 == "") { string _mime_type = _bl->mime_type ? _bl->mime_type : ""; encoding = "ascii"; - if (_mime_type == "application/pEp.sync") + if (_mime_type == "application/pEp.sync") { encoding = "pep.sync"; + } - if (_mime_type == "application/pEp.keyreset") + if (_mime_type == "application/pEp.keyreset") { encoding = "pep.distribution"; - + } } object codecs = import("codecs"); object _decode = codecs.attr("decode"); return call(_decode.ptr(), this, encoding); } - PyBufferProcs Message::Blob::bp = {getbuffer, NULL}; + PyBufferProcs Message::Blob::bp = { getbuffer, NULL }; - Message::Message(int dir, Identity *from) - : _msg(new_message((PEP_msg_direction) dir), &free_message) { - if (!_msg) + Message::Message(int dir, Identity *from) : + _msg(new_message((PEP_msg_direction)dir), &free_message) + { + if (!_msg) { throw bad_alloc(); + } if (from) { _msg->from = ::identity_dup(*from); - if (!_msg->from) + if (!_msg->from) { throw bad_alloc(); - _msg->dir = (PEP_msg_direction) dir; + } + _msg->dir = (PEP_msg_direction)dir; } } - Message::Message(string mimetext) - : _msg(NULL, &free_message) { + Message::Message(string mimetext) : _msg(NULL, &free_message) + { message *_cpy; - PEP_STATUS status = mime_decode_message(mimetext.c_str(), - mimetext.size(), &_cpy, NULL); + PEP_STATUS status = mime_decode_message(mimetext.c_str(), mimetext.size(), &_cpy, NULL); switch (status) { case PEP_STATUS_OK: - if (_cpy) + if (_cpy) { _cpy->dir = PEP_dir_outgoing; - else + } else { _cpy = new_message(PEP_dir_outgoing); + } - if (!_cpy) + if (!_cpy) { throw bad_alloc(); + } _msg = shared_ptr(_cpy); break; @@ -171,37 +181,37 @@ namespace pEp { default: stringstream build; - build << "mime_decode_message: unknown error (" << (int) status << ")"; + build << "mime_decode_message: unknown error (" << (int)status << ")"; throw runtime_error(build.str()); } } - Message::Message(const Message &second) - : _msg(second._msg) { - if (!_msg.get()) + Message::Message(const Message &second) : _msg(second._msg) + { + if (!_msg.get()) { throw bad_alloc(); + } } - Message::Message(message *msg) - : _msg(::message_dup(msg), &free_message) { - - } - - Message::~Message() { + Message::Message(message *msg) : _msg(::message_dup(msg), &free_message) {} - } + Message::~Message() {} - Message::operator message *() { + Message::operator message *() + { return _msg.get(); } - Message::operator const message *() const { + Message::operator const message *() const + { return _msg.get(); } - string Message::_str() { - if (!(_msg->from && _msg->from->address && _msg->from->address[0])) + string Message::_str() + { + if (!(_msg->from && _msg->from->address && _msg->from->address[0])) { throw out_of_range(".from_.address missing"); + } char *mimetext; string result; @@ -224,40 +234,47 @@ namespace pEp { default: stringstream build; - build << "mime_encode_message: unknown error (" << (int) status << ")"; + build << "mime_encode_message: unknown error (" << (int)status << ")"; throw runtime_error(build.str()); } return result; } - string Message::_repr() { + string Message::_repr() + { stringstream build; build << "Message(" << repr(_str()) << ")"; return build.str(); } - boost::python::tuple Message::attachments() { + boost::python::tuple Message::attachments() + { boost::python::list l; - for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = - bl->next) { + for (bloblist_t *bl = _msg->attachments; bl && bl->value; bl = bl->next) { l.append(Blob(bl, true)); } return boost::python::tuple(l); } - void Message::attachments(boost::python::list value) { + void Message::attachments(boost::python::list value) + { bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL); - if (!bl) + if (!bl) { throw bad_alloc(); + } bloblist_t *_l = bl; for (int i = 0; i < len(value); i++) { Message::Blob &blob = extract(value[i]); - _l = bloblist_add(_l, blob._bl->value, blob._bl->size, - blob._bl->mime_type, blob._bl->filename); + _l = bloblist_add( + _l, + blob._bl->value, + blob._bl->size, + blob._bl->mime_type, + blob._bl->filename); if (!_l) { for (_l = bl; _l && _l->value;) { free(_l->mime_type); @@ -284,32 +301,41 @@ namespace pEp { _msg->attachments = bl; } - Message Message::encrypt() { + Message Message::encrypt() + { boost::python::list extra; return encrypt_message(*this, extra, PEP_enc_PGP_MIME, 0); } - Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) { - if (!enc_format) + Message Message::_encrypt(boost::python::list extra, int enc_format, int flags) + { + if (!enc_format) { enc_format = PEP_enc_PGP_MIME; + } return encrypt_message(*this, extra, enc_format, flags); } - boost::python::tuple Message::decrypt(int flags) { + boost::python::tuple Message::decrypt(int flags) + { return pEp::PythonAdapter::decrypt_message(*this, flags); } - PEP_rating Message::outgoing_rating() { - if (_msg->dir != PEP_dir_outgoing) + PEP_rating Message::outgoing_rating() + { + if (_msg->dir != PEP_dir_outgoing) { throw invalid_argument("Message.dir must be outgoing"); + } - if (from().address() == "") + if (from().address() == "") { throw invalid_argument("from.address needed"); - if (from().username() == "") + } + if (from().username() == "") { 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"); + } PEP_STATUS status = myself(Adapter::session(), _msg->from); _throw_status(status); @@ -321,38 +347,47 @@ namespace pEp { return rating; } - PEP_color Message::outgoing_color() { + PEP_color Message::outgoing_color() + { return _color(outgoing_rating()); } - Message Message::copy() { + Message Message::copy() + { message *dup = message_dup(*this); - if (!dup) + if (!dup) { throw bad_alloc(); + } return Message(dup); } - Message Message::deepcopy(dict &) { + Message Message::deepcopy(dict &) + { return copy(); } - Message outgoing_message(Identity me) { - if (me.address().empty() || me.user_id().empty()) + Message outgoing_message(Identity me) + { + if (me.address().empty() || me.user_id().empty()) { throw runtime_error("at least address and user_id of own user needed"); + } ::myself(Adapter::session(), me); auto m = Message(PEP_dir_outgoing, &me); return m; } - static object update(Identity ident) { - if (ident.address().empty()) + static object update(Identity ident) + { + if (ident.address().empty()) { throw runtime_error("at least address needed"); + } update_identity(Adapter::session(), ident); return object(ident); } - static boost::python::list update(boost::python::list il) { + static boost::python::list update(boost::python::list il) + { for (int i = 0; i < len(il); i++) { update(extract(il[i])); } @@ -360,19 +395,20 @@ namespace pEp { return il; } - Message incoming_message(string mime_text) { + Message incoming_message(string mime_text) + { auto m = Message(mime_text); m.dir(PEP_dir_incoming); try { m.from(update(m.from())); + } catch (out_of_range &) { } - catch (out_of_range &) {} try { m.recv_by(update(m.recv_by())); + } catch (out_of_range &) { } - catch (out_of_range &) {} m.to(update(m.to())); m.cc(update(m.cc())); diff --git a/src/pEp/_pEp/message.hh b/src/pEp/_pEp/message.hh index 5eba845..eba8863 100644 --- a/src/pEp/_pEp/message.hh +++ b/src/pEp/_pEp/message.hh @@ -19,12 +19,12 @@ namespace pEp { namespace PythonAdapter { - using std::string; - using std::runtime_error; - using std::invalid_argument; 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 class Message { shared_ptr<::message> _msg; @@ -38,8 +38,7 @@ namespace pEp { bool part_of_chain; public: - Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), - bool chained = false); + Blob(bloblist_t *bl = new_bloblist(NULL, 0, NULL, NULL), bool chained = false); Blob(object data, string mime_type = "", string filename = ""); @@ -49,19 +48,37 @@ namespace pEp { 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() { return decode(""); } + string decode() + { + return decode(""); + } static PyBufferProcs bp; @@ -89,85 +106,199 @@ namespace pEp { string _repr(); - PEP_msg_direction dir() { return _msg->dir; } - - void dir(PEP_msg_direction value) { _msg->dir = value; } - - string id() { return str_attr(_msg->id); } - - void id(string value) { str_attr(_msg->id, value); } - - string shortmsg() { return str_attr(_msg->shortmsg); } - - void shortmsg(string value) { str_attr(_msg->shortmsg, value); } - - string longmsg() { return str_attr(_msg->longmsg); } - - void longmsg(string value) { str_attr(_msg->longmsg, value); } - - string longmsg_formatted() { return str_attr(_msg->longmsg_formatted); } - - void longmsg_formatted(string value) { str_attr(_msg->longmsg_formatted, value); } + PEP_msg_direction dir() + { + return _msg->dir; + } + + void dir(PEP_msg_direction value) + { + _msg->dir = value; + } + + string id() + { + return str_attr(_msg->id); + } + + void id(string value) + { + str_attr(_msg->id, value); + } + + string shortmsg() + { + return str_attr(_msg->shortmsg); + } + + void shortmsg(string value) + { + str_attr(_msg->shortmsg, value); + } + + string longmsg() + { + return str_attr(_msg->longmsg); + } + + void longmsg(string value) + { + str_attr(_msg->longmsg, value); + } + + string longmsg_formatted() + { + return str_attr(_msg->longmsg_formatted); + } + + void longmsg_formatted(string value) + { + str_attr(_msg->longmsg_formatted, value); + } boost::python::tuple attachments(); void attachments(boost::python::list value); - time_t sent() { return timestamp_attr(_msg->sent); } - - void sent(time_t value) { timestamp_attr(_msg->sent, value); } - - time_t recv() { return timestamp_attr(_msg->recv); } - - void recv(time_t value) { timestamp_attr(_msg->recv, value); } - - Identity from() { return identity_attr(_msg->from); } - - void from(object value) { identity_attr(_msg->from, value); } - - boost::python::list to() { return identitylist_attr(_msg->to); } - - void to(boost::python::list value) { identitylist_attr(_msg->to, value); } - - Identity recv_by() { return identity_attr(_msg->recv_by); } - - void recv_by(object value) { identity_attr(_msg->recv_by, value); } - - boost::python::list cc() { return identitylist_attr(_msg->cc); } - - void cc(boost::python::list value) { identitylist_attr(_msg->cc, value); } - - boost::python::list bcc() { return identitylist_attr(_msg->bcc); } - - void bcc(boost::python::list value) { identitylist_attr(_msg->bcc, value); } - - boost::python::list reply_to() { return identitylist_attr(_msg->reply_to); } - - void reply_to(boost::python::list value) { identitylist_attr(_msg->reply_to, value); } - - boost::python::list in_reply_to() { return strlist_attr(_msg->in_reply_to); } - - void in_reply_to(boost::python::list value) { strlist_attr(_msg->in_reply_to, value); } - - boost::python::list references() { return strlist_attr(_msg->references); } - - void references(boost::python::list value) { strlist_attr(_msg->references, value); } - - boost::python::list keywords() { return strlist_attr(_msg->keywords); } - - void keywords(boost::python::list value) { strlist_attr(_msg->keywords, value); } - - string comments() { return str_attr(_msg->comments); } - - void comments(string value) { str_attr(_msg->comments, value); } - - dict opt_fields() { return strdict_attr(_msg->opt_fields); } - - void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); } - - PEP_enc_format enc_format() { return _msg->enc_format; } - - void enc_format(PEP_enc_format value) { _msg->enc_format = value; } + time_t sent() + { + return timestamp_attr(_msg->sent); + } + + void sent(time_t value) + { + timestamp_attr(_msg->sent, value); + } + + time_t recv() + { + return timestamp_attr(_msg->recv); + } + + void recv(time_t value) + { + timestamp_attr(_msg->recv, value); + } + + Identity from() + { + return identity_attr(_msg->from); + } + + void from(object value) + { + identity_attr(_msg->from, value); + } + + boost::python::list to() + { + return identitylist_attr(_msg->to); + } + + void to(boost::python::list value) + { + identitylist_attr(_msg->to, value); + } + + Identity recv_by() + { + return identity_attr(_msg->recv_by); + } + + void recv_by(object value) + { + identity_attr(_msg->recv_by, value); + } + + boost::python::list cc() + { + return identitylist_attr(_msg->cc); + } + + void cc(boost::python::list value) + { + identitylist_attr(_msg->cc, value); + } + + boost::python::list bcc() + { + return identitylist_attr(_msg->bcc); + } + + void bcc(boost::python::list value) + { + identitylist_attr(_msg->bcc, value); + } + + boost::python::list reply_to() + { + return identitylist_attr(_msg->reply_to); + } + + void reply_to(boost::python::list value) + { + identitylist_attr(_msg->reply_to, value); + } + + boost::python::list in_reply_to() + { + return strlist_attr(_msg->in_reply_to); + } + + void in_reply_to(boost::python::list value) + { + strlist_attr(_msg->in_reply_to, value); + } + + boost::python::list references() + { + return strlist_attr(_msg->references); + } + + void references(boost::python::list value) + { + strlist_attr(_msg->references, value); + } + + boost::python::list keywords() + { + return strlist_attr(_msg->keywords); + } + + void keywords(boost::python::list value) + { + strlist_attr(_msg->keywords, value); + } + + string comments() + { + return str_attr(_msg->comments); + } + + void comments(string value) + { + str_attr(_msg->comments, value); + } + + dict opt_fields() + { + return strdict_attr(_msg->opt_fields); + } + + void opt_fields(dict value) + { + return strdict_attr(_msg->opt_fields, value); + } + + PEP_enc_format enc_format() + { + return _msg->enc_format; + } + + void enc_format(PEP_enc_format value) + { + _msg->enc_format = value; + } Message encrypt(); @@ -191,4 +322,4 @@ namespace pEp { } /* namespace PythonAdapter */ } /* namespace pEp */ -#endif /* MESSAGE_HH */ \ No newline at end of file +#endif /* MESSAGE_HH */ diff --git a/src/pEp/_pEp/message_api.cc b/src/pEp/_pEp/message_api.cc index 1c2e3c7..54dd9b9 100644 --- a/src/pEp/_pEp/message_api.cc +++ b/src/pEp/_pEp/message_api.cc @@ -17,42 +17,58 @@ namespace pEp { using namespace std; 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(); - if (_from.address() == "") + if (_from.address() == "") { throw invalid_argument("encrypt_message: src.from_.address empty"); - if (_from.username() == "") + } + if (_from.username() == "") { throw invalid_argument("encrypt_message: src.from_.username empty"); + } - if (_from.user_id() == "") + if (_from.user_id() == "") { src.from().user_id(_from.address()); + } stringlist_t *_extra = to_stringlist(extra); - PEP_enc_format _enc_format = (PEP_enc_format) enc_format; - PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags; + PEP_enc_format _enc_format = (PEP_enc_format)enc_format; + PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t)flags; message *_dst = NULL; message *_src = src; - PEP_STATUS status = encrypt_message(Adapter::session(), _src, _extra, &_dst, - _enc_format, _flags); + PEP_STATUS status = encrypt_message( + Adapter::session(), + _src, + _extra, + &_dst, + _enc_format, + _flags); free_stringlist(_extra); _throw_status(status); - if (!_dst || _dst == _src) + if (!_dst || _dst == _src) { return Message(_src); + } return Message(_dst); } - boost::python::tuple decrypt_message(Message src, int flags) { + boost::python::tuple decrypt_message(Message src, int flags) + { message *_dst = NULL; stringlist_t *_keylist = NULL; PEP_rating _rating = PEP_rating_undefined; - PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t) flags; + PEP_decrypt_flags_t _flags = (PEP_decrypt_flags_t)flags; message *_src = src; - PEP_STATUS status = ::decrypt_message(Adapter::session(), _src, &_dst, &_keylist, - &_rating, &_flags); + PEP_STATUS status = ::decrypt_message( + Adapter::session(), + _src, + &_dst, + &_keylist, + &_rating, + &_flags); _throw_status(status); boost::python::list keylist; @@ -65,18 +81,21 @@ namespace pEp { return boost::python::make_tuple(dst, keylist, _rating, _flags); } - PEP_color _color(int rating) { - return ::color_from_rating((PEP_rating) rating); + PEP_color _color(int 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; int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); - if (result) + if (result) { throw invalid_argument("need a contiguous buffer to read"); + } char *dst = NULL; - PEP_STATUS status = PER_to_XER_Sync_msg((char *) src.buf, src.len, &dst); + PEP_STATUS status = PER_to_XER_Sync_msg((char *)src.buf, src.len, &dst); PyBuffer_Release(&src); _throw_status(status); @@ -85,7 +104,8 @@ namespace pEp { 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; size_t size = 0; PEP_STATUS status = XER_to_PER_Sync_msg(text.c_str(), &data, &size); @@ -93,20 +113,23 @@ namespace pEp { PyObject *ba = PyBytes_FromStringAndSize(data, size); free(data); - if (!ba) + if (!ba) { throw bad_alloc(); + } 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; int result = PyObject_GetBuffer(buffer.ptr(), &src, PyBUF_CONTIG_RO); - if (result) + if (result) { throw invalid_argument("need a contiguous buffer to read"); + } char *dst = NULL; - PEP_STATUS status = PER_to_XER_Distribution_msg((char *) src.buf, src.len, &dst); + PEP_STATUS status = PER_to_XER_Distribution_msg((char *)src.buf, src.len, &dst); PyBuffer_Release(&src); _throw_status(status); @@ -115,7 +138,8 @@ namespace pEp { 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; size_t size = 0; 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); free(data); - if (!ba) + if (!ba) { throw bad_alloc(); - + } return boost::python::make_tuple(object(handle<>(ba)), 0); } - object sync_search(string name) { + object sync_search(string name) + { if (name != "pep.sync") { return object(); } else { @@ -143,7 +168,8 @@ namespace pEp { } } - object distribution_search(string name) { + object distribution_search(string name) + { if (name != "pep.distribution") { return object(); } else { @@ -158,4 +184,4 @@ namespace pEp { } } // namespace PythonAdapter -} // namespace pEp { +} // namespace pEp diff --git a/src/pEp/_pEp/message_api.hh b/src/pEp/_pEp/message_api.hh index 2d153b6..d4b672d 100644 --- a/src/pEp/_pEp/message_api.hh +++ b/src/pEp/_pEp/message_api.hh @@ -10,11 +10,10 @@ namespace pEp { namespace PythonAdapter { Message encrypt_message( - Message src, - boost::python::list extra = boost::python::list(), - int enc_format = 4, - int flags = 0 - ); + Message src, + boost::python::list extra = boost::python::list(), + int enc_format = 4, + int flags = 0); boost::python::tuple decrypt_message(Message src, int flags = 0); @@ -27,4 +26,4 @@ namespace pEp { } /* namespace PythonAdapter */ } /* namespace pEp */ -#endif /* MESSAGE_API_HH */ \ No newline at end of file +#endif /* MESSAGE_API_HH */ diff --git a/src/pEp/_pEp/pEpmodule.cc b/src/pEp/_pEp/pEpmodule.cc index a13cc92..86a8233 100644 --- a/src/pEp/_pEp/pEpmodule.cc +++ b/src/pEp/_pEp/pEpmodule.cc @@ -33,58 +33,71 @@ namespace pEp { static const char *version_string = "p≡p Python adapter version 0.3"; - void _init_callbackdispatcher() { + void _init_callbackdispatcher() + { pEpLog("called"); callback_dispatcher.add(_messageToSend, _notifyHandshake, nullptr, nullptr); } - void _init_session(bool mode_async) { + void _init_session(bool mode_async) + { pEpLog("called"); - if(mode_async) { - Adapter::session.initialize(pEp::Adapter::SyncModes::Async, true); - } else { - Adapter::session.initialize(pEp::Adapter::SyncModes::Sync, true); - } + if (mode_async) { + Adapter::session.initialize(pEp::Adapter::SyncModes::Async, true); + } else { + Adapter::session.initialize(pEp::Adapter::SyncModes::Sync, true); + } } - void config_passive_mode(bool enable) { + void config_passive_mode(bool 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); } - void key_reset_user(string user_id, string fpr) { - if (user_id == "") + 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); + PEP_STATUS status = ::key_reset_user( + Adapter::session(), + user_id.c_str(), + fpr != "" ? fpr.c_str() : nullptr); _throw_status(status); } - void key_reset_all_own_keys() { + 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"; + 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) + void _throw_status(PEP_STATUS status) + { + if (status == PEP_STATUS_OK) { return; - if (status >= 0x400 && status <= 0x4ff) + } + if (status >= 0x400 && status <= 0x4ff) { return; - if (status == PEP_OUT_OF_MEMORY) + } + if (status == PEP_OUT_OF_MEMORY) { throw bad_alloc(); - if (status == PEP_ILLEGAL_VALUE) + } + 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; @@ -95,7 +108,8 @@ namespace pEp { } // TODO: GIL handling isnt really required here, i think - PEP_STATUS _messageToSend(::message *msg) { + PEP_STATUS _messageToSend(::message *msg) + { pEpLog("called"); try { PyGILState_STATE gil = PyGILState_Ensure(); @@ -105,13 +119,15 @@ namespace pEp { call(funcref.ptr(), Message(msg)); PyGILState_Release(gil); pEpLog("GIL released"); - } catch (exception &e) {} + } 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) { + PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) + { pEpLog("called"); try { PyGILState_STATE gil = PyGILState_Ensure(); @@ -121,12 +137,14 @@ namespace pEp { call(funcref.ptr(), Identity(me), Identity(partner), signal); PyGILState_Release(gil); pEpLog("GIL released"); - } catch (exception &e) {} + } catch (exception &e) { + } return PEP_STATUS_OK; } - bool _do_protocol_step() { + bool _do_protocol_step() + { pEpLog("called"); SYNC_EVENT event = Adapter::_retrieve_next_sync_event(nullptr, 0); if (event != NULL) { @@ -138,41 +156,49 @@ namespace pEp { } } - void _free_session() { + void _free_session() + { ::unregister_sync_callbacks(Adapter::session()); Adapter::session.release(); } // TODO: Integrate this (currently SEGFAULTING) - void _notifyHandshake_sync_start() { + 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() { + void _notifyHandshake_sync_stop() + { pEpLog("all targets signal: 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); } - void leave_device_group() { + void leave_device_group() + { ::leave_device_group(Adapter::session()); } - void disable_all_sync_channels() { + void disable_all_sync_channels() + { ::disable_all_sync_channels(Adapter::session()); } - void deliverHandshakeResult(int result, object identities) { + 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) + if (!shared_identities) { throw bad_alloc(); + } try { identity_list *si = shared_identities; @@ -182,353 +208,454 @@ namespace pEp { if (!si) throw bad_alloc(); } - } - catch (exception &ex) { + } catch (exception &ex) { free_identity_list(shared_identities); 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); _throw_status(status); } - BOOST_PYTHON_MODULE(_pEp) { - def("_init_callbackdispatcher", _init_callbackdispatcher); + BOOST_PYTHON_MODULE(_pEp) + { + def("_init_callbackdispatcher", _init_callbackdispatcher); - docstring_options doc_options(true, false, false); - boost::locale::generator gen; - std::locale::global(gen("")); + 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(); + 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("set_debug_log_enabled", &Adapter::pEpLog::set_enabled, "Switch debug logging on/off"); - def("_init_session", _init_session); - def("_free_session", _free_session); - 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("_init_session", _init_session); + def("_free_session", _free_session); + 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("passive_mode", config_passive_mode, - "do not attach pub keys to all messages"); + def("passive_mode", config_passive_mode, "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"); - def("key_reset", key_reset_user, + def("key_reset", + key_reset_user, "reset the default database status for the user / keypair provided\n" "This will effectively perform key_reset on each identity\n" "associated with the key and user_id, if a key is provided, and for\n" "each key (and all of their identities) if an fpr is not."); - def("key_reset_all_own_keys", key_reset_all_own_keys, + 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(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()) - .def(boost::python::init()) - .def(boost::python::init()) - .def(boost::python::init()) - .def(boost::python::init()) - .def(boost::python::init()) - .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_("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()) - .def(boost::python::init()) - .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(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()) - .def(boost::python::init()) - .def(boost::python::init()) - .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, + auto + identity_class = class_( + "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()) + .def(boost::python::init()) + .def(boost::python::init()) + .def(boost::python::init()) + .def(boost::python::init()) + .def(boost::python::init()) + .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_( + "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( + args("data", "mime_type", "filename"))) + .def(boost::python::init()) + .def(boost::python::init()) + .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(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()) + .def(boost::python::init()) + .def(boost::python::init()) + .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, + "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, + "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" - ); + "mark a key as trusted with a person\n"); - enum_("identity_flags") + enum_("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, + def("set_identity_flags", + &set_identity_flags, "set_identity_flags(ident, flags)\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" "\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" "\n" "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" "\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" "\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" "\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" "\n" "mark a key as an own key, and make it the default key\n" @@ -540,12 +667,11 @@ namespace pEp { "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" - ); + "me->fpr will be ignored and replaced by fpr\n"); - // message API + // message API - enum_("rating") + enum_("rating") .value("_undefined", PEP_rating_undefined) .value("cannot_decrypt", PEP_rating_cannot_decrypt) .value("have_no_key", PEP_rating_have_no_key) @@ -559,36 +685,37 @@ namespace pEp { .value("b0rken", PEP_rating_b0rken) .value("under_attack", PEP_rating_under_attack); - enum_("colorvalue") + enum_("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, + 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, + "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, + "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, + "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 + // Sync API - enum_("sync_handshake_signal") + enum_("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) @@ -600,33 +727,37 @@ namespace pEp { .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(), + 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" - ); + "call to deliver the handshake result of the handshake dialog"); - def("debug_color", &debug_color, - "for debug builds set ANSI color value"); + def("debug_color", &debug_color, "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" "\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" "\n" - "Disable sync for all identities\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)); + // codecs + call( + ((object)(import("codecs").attr("register"))).ptr(), + make_function(sync_search)); + call( + ((object)(import("codecs").attr("register"))).ptr(), + make_function(distribution_search)); } } // namespace PythonAdapter diff --git a/src/pEp/_pEp/str_attr.cc b/src/pEp/_pEp/str_attr.cc index 74f44ee..59957e3 100644 --- a/src/pEp/_pEp/str_attr.cc +++ b/src/pEp/_pEp/str_attr.cc @@ -15,44 +15,54 @@ namespace pEp { using namespace boost::python; using namespace boost::locale; - object repr(object s) { + object repr(object s) + { return s.attr("__repr__")(); } - string repr(string s) { + string repr(string s) + { str _s = s.c_str(); object _r = _s.attr("__repr__")(); string r = extract(_r); return r; } - string str_attr(char *&str) { - if (!str) + string str_attr(char *&str) + { + if (!str) { return string(""); + } return string(str); } - void str_attr(char *&str, string value) { + void str_attr(char *&str, string value) + { string normalized = normalize(value, norm_nfc); free(str); str = strdup(normalized.c_str()); - if (!str) + if (!str) { throw bad_alloc(); + } } - time_t timestamp_attr(timestamp *&ts) { - if (!ts) + time_t timestamp_attr(timestamp *&ts) + { + if (!ts) { return 0; + } return timegm(ts); } - void timestamp_attr(timestamp *&ts, time_t value) { + void timestamp_attr(timestamp *&ts, time_t value) + { free_timestamp(ts); ts = new_timestamp(value); } - boost::python::list strlist_attr(stringlist_t *&sl) { + boost::python::list strlist_attr(stringlist_t *&sl) + { boost::python::list result; for (stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { @@ -63,14 +73,16 @@ namespace pEp { 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); - if (!_sl) + if (!_sl) { throw bad_alloc(); + } stringlist_t *_s = _sl; for (int i = 0; i < len(value); i++) { - extract extract_string(value[i]); + extract extract_string(value[i]); if (!extract_string.check()) { free_stringlist(_sl); } @@ -87,11 +99,11 @@ namespace pEp { sl = _sl; } - dict strdict_attr(stringpair_list_t *&spl) { + dict strdict_attr(stringpair_list_t *&spl) + { dict result; - for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = - _spl->next) { + for (stringpair_list_t *_spl = spl; _spl && _spl->value; _spl = _spl->next) { stringpair_t *p = _spl->value; if (p->key && p->value) { string key(p->key); @@ -104,18 +116,21 @@ namespace pEp { 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); - if (!_spl) + if (!_spl) { throw bad_alloc(); + } stringpair_list_t *_s = _spl; for (int i = 0; i < len(value); i++) { - extract extract_key(value.keys()[i]); - extract extract_value(value.values()[i]); + extract extract_key(value.keys()[i]); + extract extract_value(value.values()[i]); - if (!(extract_key.check() && extract_value.check())) + if (!(extract_key.check() && extract_value.check())) { free_stringpair_list(_spl); + } string key = extract_key(); key = normalize(key, norm_nfc); @@ -137,16 +152,19 @@ namespace pEp { spl = _spl; } - stringlist_t *to_stringlist(boost::python::list l) { + stringlist_t *to_stringlist(boost::python::list l) + { stringlist_t *result = new_stringlist(NULL); - if (!result) + if (!result) { throw bad_alloc(); + } stringlist_t *_s = result; for (int i = 0; i < len(l); i++) { - extract extract_string(l[i]); - if (!extract_string.check()) + extract extract_string(l[i]); + if (!extract_string.check()) { free_stringlist(result); + } string s = extract_string(); _s = stringlist_add(_s, s.c_str()); if (!_s) { @@ -158,7 +176,8 @@ namespace pEp { return result; } - boost::python::list from_stringlist(const stringlist_t *sl) { + boost::python::list from_stringlist(const stringlist_t *sl) + { boost::python::list result; for (const stringlist_t *_sl = sl; _sl && _sl->value; _sl = _sl->next) { string s = _sl->value; @@ -168,5 +187,4 @@ namespace pEp { } } // namespace PythonAdapter -} // namespace pEp { - +} // namespace pEp diff --git a/src/pEp/_pEp/str_attr.hh b/src/pEp/_pEp/str_attr.hh index 5e084ad..5167aab 100644 --- a/src/pEp/_pEp/str_attr.hh +++ b/src/pEp/_pEp/str_attr.hh @@ -15,30 +15,30 @@ #include namespace pEp { -namespace PythonAdapter { -using std::string; -using boost::python::object; -using boost::python::dict; + namespace PythonAdapter { + using boost::python::dict; + using boost::python::object; + using std::string; -object repr(object s); -string repr(string s); + object repr(object s); + string repr(string s); -string str_attr(char *&str); -void str_attr(char *&str, string value); + string str_attr(char *&str); + void str_attr(char *&str, string value); -time_t timestamp_attr(timestamp *&ts); -void timestamp_attr(timestamp *&ts, time_t value); + time_t timestamp_attr(timestamp *&ts); + void timestamp_attr(timestamp *&ts, time_t value); -boost::python::list strlist_attr(stringlist_t *&sl); -void strlist_attr(stringlist_t *&sl, boost::python::list value); + boost::python::list strlist_attr(stringlist_t *&sl); + void strlist_attr(stringlist_t *&sl, boost::python::list value); -dict strdict_attr(stringpair_list_t *&spl); -void strdict_attr(stringpair_list_t *&spl, dict value); + dict strdict_attr(stringpair_list_t *&spl); + void strdict_attr(stringpair_list_t *&spl, dict value); -stringlist_t *to_stringlist(boost::python::list l); -boost::python::list from_stringlist(const stringlist_t *sl); + stringlist_t *to_stringlist(boost::python::list l); + boost::python::list from_stringlist(const stringlist_t *sl); -} /* namespace PythonAdapter */ + } /* namespace PythonAdapter */ } /* namespace pEp */ -#endif /* STR_ATTR_HH */ \ No newline at end of file +#endif /* STR_ATTR_HH */