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

Mark all symbols from the pEpEngine with explicit global namespace. (e.g: ::pEp_stuff).

REWORK
heck 5 years ago
parent
688fff5667
commit
63e830040c
14 changed files with 241 additions and 241 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. 32
      src/pEp/_pEp/basic_api.cc
  2. 5
      src/pEp/_pEp/basic_api.hh
  3. 65
      src/pEp/_pEp/identity.cc
  4. 28
      src/pEp/_pEp/identity.hh
  5. 76
      src/pEp/_pEp/message.cc
  6. 24
      src/pEp/_pEp/message.hh
  7. 49
      src/pEp/_pEp/message_api.cc
  8. 2
      src/pEp/_pEp/message_api.hh
  9. 115
      src/pEp/_pEp/pEpmodule.cc
  10. 6
      src/pEp/_pEp/pEpmodule.hh
  11. 40
      src/pEp/_pEp/str_attr.cc
  12. 16
      src/pEp/_pEp/str_attr.hh
  13. 12
      src/pEp/_pEp/user_interface.cc
  14. 2
      src/pEp/_pEp/user_interface.hh

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

@ -24,7 +24,7 @@ namespace pEp {
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);
} }
@ -37,7 +37,7 @@ namespace pEp {
if (ident.user_id() == "") if (ident.user_id() == "")
ident.user_id(ident.address()); ident.user_id(ident.address());
PEP_STATUS status = myself(Adapter::session(), ident); ::PEP_STATUS status = ::myself(Adapter::session(), ident);
_throw_status(status); _throw_status(status);
} }
@ -50,7 +50,7 @@ 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(Adapter::session(), me, partner,
lang.c_str(), &words, &size, full); lang.c_str(), &words, &size, full);
_throw_status(status); _throw_status(status);
return words; return words;
@ -62,27 +62,27 @@ namespace pEp {
if (ident.user_id() == "") if (ident.user_id() == "")
throw invalid_argument("user_id must be provided"); throw invalid_argument("user_id must be provided");
PEP_STATUS status = trust_personal_key(Adapter::session(), ident); ::PEP_STATUS status = ::trust_personal_key(Adapter::session(), ident);
_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() == "")
throw invalid_argument("user_id needed"); throw invalid_argument("user_id needed");
PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags); ::PEP_STATUS status = ::set_identity_flags(Adapter::session(), ident, flags);
_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() == "")
throw invalid_argument("user_id needed"); throw invalid_argument("user_id needed");
PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags); ::PEP_STATUS status = ::unset_identity_flags(Adapter::session(), ident, flags);
_throw_status(status); _throw_status(status);
} }
@ -94,33 +94,33 @@ namespace pEp {
if (ident.user_id() == "") if (ident.user_id() == "")
throw invalid_argument("user_id needed"); throw invalid_argument("user_id needed");
PEP_STATUS status = key_reset_trust(Adapter::session(), ident); ::PEP_STATUS status = ::key_reset_trust(Adapter::session(), ident);
_throw_status(status); _throw_status(status);
} }
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);
auto result = boost::python::list(); auto result = boost::python::list();
for (::identity_list *il = private_keys; il && il->ident; il = il->next) { for (::identity_list *il = private_keys; il && il->ident; il = il->next) {
::pEp_identity *ident = ::identity_dup(il->ident); ::pEp_identity *ident = ::identity_dup(il->ident);
if (!ident) { if (!ident) {
free_identity_list(private_keys); ::free_identity_list(private_keys);
throw bad_alloc(); throw bad_alloc();
} }
result.append(Identity(ident)); result.append(Identity(ident));
} }
free_identity_list(private_keys); ::free_identity_list(private_keys);
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;
status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size); status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
@ -130,7 +130,7 @@ namespace pEp {
} }
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;
status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size); status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
@ -151,7 +151,7 @@ namespace pEp {
const char *fpr_c = fpr.c_str(); const char *fpr_c = fpr.c_str();
PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c); ::PEP_STATUS status = ::set_own_key(Adapter::session(), ident, fpr_c);
_throw_status(status); _throw_status(status);
} }

5
src/pEp/_pEp/basic_api.hh
View File

@ -5,6 +5,7 @@
#define BASIC_API_HH #define BASIC_API_HH
#include "pEpmodule.hh" #include "pEpmodule.hh"
#include "identity.hh"
namespace pEp { namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
@ -17,9 +18,9 @@ namespace pEp {
void trust_personal_key(Identity ident); void trust_personal_key(Identity ident);
void set_identity_flags(Identity ident, identity_flags_t flags); void set_identity_flags(Identity ident, ::identity_flags_t flags);
void unset_identity_flags(Identity ident, identity_flags_t flags); void unset_identity_flags(Identity ident, ::identity_flags_t flags);
void key_reset_trust(Identity ident); void key_reset_trust(Identity ident);

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

@ -22,13 +22,13 @@ namespace pEp {
using namespace boost::python; using namespace boost::python;
Identity::Identity(string address, string username, string user_id, Identity::Identity(string address, string username, string user_id,
string fpr, int comm_type, string lang, identity_flags_t flags) string fpr, int comm_type, string lang, ::identity_flags_t flags)
: _ident(new_identity(address.c_str(), fpr.c_str(), user_id.c_str(), : _ident(::new_identity(address.c_str(), fpr.c_str(), user_id.c_str(),
username.c_str()), &::free_identity) { username.c_str()), &::free_identity) {
if (!_ident) 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);
} }
@ -37,7 +37,7 @@ namespace pEp {
} }
Identity::Identity(pEp_identity *ident) Identity::Identity(::pEp_identity *ident)
: _ident(ident, &::free_identity) { : _ident(ident, &::free_identity) {
} }
@ -46,11 +46,11 @@ namespace pEp {
} }
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();
} }
@ -111,19 +111,19 @@ namespace pEp {
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);
_throw_status(status); _throw_status(status);
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();
@ -139,30 +139,29 @@ namespace pEp {
} }
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);
} }
@ -183,11 +182,11 @@ namespace pEp {
// pEp::PythonAdapter::myself(*this); // pEp::PythonAdapter::myself(*this);
// } // }
Identity identity_attr(pEp_identity *&ident) { Identity identity_attr(::pEp_identity *&ident) {
if (!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();
@ -195,22 +194,22 @@ namespace pEp {
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)));
@ -219,25 +218,25 @@ namespace pEp {
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++) {
extract < Identity & > extract_identity(value[i]); extract < Identity & > extract_identity(value[i]);
if (!extract_identity.check()) { if (!extract_identity.check()) {
free_identity_list(_il); ::free_identity_list(_il);
} }
pEp_identity *_ident = extract_identity(); ::pEp_identity *_ident = extract_identity();
pEp_identity *_dup = ::identity_dup(_ident); ::pEp_identity *_dup = ::identity_dup(_ident);
if (!_dup) { if (!_dup) {
::free_identity_list(_il); ::free_identity_list(_il);
throw bad_alloc(); throw bad_alloc();
} }
PEP_STATUS status = ::update_identity(Adapter::session(), _dup); ::PEP_STATUS status = ::update_identity(Adapter::session(), _dup);
if (status != PEP_STATUS_OK) { if (status != ::PEP_STATUS_OK) {
::free_identity_list(_il); ::free_identity_list(_il);
_throw_status(status); _throw_status(status);
} }

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

@ -30,22 +30,22 @@ namespace pEp {
class Identity { class Identity {
protected: protected:
shared_ptr <pEp_identity> _ident; shared_ptr <::pEp_identity> _ident;
public: public:
Identity(string address = "", string username = "", Identity(string address = "", string username = "",
string user_id = "", string fpr = "", int comm_type = 0, string user_id = "", string fpr = "", int comm_type = 0,
string lang = "", identity_flags_t flags = 0); string lang = "", ::identity_flags_t flags = 0);
Identity(const Identity &second); Identity(const Identity &second);
Identity(pEp_identity *ident); Identity(::pEp_identity *ident);
virtual ~Identity(); virtual ~Identity();
operator pEp_identity *(); operator ::pEp_identity *();
operator const pEp_identity *() const; operator const ::pEp_identity *() const;
string _repr(); string _repr();
@ -67,21 +67,21 @@ namespace pEp {
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();
PEP_color color(); ::PEP_color color();
Identity copy(); Identity copy();
@ -107,13 +107,13 @@ namespace pEp {
// virtual void update(); // 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);
boost::python::list identitylist_attr(identity_list *&il); boost::python::list identitylist_attr(::identity_list *&il);
void identitylist_attr(identity_list *&il, boost::python::list value); void identitylist_attr(::identity_list *&il, boost::python::list value);
} // namespace PythonAdapter } // namespace PythonAdapter
} // namespace pEp } // namespace pEp

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

@ -23,14 +23,14 @@ 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)), part_of_chain(false) {
if (!_bl) if (!_bl)
throw bad_alloc(); throw bad_alloc();
@ -89,7 +89,7 @@ namespace pEp {
} }
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);
@ -130,7 +130,7 @@ 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();
@ -138,35 +138,35 @@ namespace pEp {
_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;
case PEP_BUFFER_TOO_SMALL: case ::PEP_BUFFER_TOO_SMALL:
throw runtime_error("mime_decode_message: buffer too small"); throw runtime_error("mime_decode_message: buffer too small");
case PEP_CANNOT_CREATE_TEMP_FILE: case ::PEP_CANNOT_CREATE_TEMP_FILE:
throw runtime_error("mime_decode_message: cannot create temp file"); throw runtime_error("mime_decode_message: cannot create temp file");
case PEP_OUT_OF_MEMORY: case ::PEP_OUT_OF_MEMORY:
throw bad_alloc(); throw bad_alloc();
default: default:
@ -182,8 +182,8 @@ namespace pEp {
throw bad_alloc(); throw bad_alloc();
} }
Message::Message(message *msg) Message::Message(::message *msg)
: _msg(::message_dup(msg), &free_message) { : _msg(::message_dup(msg), &::free_message) {
} }
@ -191,11 +191,11 @@ namespace pEp {
} }
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();
} }
@ -206,20 +206,20 @@ namespace pEp {
char *mimetext; char *mimetext;
string result; string result;
PEP_STATUS status = mime_encode_message(*this, false, &mimetext, false); ::PEP_STATUS status = ::mime_encode_message(*this, false, &mimetext, false);
switch (status) { switch (status) {
case PEP_STATUS_OK: case ::PEP_STATUS_OK:
result = mimetext; result = mimetext;
free(mimetext); free(mimetext);
break; break;
case PEP_BUFFER_TOO_SMALL: case ::PEP_BUFFER_TOO_SMALL:
throw runtime_error("mime_encode_message: buffer too small"); throw runtime_error("mime_encode_message: buffer too small");
case PEP_CANNOT_CREATE_TEMP_FILE: case ::PEP_CANNOT_CREATE_TEMP_FILE:
throw runtime_error("mime_encode_message: cannot create temp file"); throw runtime_error("mime_encode_message: cannot create temp file");
case PEP_OUT_OF_MEMORY: case ::PEP_OUT_OF_MEMORY:
throw bad_alloc(); throw bad_alloc();
default: default:
@ -240,7 +240,7 @@ namespace pEp {
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));
} }
@ -249,11 +249,11 @@ namespace pEp {
} }
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(_l, blob._bl->value, blob._bl->size,
@ -262,7 +262,7 @@ namespace pEp {
for (_l = bl; _l && _l->value;) { for (_l = bl; _l && _l->value;) {
free(_l->mime_type); free(_l->mime_type);
free(_l->filename); free(_l->filename);
bloblist_t *_ll = _l; ::bloblist_t *_ll = _l;
_l = _l->next; _l = _l->next;
free(_ll); free(_ll);
} }
@ -286,12 +286,12 @@ namespace pEp {
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);
} }
@ -299,8 +299,8 @@ namespace pEp {
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() == "")
@ -311,22 +311,22 @@ namespace pEp {
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);
PEP_rating rating = PEP_rating_undefined; ::PEP_rating rating = ::PEP_rating_undefined;
status = outgoing_message_rating(Adapter::session(), *this, &rating); status = outgoing_message_rating(Adapter::session(), *this, &rating);
_throw_status(status); _throw_status(status);
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);
@ -341,14 +341,14 @@ namespace pEp {
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);
} }
@ -362,7 +362,7 @@ namespace pEp {
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()));

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

@ -34,11 +34,11 @@ namespace pEp {
// one depending on part_of_chain // one depending on part_of_chain
class Blob { class Blob {
bloblist_t *_bl; ::bloblist_t *_bl;
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 = "");
@ -71,27 +71,27 @@ namespace pEp {
static int getbuffer(PyObject *self, Py_buffer *view, int flags); static int getbuffer(PyObject *self, Py_buffer *view, int flags);
}; };
Message(int dir = PEP_dir_outgoing, Identity *from = NULL); Message(int dir = ::PEP_dir_outgoing, Identity *from = NULL);
Message(string mimetext); Message(string mimetext);
Message(const Message &second); Message(const Message &second);
Message(message *msg); Message(::message *msg);
~Message(); ~Message();
operator message *(); operator ::message *();
operator const message *() const; operator const ::message *() const;
string _str(); string _str();
string _repr(); string _repr();
PEP_msg_direction dir() { return _msg->dir; } ::PEP_msg_direction dir() { return _msg->dir; }
void dir(PEP_msg_direction value) { _msg->dir = value; } void dir(::PEP_msg_direction value) { _msg->dir = value; }
string id() { return str_attr(_msg->id); } string id() { return str_attr(_msg->id); }
@ -165,9 +165,9 @@ namespace pEp {
void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); } void opt_fields(dict value) { return strdict_attr(_msg->opt_fields, value); }
PEP_enc_format enc_format() { return _msg->enc_format; } ::PEP_enc_format enc_format() { return _msg->enc_format; }
void enc_format(PEP_enc_format value) { _msg->enc_format = value; } void enc_format(::PEP_enc_format value) { _msg->enc_format = value; }
Message encrypt(); Message encrypt();
@ -175,9 +175,9 @@ namespace pEp {
boost::python::tuple decrypt(int flags = 0); boost::python::tuple decrypt(int flags = 0);
PEP_rating outgoing_rating(); ::PEP_rating outgoing_rating();
PEP_color outgoing_color(); ::PEP_color outgoing_color();
Message deepcopy(dict &memo); Message deepcopy(dict &memo);

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

@ -16,7 +16,7 @@ namespace pEp {
namespace PythonAdapter { namespace PythonAdapter {
using namespace std; using namespace std;
using namespace boost::python; using namespace boost::python;
// namespace bp = 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() == "")
@ -27,56 +27,57 @@ namespace pEp {
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;
PEP_encrypt_flags_t _flags = (PEP_encrypt_flags_t) flags; ::PEP_encrypt_flags_t _flags = (::PEP_encrypt_flags_t) flags;
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(Adapter::session(), _src, _extra, &_dst, _enc_format, _flags);
_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(Adapter::session(), _src, &_dst, &_keylist,
&_rating, &_flags); &_rating, &_flags);
_throw_status(status); _throw_status(status);
boost::python::list keylist; boost::python::list keylist;
if (_keylist) { if (_keylist) {
keylist = from_stringlist(_keylist); keylist = from_stringlist(_keylist);
free_stringlist(_keylist); ::free_stringlist(_keylist);
} }
Message dst = _dst ? Message(_dst) : Message(src); Message dst = _dst ? Message(_dst) : Message(src);
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);
PyBuffer_Release(&src); PyBuffer_Release(&src);
_throw_status(status); _throw_status(status);
@ -88,7 +89,7 @@ namespace pEp {
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);
_throw_status(status); _throw_status(status);
PyObject *ba = PyBytes_FromStringAndSize(data, size); PyObject *ba = PyBytes_FromStringAndSize(data, size);
@ -106,7 +107,7 @@ namespace pEp {
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);
PyBuffer_Release(&src); PyBuffer_Release(&src);
_throw_status(status); _throw_status(status);
@ -118,7 +119,7 @@ namespace pEp {
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);
_throw_status(status); _throw_status(status);
PyObject *ba = PyBytes_FromStringAndSize(data, size); PyObject *ba = PyBytes_FromStringAndSize(data, size);

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

@ -18,7 +18,7 @@ namespace pEp {
boost::python::tuple decrypt_message(Message src, int flags = 0); boost::python::tuple decrypt_message(Message src, int flags = 0);
PEP_color _color(int rating); ::PEP_color _color(int rating);
object sync_search(string name); object sync_search(string name);

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

@ -37,7 +37,7 @@ namespace pEp {
pEpLog("called"); pEpLog("called");
} }
// hidden init function, wrapped by hello_world.init() // hidden init function, wrapped by hello_world.init()
void _init_after_main_module() { void _init_after_main_module() {
pEpLog("called"); pEpLog("called");
callback_dispatcher.add(_messageToSend, notifyHandshake, nullptr, nullptr); callback_dispatcher.add(_messageToSend, notifyHandshake, nullptr, nullptr);
@ -57,8 +57,7 @@ namespace pEp {
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(Adapter::session(), user_id.c_str(), fpr != "" ? fpr.c_str() : nullptr);
user_id.c_str(), fpr != "" ? fpr.c_str() : nullptr);
_throw_status(status); _throw_status(status);
} }
@ -67,7 +66,7 @@ namespace pEp {
} }
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);
} }
@ -77,14 +76,14 @@ namespace pEp {
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") {
@ -96,7 +95,7 @@ namespace pEp {
} }
} }
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();
@ -108,10 +107,10 @@ namespace pEp {
pEpLog("GIL released"); pEpLog("GIL released");
} catch (exception &e) {} } catch (exception &e) {}
return PEP_STATUS_OK; return ::PEP_STATUS_OK;
} }
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();
@ -123,7 +122,7 @@ namespace pEp {
pEpLog("GIL released"); pEpLog("GIL released");
} catch (exception &e) {} } catch (exception &e) {}
return PEP_STATUS_OK; return ::PEP_STATUS_OK;
} }
@ -154,26 +153,26 @@ namespace pEp {
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;
for (int i = 0; i < boost::python::len(identities); ++i) { for (int i = 0; i < boost::python::len(identities); ++i) {
Identity ident = extract<Identity>(identities[i]); Identity ident = extract<Identity>(identities[i]);
si = identity_list_add(si, ident); si = ::identity_list_add(si, ident);
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);
} }
@ -191,10 +190,10 @@ namespace pEp {
scope().attr("about") = about(); scope().attr("about") = about();
scope().attr("per_user_directory") = per_user_directory(); scope().attr("per_user_directory") = ::per_user_directory();
scope().attr("per_machine_directory") = per_machine_directory(); scope().attr("per_machine_directory") = ::per_machine_directory();
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("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");
@ -287,13 +286,13 @@ namespace pEp {
.add_property("comm_type", (int(Identity::*)()) .add_property("comm_type", (int(Identity::*)())
(PEP_comm_type(Identity::*)()) &Identity::comm_type, (PEP_comm_type(Identity::*)()) &Identity::comm_type,
(void(Identity::*)(int)) (void(Identity::*)(int))
(void(Identity::*)(PEP_comm_type)) &Identity::comm_type, (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("color", &Identity::color, "color of Identity as PEP_color")
@ -419,7 +418,7 @@ namespace pEp {
.add_property("enc_format", (int(Message::*)()) .add_property("enc_format", (int(Message::*)())
(PEP_enc_format(Message::*)()) &Message::enc_format, (PEP_enc_format(Message::*)()) &Message::enc_format,
(void(Message::*)(int)) (void(Message::*)(int))
(void(Message::*)(PEP_enc_format)) &Message::enc_format, (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("encrypt", (Message(Message::*)(boost::python::list))&Message::_encrypt)
@ -470,10 +469,10 @@ namespace pEp {
"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"
@ -529,25 +528,25 @@ namespace pEp {
// message API // message API
enum_<PEP_rating>("rating") enum_<::PEP_rating>("rating")
.value("_undefined", PEP_rating_undefined) .value("_undefined", ::PEP_rating_undefined)
.value("cannot_decrypt", PEP_rating_cannot_decrypt) .value("cannot_decrypt", ::PEP_rating_cannot_decrypt)
.value("have_no_key", PEP_rating_have_no_key) .value("have_no_key", ::PEP_rating_have_no_key)
.value("unencrypted", PEP_rating_unencrypted) .value("unencrypted", ::PEP_rating_unencrypted)
.value("unreliable", PEP_rating_unreliable) .value("unreliable", ::PEP_rating_unreliable)
.value("reliable", PEP_rating_reliable) .value("reliable", ::PEP_rating_reliable)
.value("trusted", PEP_rating_trusted) .value("trusted", ::PEP_rating_trusted)
.value("trusted_and_anonymized", PEP_rating_trusted_and_anonymized) .value("trusted_and_anonymized", ::PEP_rating_trusted_and_anonymized)
.value("fully_anonymous", PEP_rating_fully_anonymous) .value("fully_anonymous", ::PEP_rating_fully_anonymous)
.value("mistrust", PEP_rating_mistrust) .value("mistrust", ::PEP_rating_mistrust)
.value("b0rken", PEP_rating_b0rken) .value("b0rken", ::PEP_rating_b0rken)
.value("under_attack", PEP_rating_under_attack); .value("under_attack", ::PEP_rating_under_attack);
enum_<PEP_color>("colorvalue") enum_<::PEP_color>("colorvalue")
.value("no_color", PEP_color_no_color) .value("no_color", ::PEP_color_no_color)
.value("yellow", PEP_color_yellow) .value("yellow", ::PEP_color_yellow)
.value("green", PEP_color_green) .value("green", ::PEP_color_green)
.value("red", PEP_color_red); .value("red", ::PEP_color_red);
def("incoming_message", &incoming_message, def("incoming_message", &incoming_message,
@ -572,17 +571,17 @@ namespace pEp {
// Sync API // Sync API
enum_<sync_handshake_signal>("sync_handshake_signal") enum_<::sync_handshake_signal>("sync_handshake_signal")
.value("SYNC_NOTIFY_UNDEFINED", SYNC_NOTIFY_UNDEFINED) .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_OUR_DEVICE", ::SYNC_NOTIFY_INIT_ADD_OUR_DEVICE)
.value("SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE", SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE) .value("SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE", ::SYNC_NOTIFY_INIT_ADD_OTHER_DEVICE)
.value("SYNC_NOTIFY_INIT_FORM_GROUP", SYNC_NOTIFY_INIT_FORM_GROUP) .value("SYNC_NOTIFY_INIT_FORM_GROUP", ::SYNC_NOTIFY_INIT_FORM_GROUP)
.value("SYNC_NOTIFY_TIMEOUT", SYNC_NOTIFY_TIMEOUT) .value("SYNC_NOTIFY_TIMEOUT", ::SYNC_NOTIFY_TIMEOUT)
.value("SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED", SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED) .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED", ::SYNC_NOTIFY_ACCEPTED_DEVICE_ADDED)
.value("SYNC_NOTIFY_ACCEPTED_GROUP_CREATED", SYNC_NOTIFY_ACCEPTED_GROUP_CREATED) .value("SYNC_NOTIFY_ACCEPTED_GROUP_CREATED", ::SYNC_NOTIFY_ACCEPTED_GROUP_CREATED)
.value("SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED", SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED) .value("SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED", ::SYNC_NOTIFY_ACCEPTED_DEVICE_ACCEPTED)
.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);
// auto user_interface_class = class_<UserInterface, UserInterface_callback, boost::noncopyable>( // auto user_interface_class = class_<UserInterface, UserInterface_callback, boost::noncopyable>(
// "UserInterface", // "UserInterface",

6
src/pEp/_pEp/pEpmodule.hh
View File

@ -23,11 +23,11 @@ namespace pEp {
void key_reset_all_own_keys(); void key_reset_all_own_keys();
void _throw_status(PEP_STATUS status); void _throw_status(::PEP_STATUS status);
PEP_STATUS _messageToSend(::message *msg); ::PEP_STATUS _messageToSend(::message *msg);
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);
} /* namespace PythonAdapter */ } /* namespace PythonAdapter */
} /* namespace pEp */ } /* namespace pEp */

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

@ -40,22 +40,22 @@ namespace pEp {
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) {
string s(_sl->value); string s(_sl->value);
result.append(object(s)); result.append(object(s));
} }
@ -63,12 +63,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++) {
extract <string> extract_string(value[i]); extract <string> extract_string(value[i]);
if (!extract_string.check()) { if (!extract_string.check()) {
@ -87,12 +87,12 @@ 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);
string value(p->value); string value(p->value);
@ -104,12 +104,12 @@ 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]);
@ -121,7 +121,7 @@ namespace pEp {
key = normalize(key, norm_nfc); key = normalize(key, norm_nfc);
string _value = extract_value(); string _value = extract_value();
_value = normalize(_value, norm_nfc); _value = normalize(_value, norm_nfc);
stringpair_t *pair = new_stringpair(key.c_str(), _value.c_str()); ::stringpair_t *pair = ::new_stringpair(key.c_str(), _value.c_str());
if (!pair) { if (!pair) {
free_stringpair_list(_spl); free_stringpair_list(_spl);
throw bad_alloc(); throw bad_alloc();
@ -137,12 +137,12 @@ 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())
@ -158,9 +158,9 @@ 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;
result.append(s); result.append(s);
} }

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

@ -25,17 +25,17 @@ string repr(string s);
string str_attr(char *&str); string str_attr(char *&str);
void str_attr(char *&str, string value); void str_attr(char *&str, string value);
time_t timestamp_attr(timestamp *&ts); time_t timestamp_attr(::timestamp *&ts);
void timestamp_attr(timestamp *&ts, time_t value); void timestamp_attr(::timestamp *&ts, time_t value);
boost::python::list strlist_attr(stringlist_t *&sl); boost::python::list strlist_attr(::stringlist_t *&sl);
void strlist_attr(stringlist_t *&sl, boost::python::list value); void strlist_attr(::stringlist_t *&sl, boost::python::list value);
dict strdict_attr(stringpair_list_t *&spl); dict strdict_attr(::stringpair_list_t *&spl);
void strdict_attr(stringpair_list_t *&spl, dict value); void strdict_attr(::stringpair_list_t *&spl, dict value);
stringlist_t *to_stringlist(boost::python::list l); ::stringlist_t *to_stringlist(boost::python::list l);
boost::python::list from_stringlist(const stringlist_t *sl); boost::python::list from_stringlist(const ::stringlist_t *sl);
} /* namespace PythonAdapter */ } /* namespace PythonAdapter */
} /* namespace pEp */ } /* namespace pEp */

12
src/pEp/_pEp/user_interface.cc
View File

@ -27,9 +27,9 @@ namespace pEp {
UserInterface_callback::UserInterface_callback(PyObject *self) : UserInterface_callback::UserInterface_callback(PyObject *self) :
UserInterface(), _self(self) { UserInterface(), _self(self) {
// adapter.ui_object(self); // adapter.ui_object(self);
// PEP_STATUS status = ::register_sync_callbacks(Adapter::session(), // ::PEP_STATUS status = ::register_sync_callbacks(Adapter::session(),
// (void *) this, _notifyHandshake, retrieve_next_sync_event); // (void *) this, _notifyHandshake, retrieve_next_sync_event);
// assert(status == PEP_STATUS_OK); // assert(status == ::PEP_STATUS_OK);
// if (status) // if (status)
// _throw_status(status); // _throw_status(status);
} }
@ -38,7 +38,7 @@ namespace pEp {
// ::unregister_sync_callbacks(Adapter::session()); // ::unregister_sync_callbacks(Adapter::session());
} }
PEP_STATUS UserInterface::_notifyHandshake( ::PEP_STATUS UserInterface::_notifyHandshake(
pEp_identity *me, pEp_identity *partner, pEp_identity *me, pEp_identity *partner,
sync_handshake_signal signal sync_handshake_signal signal
) { ) {
@ -48,7 +48,7 @@ namespace pEp {
auto that = dynamic_cast< UserInterface_callback * >(_ui); auto that = dynamic_cast< UserInterface_callback * >(_ui);
that->notifyHandshake(Identity(me), Identity(partner), signal); that->notifyHandshake(Identity(me), Identity(partner), signal);
return PEP_STATUS_OK; return ::PEP_STATUS_OK;
} }
void UserInterface::deliverHandshakeResult(int result, object identities) { void UserInterface::deliverHandshakeResult(int result, object identities) {
@ -73,7 +73,7 @@ namespace pEp {
} }
} }
PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(), ::PEP_STATUS status = ::deliverHandshakeResult(Adapter::session(),
(sync_handshake_result) result, shared_identities); (sync_handshake_result) result, shared_identities);
free_identity_list(shared_identities); free_identity_list(shared_identities);
_throw_status(status); _throw_status(status);
@ -82,7 +82,7 @@ namespace pEp {
//PEP_rating UserInterface::get_key_rating_for_user(string user_id, string fpr) //PEP_rating UserInterface::get_key_rating_for_user(string user_id, string fpr)
//{ //{
// PEP_rating result; // PEP_rating result;
// PEP_STATUS status = // ::PEP_STATUS status =
// ::get_key_rating_for_user(Adapter::session(), // ::get_key_rating_for_user(Adapter::session(),
// user_id.c_str(), fpr.c_str(), &result); // user_id.c_str(), fpr.c_str(), &result);
// _throw_status(status); // _throw_status(status);

2
src/pEp/_pEp/user_interface.hh
View File

@ -37,7 +37,7 @@ namespace pEp {
// PEP_rating get_key_rating_for_user(string user_id, string fpr); // PEP_rating get_key_rating_for_user(string user_id, string fpr);
protected: protected:
static PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal); static ::PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal);
}; };
class UserInterface_callback : public UserInterface { class UserInterface_callback : public UserInterface {

Write Preview
Loading…
Cancel
Save