Formatting only - K&R 1TBS is the standard here

setup.py

@@ -27,10 +27,10 @@ def pEpLog(*msg):
         msgstr += str(m)
         msgstr += separator
     func = inspect.currentframe().f_back.f_code
-    print(func.co_filename + " : " + func.co_name + " : "  + msgstr)
+    print(func.co_filename + " : " + func.co_name + " : " + msgstr)
 
-class BuildExtCommand(build_ext):
 
+class BuildExtCommand(build_ext):
     user_options = build_ext.user_options + [
         ('local', None, 'Use local pEp install in HOME/USERPROFILE for libs/includes'),
         ('prefix=', None, 'Use local pEp install in prefix for libs/includes'),
@@ -155,15 +155,15 @@ class BuildExtCommand(build_ext):
         # Append home-dir
         if self.local:
             pEpLog("local mode")
-            home_include=[ join(home, 'include') ]
-            home_libdirs=[ join(home, 'lib') ]
+            home_include = [join(home, 'include')]
+            home_libdirs = [join(home, 'lib')]
             includes += home_include
             libdirs += home_libdirs
 
         # Append prefix-dir
         if self.prefix:
-            prefix_include=[ join(self.prefix, 'include') ]
-            prefix_libdirs=[ join(self.prefix, 'lib') ]
+            prefix_include = [join(self.prefix, 'include')]
+            prefix_libdirs = [join(self.prefix, 'lib')]
             includes += prefix_include
             libdirs += prefix_libdirs
 
@@ -194,7 +194,7 @@ class BuildExtCommand(build_ext):
 
 
 if sys.platform == 'winnt':
-    if  sys.version_info[0] >= 3:
+    if sys.version_info[0] >= 3:
         import winreg
     else:
         import _winreg as winreg
@@ -202,18 +202,17 @@ if sys.platform == 'winnt':
 if sys.version_info[0] < 3:
     FileNotFoundError = EnvironmentError
 
-
 module_pEp = Extension(
     'native_pEp',
-    sources =   [
-                'src/pEp/native_pEp/pEpmodule.cc',
-                'src/pEp/native_pEp/basic_api.cc',
-                'src/pEp/native_pEp/identity.cc',
-                'src/pEp/native_pEp/message.cc',
-                'src/pEp/native_pEp/message_api.cc',
-                'src/pEp/native_pEp/str_attr.cc',
-                # 'src/pEp/native_pEp/user_interface.cc',
-                ],
+    sources=[
+        'src/pEp/native_pEp/pEpmodule.cc',
+        'src/pEp/native_pEp/basic_api.cc',
+        'src/pEp/native_pEp/identity.cc',
+        'src/pEp/native_pEp/message.cc',
+        'src/pEp/native_pEp/message_api.cc',
+        'src/pEp/native_pEp/str_attr.cc',
+        # 'src/pEp/native_pEp/user_interface.cc',
+    ],
 )
 
 # "MAIN" Function
@@ -225,7 +224,7 @@ setup(
     author_email="vb@pep-project.org",
     maintainer="Heck",
     maintainer_email="heck@pep.foundation",
-    package_dir={'':'src'},
+    package_dir={'': 'src'},
     packages=['pEp'],
     ext_modules=[module_pEp],
     cmdclass={

src/pEp/__init__.py

@@ -11,6 +11,7 @@ from native_pEp import *
 # import the module
 import native_pEp
 
+
 # Executed on module import
 def init():
     print(init, "called")
@@ -45,8 +46,9 @@ def notify_handshake(me, partner, signal):
 def main():
     print("I am being run as a script")
 
+
 # MAIN
 if __name__ == "__main__":
     main()
 else:
-    init()
+    init()

src/pEp/native_pEp/basic_api.cc

@@ -13,160 +13,149 @@
 #include "basic_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-
-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");
-
-    PEP_STATUS status = update_identity(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-void myself(Identity& ident)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.username() == "")
-        throw invalid_argument("username needed");
-
-    if (ident.user_id() == "")
-        ident.user_id(ident.address());
-
-    PEP_STATUS status = myself(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-string _trustwords(Identity me, Identity partner, string lang, bool full)
-{
-    if (me.fpr() == "" || partner.fpr() == "")
-        throw invalid_argument("fingerprint needed in Identities");
-
-    if (lang == "" && me.lang() == partner.lang())
-        lang = me.lang();
-
-    char *words = NULL;
-    size_t size = 0;
-    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)
-{
-    if (ident.fpr() == "")
-        throw invalid_argument("fingerprint needed in Identities");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id must be provided");
-
-    PEP_STATUS status = trust_personal_key(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-void set_identity_flags(Identity ident, identity_flags_t flags)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags);
-    _throw_status(status);
-}
-
-void unset_identity_flags(Identity ident, identity_flags_t flags)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags);
-    _throw_status(status);
-}
-
-void key_reset_trust(Identity ident)
-{
-    if (ident.fpr() == "")
-        throw invalid_argument("fpr needed");
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-
-    PEP_STATUS status = key_reset_trust(Adapter::session(), ident);
-    _throw_status(status);
-}
-
-
-
-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);
-    if (status && status != PEP_KEY_IMPORTED)
-        _throw_status(status);
-
-    auto result = boost::python::list();
-    for (::identity_list *il = private_keys; il && il->ident; il=il->next) {
-        ::pEp_identity *ident = ::identity_dup(il->ident);
-        if (!ident) {
+    namespace PythonAdapter {
+        using namespace std;
+
+        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");
+
+            PEP_STATUS status = update_identity(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        void myself(Identity &ident) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.username() == "")
+                throw invalid_argument("username needed");
+
+            if (ident.user_id() == "")
+                ident.user_id(ident.address());
+
+            PEP_STATUS status = myself(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        string _trustwords(Identity me, Identity partner, string lang, bool full) {
+            if (me.fpr() == "" || partner.fpr() == "")
+                throw invalid_argument("fingerprint needed in Identities");
+
+            if (lang == "" && me.lang() == partner.lang())
+                lang = me.lang();
+
+            char *words = NULL;
+            size_t size = 0;
+            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) {
+            if (ident.fpr() == "")
+                throw invalid_argument("fingerprint needed in Identities");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id must be provided");
+
+            PEP_STATUS status = trust_personal_key(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+        void set_identity_flags(Identity ident, identity_flags_t flags) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = set_identity_flags(Adapter::session(), ident, flags);
+            _throw_status(status);
+        }
+
+        void unset_identity_flags(Identity ident, identity_flags_t flags) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = unset_identity_flags(Adapter::session(), ident, flags);
+            _throw_status(status);
+        }
+
+        void key_reset_trust(Identity ident) {
+            if (ident.fpr() == "")
+                throw invalid_argument("fpr needed");
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+
+            PEP_STATUS status = key_reset_trust(Adapter::session(), ident);
+            _throw_status(status);
+        }
+
+
+        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);
+            if (status && status != PEP_KEY_IMPORTED)
+                _throw_status(status);
+
+            auto result = boost::python::list();
+            for (::identity_list *il = private_keys; il && il->ident; il = il->next) {
+                ::pEp_identity *ident = ::identity_dup(il->ident);
+                if (!ident) {
+                    free_identity_list(private_keys);
+                    throw bad_alloc();
+                }
+                result.append(Identity(ident));
+            }
+
             free_identity_list(private_keys);
-            throw bad_alloc();
+            return result;
+        }
+
+        string export_key(Identity ident) {
+            PEP_STATUS status = PEP_STATUS_OK;
+            char *key_data = NULL;
+            size_t size;
+            status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
+
+            _throw_status(status);
+            return key_data;
         }
-        result.append(Identity(ident));
-    }
-
-    free_identity_list(private_keys);
-    return result;
-}
-
-string export_key(Identity ident)
-{
-    PEP_STATUS status = PEP_STATUS_OK;
-    char* key_data = NULL;
-    size_t size;
-    status = ::export_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
-
-    _throw_status(status);
-    return key_data;
-}
-
-string export_secret_key(Identity ident)
-{
-    PEP_STATUS status = PEP_STATUS_OK;
-    char* key_data = NULL;
-    size_t size;
-    status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
-
-    _throw_status(status);
-    return key_data;
-}
-
-void set_own_key(Identity& ident, string fpr)
-{
-    if (ident.address() == "")
-        throw invalid_argument("address needed");
-    if (ident.username() == "")
-        throw invalid_argument("username needed");
-    if (ident.user_id() == "")
-        throw invalid_argument("user_id needed");
-    if (fpr == "")
-        throw invalid_argument("fpr needed");
-
-
-    const char* fpr_c = fpr.c_str();
-    PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c);
-    _throw_status(status);
-}
-
-} // namespace PythonAdapter
-} // namespace pEp {
+
+        string export_secret_key(Identity ident) {
+            PEP_STATUS status = PEP_STATUS_OK;
+            char *key_data = NULL;
+            size_t size;
+            status = ::export_secret_key(Adapter::session(), ident.fpr().c_str(), &key_data, &size);
+
+            _throw_status(status);
+            return key_data;
+        }
+
+        void set_own_key(Identity &ident, string fpr) {
+            if (ident.address() == "")
+                throw invalid_argument("address needed");
+            if (ident.username() == "")
+                throw invalid_argument("username needed");
+            if (ident.user_id() == "")
+                throw invalid_argument("user_id needed");
+            if (fpr == "")
+                throw invalid_argument("fpr needed");
+
+
+            const char *fpr_c = fpr.c_str();
+            PEP_STATUS status = set_own_key(Adapter::session(), ident, fpr_c);
+            _throw_status(status);
+        }
+
+    } // namespace PythonAdapter
+} // namespace pEp
 
 

src/pEp/native_pEp/basic_api.hh

@@ -7,24 +7,31 @@
 #include "pEpmodule.hh"
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-void update_identity(Identity& ident);
-void myself(Identity& ident);
-string _trustwords(Identity me, Identity partner, string lang, bool full);
-void trust_personal_key(Identity ident);
+        void update_identity(Identity &ident);
 
-void set_identity_flags(Identity ident, identity_flags_t flags);
-void unset_identity_flags(Identity ident, identity_flags_t flags);
+        void myself(Identity &ident);
 
-void key_reset_trust(Identity ident);
+        string _trustwords(Identity me, Identity partner, string lang, bool full);
 
-boost::python::list import_key(string key_data);
-string export_key(Identity ident);
-string export_secret_key(Identity ident);
-void set_own_key(Identity& ident, string fpr);
+        void trust_personal_key(Identity ident);
 
-} /* namespace PythonAdapter */
+        void set_identity_flags(Identity ident, identity_flags_t flags);
+
+        void unset_identity_flags(Identity ident, identity_flags_t flags);
+
+        void key_reset_trust(Identity ident);
+
+        boost::python::list import_key(string key_data);
+
+        string export_key(Identity ident);
+
+        string export_secret_key(Identity ident);
+
+        void set_own_key(Identity &ident, string fpr);
+
+    } /* namespace PythonAdapter */
 } /* namespace pEp */
 
 #endif /* BASIC_API_HH */

src/pEp/native_pEp/identity.cc

@@ -17,269 +17,241 @@
 #include "message_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-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)
-        throw bad_alloc();
-    _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()
-{
-
-}
-
-Identity::operator pEp_identity *()
-{
-    return _ident.get();
-}
-
-Identity::operator const pEp_identity *() const
-{
-    return _ident.get();
-}
-
-string Identity::_repr()
-{
-    stringstream build;
-    build << "Identity(";
-    string address;
-    if (_ident->address)
-        address = string(_ident->address);
-    build << repr(address) << ", ";
-    string username;
-    if (_ident->username)
-        username = string(_ident->username);
-    build << repr(username) << ", ";
-    string user_id;
-    if (_ident->user_id)
-        user_id = string(_ident->user_id);
-    build << repr(user_id) << ", ";
-    string fpr;
-    if (_ident->fpr)
-        fpr = string(_ident->fpr);
-    build << repr(fpr) << ", ";
-    build << (int) _ident->comm_type << ", ";
-    string lang = _ident->lang;
-    build << repr(lang) << ")";
-    return build.str();
-}
-
-string Identity::_str()
-{
-    if (!(_ident->address && _ident->address[0]))
-        return "";
-    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)
-        throw length_error("username must be at least 5 characters");
-
-    str_attr(_ident->username, value);
-}
-
-void Identity::lang(string value)
-{
-    if (value == "")
-        memset(_ident->lang, 0, 3);
-    else if (value.length() != 2)
-        throw length_error("length of lang must be 2");
-    else
-        memcpy(_ident->lang, value.c_str(), 3);
-}
-
-string Identity::lang()
-{
-    return _ident->lang;
-}
-
-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;
-}
-
-PEP_color Identity::color()
-{
-    return _color(rating());
-}
-
-Identity Identity::copy()
-{
-    pEp_identity *dup = ::identity_dup(*this);
-    if (!dup)
-        throw bad_alloc();
-
-    return Identity(dup);
-}
-
-Identity Identity::deepcopy(dict&)
-{
-    return copy();
-}
-
-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);
-    _throw_status(status);
-}
-
-void Identity::key_mistrusted()
-{
-    PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this);
-    _throw_status(status);
-}
-
-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()
-{
-    PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this);
-    _throw_status(status);
-}
-
-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)
-        throw out_of_range("no identity assigned");
-
-    pEp_identity *_dup = identity_dup(ident);
-    if (!_dup)
-        throw bad_alloc();
-
-    Identity _ident(_dup);
-    return _ident;
-}
-
-void identity_attr(pEp_identity *&ident, object value)
-{
-    Identity& _ident = extract< Identity& >(value);
-    pEp_identity *_dup = ::identity_dup(_ident);
-    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 result;
-
-    for (identity_list *_il = il; _il && _il->ident; _il = _il->next) {
-        pEp_identity *ident = ::identity_dup(_il->ident);
-        if (!ident)
-            throw bad_alloc();
-        result.append(object(Identity(ident)));
-    }
-
-    return result;
-}
-
-void identitylist_attr(identity_list *&il, boost::python::list value)
-{
-    identity_list *_il = new_identity_list(NULL);
-    if (!_il)
-        throw bad_alloc();
-
-    identity_list *_i = _il;
-    for (int i=0; i<len(value); i++) {
-        extract< Identity& > extract_identity(value[i]);
-        if (!extract_identity.check()) {
-            free_identity_list(_il);
+    namespace PythonAdapter {
+        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)
+                throw bad_alloc();
+            _ident->comm_type = (PEP_comm_type) comm_type;
+            _ident->flags = (identity_flags_t) flags;
+            this->lang(lang);
         }
-        pEp_identity *_ident = extract_identity();
-        pEp_identity *_dup = ::identity_dup(_ident);
-        if (!_dup) {
-            free_identity_list(_il);
-            throw bad_alloc();
+
+        Identity::Identity(const Identity &second)
+                : _ident(second._ident) {
+
+        }
+
+        Identity::Identity(pEp_identity *ident)
+                : _ident(ident, &::free_identity) {
+
         }
-        PEP_STATUS status = update_identity(Adapter::session(), _dup);
-        if (status != PEP_STATUS_OK) {
-            free_identity_list(_il);
+
+        Identity::~Identity() {
+
+        }
+
+        Identity::operator pEp_identity *() {
+            return _ident.get();
+        }
+
+        Identity::operator const pEp_identity *() const {
+            return _ident.get();
+        }
+
+        string Identity::_repr() {
+            stringstream build;
+            build << "Identity(";
+            string address;
+            if (_ident->address)
+                address = string(_ident->address);
+            build << repr(address) << ", ";
+            string username;
+            if (_ident->username)
+                username = string(_ident->username);
+            build << repr(username) << ", ";
+            string user_id;
+            if (_ident->user_id)
+                user_id = string(_ident->user_id);
+            build << repr(user_id) << ", ";
+            string fpr;
+            if (_ident->fpr)
+                fpr = string(_ident->fpr);
+            build << repr(fpr) << ", ";
+            build << (int) _ident->comm_type << ", ";
+            string lang = _ident->lang;
+            build << repr(lang) << ")";
+            return build.str();
+        }
+
+        string Identity::_str() {
+            if (!(_ident->address && _ident->address[0]))
+                return "";
+            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)
+                throw length_error("username must be at least 5 characters");
+
+            str_attr(_ident->username, value);
+        }
+
+        void Identity::lang(string value) {
+            if (value == "")
+                memset(_ident->lang, 0, 3);
+            else if (value.length() != 2)
+                throw length_error("length of lang must be 2");
+            else
+                memcpy(_ident->lang, value.c_str(), 3);
+        }
+
+        string Identity::lang() {
+            return _ident->lang;
+        }
+
+        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;
+        }
+
+        PEP_color Identity::color() {
+            return _color(rating());
+        }
+
+        Identity Identity::copy() {
+            pEp_identity *dup = ::identity_dup(*this);
+            if (!dup)
+                throw bad_alloc();
+
+            return Identity(dup);
         }
-        _i = identity_list_add(_i, _dup);
-        if (!_i) {
-            free_identity_list(_il);
-            throw bad_alloc();
+
+        Identity Identity::deepcopy(dict &) {
+            return copy();
         }
-    }
 
-    free_identity_list(il);
-    il = _il;
-}
+        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);
+            _throw_status(status);
+        }
+
+        void Identity::key_mistrusted() {
+            PEP_STATUS status = ::key_mistrusted(Adapter::session(), *this);
+            _throw_status(status);
+        }
+
+        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() {
+            PEP_STATUS status = ::enable_identity_for_sync(Adapter::session(), *this);
+            _throw_status(status);
+        }
+
+        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)
+                throw out_of_range("no identity assigned");
+
+            pEp_identity *_dup = identity_dup(ident);
+            if (!_dup)
+                throw bad_alloc();
+
+            Identity _ident(_dup);
+            return _ident;
+        }
+
+        void identity_attr(pEp_identity *&ident, object value) {
+            Identity &_ident = extract<Identity &>(value);
+            pEp_identity *_dup = ::identity_dup(_ident);
+            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 result;
+
+            for (identity_list *_il = il; _il && _il->ident; _il = _il->next) {
+                pEp_identity *ident = ::identity_dup(_il->ident);
+                if (!ident)
+                    throw bad_alloc();
+                result.append(object(Identity(ident)));
+            }
+
+            return result;
+        }
+
+        void identitylist_attr(identity_list *&il, boost::python::list value) {
+            identity_list *_il = new_identity_list(NULL);
+            if (!_il)
+                throw bad_alloc();
+
+            identity_list *_i = _il;
+            for (int i = 0; i < len(value); i++) {
+                extract < Identity & > extract_identity(value[i]);
+                if (!extract_identity.check()) {
+                    free_identity_list(_il);
+                }
+                pEp_identity *_ident = extract_identity();
+                pEp_identity *_dup = ::identity_dup(_ident);
+                if (!_dup) {
+                    free_identity_list(_il);
+                    throw bad_alloc();
+                }
+                PEP_STATUS status = update_identity(Adapter::session(), _dup);
+                if (status != PEP_STATUS_OK) {
+                    free_identity_list(_il);
+                    _throw_status(status);
+                }
+                _i = identity_list_add(_i, _dup);
+                if (!_i) {
+                    free_identity_list(_il);
+                    throw bad_alloc();
+                }
+            }
+
+            free_identity_list(il);
+            il = _il;
+        }
 
-} // namespace PythonAdapter
-} // namespace pEp {
+    } // namespace PythonAdapter
+} // namespace pEp
 

src/pEp/native_pEp/identity.hh

@@ -21,82 +21,101 @@
 #include "str_attr.hh"
 
 namespace pEp {
-namespace PythonAdapter {
+    namespace PythonAdapter {
 
-using std::string;
-using std::shared_ptr;
+        using std::string;
+        using std::shared_ptr;
 
 // Identity is owning a pEp_identity
 
-class Identity {
-protected:
-    shared_ptr< pEp_identity > _ident;
+        class Identity {
+        protected:
+            shared_ptr <pEp_identity> _ident;
 
-public:
-    Identity(string address = "", string username = "",
-            string user_id = "", string fpr = "", int comm_type = 0,
-            string lang = "", identity_flags_t flags = 0);
+        public:
+            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);
-    Identity(pEp_identity *ident);
-    virtual ~Identity();
-    operator pEp_identity *();
-    operator const pEp_identity *() const;
+            Identity(const Identity &second);
 
-    string _repr();
-    string _str();
+            Identity(pEp_identity *ident);
 
-    string address() { return str_attr(_ident->address); }
-    void address(string value) { str_attr(_ident->address, value); }
+            virtual ~Identity();
 
-    string fpr() { return str_attr(_ident->fpr); }
-    void fpr(string value) { str_attr(_ident->fpr, value); }
+            operator pEp_identity *();
 
-    string user_id() { return str_attr(_ident->user_id); }
-    void user_id(string value) { str_attr(_ident->user_id, value); }
+            operator const pEp_identity *() const;
 
-    string username() { return str_attr(_ident->username); }
-    void username(string value);
+            string _repr();
 
-    PEP_comm_type comm_type() { return _ident->comm_type; }
-    void comm_type(PEP_comm_type value) { _ident->comm_type = value; };
+            string _str();
 
-    std::string lang();
-    void lang(std::string value);
+            string address() { return str_attr(_ident->address); }
 
-    identity_flags_t flags() { return _ident->flags; }
-    void flags(identity_flags_t flags) { _ident->flags = flags; }
+            void address(string value) { str_attr(_ident->address, value); }
 
-    int rating();
-    PEP_color color();
+            string fpr() { return str_attr(_ident->fpr); }
 
-    Identity copy();
-    Identity deepcopy(dict& memo);
+            void fpr(string value) { str_attr(_ident->fpr, value); }
 
-    virtual void update();
+            string user_id() { return str_attr(_ident->user_id); }
 
-    void key_reset(string fpr="");
-    void key_mistrusted();
+            void user_id(string value) { str_attr(_ident->user_id, value); }
 
-    bool is_pEp_user();
+            string username() { return str_attr(_ident->username); }
 
-    void enable_for_sync();
-    void disable_for_sync();
-};
+            void username(string value);
 
-class Myself : public Identity {
-public:
-    Myself(string address, string username, string user_id="", string lang="");
-    virtual void update();
-};
+            PEP_comm_type comm_type() { return _ident->comm_type; }
 
-Identity identity_attr(pEp_identity *&ident);
-void identity_attr(pEp_identity *&ident, object value);
+            void comm_type(PEP_comm_type value) { _ident->comm_type = value; };
 
-boost::python::list identitylist_attr(identity_list *&il);
-void identitylist_attr(identity_list *&il, boost::python::list value);
+            std::string lang();
 
-} /* namespace PythonAdapter */
-} /* namespace pEp */
+            void lang(std::string value);
+
+            identity_flags_t flags() { return _ident->flags; }
+
+            void flags(identity_flags_t flags) { _ident->flags = flags; }
+
+            int rating();
+
+            PEP_color color();
+
+            Identity copy();
+
+            Identity deepcopy(dict &memo);
+
+            virtual void update();
+
+            void key_reset(string fpr = "");
+
+            void key_mistrusted();
+
+            bool is_pEp_user();
+
+            void enable_for_sync();
+
+            void disable_for_sync();
+        };
+
+        class Myself : public Identity {
+        public:
+            Myself(string address, string username, string user_id = "", string lang = "");
+
+            virtual void update();
+        };
+
+        Identity identity_attr(pEp_identity *&ident);
+
+        void identity_attr(pEp_identity *&ident, object value);
+
+        boost::python::list identitylist_attr(identity_list *&il);
+
+        void identitylist_attr(identity_list *&il, boost::python::list value);
+
+    } // namespace PythonAdapter
+} // namespace pEp
 
 #endif /* IDENTITY_HH */

src/pEp/native_pEp/message.cc

@@ -19,395 +19,367 @@
 #include "message_api.hh"
 
 namespace pEp {
-namespace PythonAdapter {
-using namespace std;
-using namespace boost::python;
-
-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)
-        throw bad_alloc();
-
-    Py_buffer src;
-    int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO);
-    if (result)
-        throw invalid_argument("need a contiguous buffer to read");
-
-    char *mem = (char *)malloc(src.len);
-    if (!mem) {
-        PyBuffer_Release(&src);
-        throw bad_alloc();
-    }
-
-    memcpy(mem, src.buf, src.len);
-    free(_bl->value);
-    _bl->size = src.len;
-    _bl->value = mem;
-
-    PyBuffer_Release(&src);
-
-    this->mime_type(mime_type);
-    this->filename(filename);
-}
-
-Message::Blob::Blob(const Message::Blob& second) :
-    _bl(second._bl), part_of_chain(true)
-{
-
-}
-
-Message::Blob::~Blob()
-{
-    if (!part_of_chain) {
-        free(_bl->value);
-        free(_bl);
-    }
-}
-
-string Message::Blob::_repr()
-{
-    stringstream build;
-    build << "Blob(";
-    if (!_bl) {
-        build << "b'', '', ''";
-    }
-    else {
-        build << "bytes(" << _bl->size << "), ";
-        string mime_type;
-        if (_bl->mime_type)
-            mime_type = string(_bl->mime_type);
-        string filename;
-        if (_bl->filename)
-            filename = string(_bl->filename);
-        build << repr(mime_type) << ", ";
-        build << repr(filename);
-    }
-    build << ")";
-    return build.str();
-}
-
-int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) {
-    bloblist_t *bl = NULL;
-
-    try {
-        Message::Blob& blob = extract< Message::Blob& >(self);
-        bl = blob._bl;
-    }
-    catch (exception& e) {
-        PyErr_SetString(PyExc_RuntimeError, "extract not possible");
-        view->obj = NULL;
-        return -1;
-    }
-
-    if (!(bl && bl->value)) {
-        PyErr_SetString(PyExc_RuntimeError, "no data available");
-        view->obj = NULL;
-        return -1;
-    }
-
-    return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags);
-}
-
-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")
-            encoding = "pep.sync";
-
-        if (_mime_type == "application/pEp.keyreset")
-            encoding = "pep.distribution";
-
-    }
-    object codecs = import("codecs");
-    object _decode = codecs.attr("decode");
-    return call< string >(_decode.ptr(), this, encoding);
-}
-
-PyBufferProcs Message::Blob::bp = { getbuffer, NULL };
-
-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)
-            throw bad_alloc();
-        _msg->dir = (PEP_msg_direction) dir;
-    }
-}
-
-Message::Message(string mimetext)
-    : _msg(NULL, &free_message)
-{
-    message *_cpy;
-    PEP_STATUS status = mime_decode_message(mimetext.c_str(),
-            mimetext.size(), &_cpy, NULL);
-    switch (status) {
-        case PEP_STATUS_OK:
-            if (_cpy)
-                _cpy->dir = PEP_dir_outgoing;
-            else
-                _cpy = new_message(PEP_dir_outgoing);
-
-            if (!_cpy)
+    namespace PythonAdapter {
+        using namespace std;
+        using namespace boost::python;
+
+        Message::Blob::Blob(bloblist_t *bl, bool chained) :
+                _bl(bl), part_of_chain(chained) {
+            if (!_bl)
                 throw bad_alloc();
+        }
 
-            _msg = shared_ptr< message >(_cpy);
-            break;
+        Message::Blob::Blob(object data, string mime_type, string filename) :
+                _bl(new_bloblist(NULL, 0, NULL, NULL)), part_of_chain(false) {
+            if (!_bl)
+                throw bad_alloc();
 
-        case PEP_BUFFER_TOO_SMALL:
-            throw runtime_error("mime_decode_message: buffer too small");
+            Py_buffer src;
+            int result = PyObject_GetBuffer(data.ptr(), &src, PyBUF_CONTIG_RO);
+            if (result)
+                throw invalid_argument("need a contiguous buffer to read");
 
-        case PEP_CANNOT_CREATE_TEMP_FILE:
-            throw runtime_error("mime_decode_message: cannot create temp file");
+            char *mem = (char *) malloc(src.len);
+            if (!mem) {
+                PyBuffer_Release(&src);
+                throw bad_alloc();
+            }
+
+            memcpy(mem, src.buf, src.len);
+            free(_bl->value);
+            _bl->size = src.len;
+            _bl->value = mem;
 
-        case PEP_OUT_OF_MEMORY:
-            throw bad_alloc();
+            PyBuffer_Release(&src);
 
-        default:
+            this->mime_type(mime_type);
+            this->filename(filename);
+        }
+
+        Message::Blob::Blob(const Message::Blob &second) :
+                _bl(second._bl), part_of_chain(true) {
+
+        }
+
+        Message::Blob::~Blob() {
+            if (!part_of_chain) {
+                free(_bl->value);
+                free(_bl);
+            }
+        }
+
+        string Message::Blob::_repr() {
             stringstream build;
-            build << "mime_decode_message: unknown error (" << (int) status << ")";
-            throw runtime_error(build.str());
-    }
-}
+            build << "Blob(";
+            if (!_bl) {
+                build << "b'', '', ''";
+            } else {
+                build << "bytes(" << _bl->size << "), ";
+                string mime_type;
+                if (_bl->mime_type)
+                    mime_type = string(_bl->mime_type);
+                string filename;
+                if (_bl->filename)
+                    filename = string(_bl->filename);
+                build << repr(mime_type) << ", ";
+                build << repr(filename);
+            }
+            build << ")";
+            return build.str();
+        }
+
+        int Message::Blob::getbuffer(PyObject *self, Py_buffer *view, int flags) {
+            bloblist_t *bl = NULL;
+
+            try {
+                Message::Blob &blob = extract<Message::Blob &>(self);
+                bl = blob._bl;
+            }
+            catch (exception &e) {
+                PyErr_SetString(PyExc_RuntimeError, "extract not possible");
+                view->obj = NULL;
+                return -1;
+            }
+
+            if (!(bl && bl->value)) {
+                PyErr_SetString(PyExc_RuntimeError, "no data available");
+                view->obj = NULL;
+                return -1;
+            }
+
+            return PyBuffer_FillInfo(view, self, bl->value, bl->size, 0, flags);
+        }
+
+        string Message::Blob::decode(string encoding) {
+            if (encoding == "") {
+                string _mime_type = _bl->mime_type ? _bl->mime_type : "";
+                encoding = "ascii";
 
-Message::Message(const Message& second)
-    : _msg(second._msg)
-{
-    if (!_msg.get())
-        throw bad_alloc();
-}
+                if (_mime_type == "application/pEp.sync")
+                    encoding = "pep.sync";
 
-Message::Message(message *msg)
-    : _msg(::message_dup(msg), &free_message)
-{
+                if (_mime_type == "application/pEp.keyreset")
+                    encoding = "pep.distribution";
 
-}
+            }
+            object codecs = import("codecs");
+            object _decode = codecs.attr("decode");
+            return call<string>(_decode.ptr(), this, encoding);
+        }
 
-Message::~Message()
-{
+        PyBufferProcs Message::Blob::bp = {getbuffer, NULL};
 
-}
+        Message::Message(int dir, Identity *from)
+                : _msg(new_message((PEP_msg_direction) dir), &free_message) {
+            if (!_msg)
+                throw bad_alloc();
 
-Message::operator message *()
-{
-    return _msg.get();
-}
+            if (from) {
+                _msg->from = ::identity_dup(*from);
+                if (!_msg->from)
+                    throw bad_alloc();
+                _msg->dir = (PEP_msg_direction) dir;
+            }
+        }
 
-Message::operator const message *() const
-{
-    return _msg.get();
-}
+        Message::Message(string mimetext)
+                : _msg(NULL, &free_message) {
+            message *_cpy;
+            PEP_STATUS status = mime_decode_message(mimetext.c_str(),
+                                                    mimetext.size(), &_cpy, NULL);
+            switch (status) {
+                case PEP_STATUS_OK:
+                    if (_cpy)
+                        _cpy->dir = PEP_dir_outgoing;
+                    else
+                        _cpy = new_message(PEP_dir_outgoing);
+
+                    if (!_cpy)
+                        throw bad_alloc();
+
+                    _msg = shared_ptr<message>(_cpy);
+                    break;
+
+                case PEP_BUFFER_TOO_SMALL:
+                    throw runtime_error("mime_decode_message: buffer too small");
+
+                case PEP_CANNOT_CREATE_TEMP_FILE:
+                    throw runtime_error("mime_decode_message: cannot create temp file");
+
+                case PEP_OUT_OF_MEMORY:
+                    throw bad_alloc();
+
+                default:
+                    stringstream build;
+                    build << "mime_decode_message: unknown error (" << (int) status << ")";
+                    throw runtime_error(build.str());
+            }
+        }
 
-string Message::_str()