Too many changes, sorry

6 files changed, 364 insertions, 331 deletions

diff --git a/python/lasso.py b/python/lasso.py
index 02b933b1..39f5170e 100644
--- a/python/lasso.py
+++ b/python/lasso.py
@@ -46,34 +46,17 @@ def shutdown():
     """
     return lassomod.shutdown()
 
-def assertion_build(response, issuer):
-    return Node(_obj=lassomod.assertion_build(response, issuer))
-
-def assertion_add_authenticationStatement(assertion, statement):
-    return lassomod.assertion_add_authenticationStatement(assertion, statement)
-
-def authentication_statement_build(authenticationMethod, sessionIndex,
-                                   reauthenticateOnOrAfter,
-                                   nameIdentifier, nameQualifier,
-                                   format, idp_nameIdentifier,
-                                   idp_nameQualifier, idp_format,
-                                   confirmationMethod):
-    return Node(_obj=lassomod.authentication_statement_build(
-        authenticationMethod, sessionIndex,
-        reauthenticateOnOrAfter,
-        nameIdentifier, nameQualifier,
-        format, idp_nameIdentifier,
-        idp_nameQualifier, idp_format,
-        confirmationMethod))
-
+################################################################################
+# xml : low level classes
+################################################################################
 
 class Node:
     def __init__(self, _obj=None):
         """
         """
-##         if _obj != None:
-##             self._o = _obj
-##             return
+        if _obj != None:
+            self._o = _obj
+            return
 ##         #self._o = lassomod.(size)
 ##         if self._o is None: raise Error('lasso_node_new() failed')
 
@@ -96,227 +79,170 @@ class Node:
         return lassomod.node_verify_signature(self, certificate_file)
 
 
-class AuthnRequest(Node):
-    def __init__(self, providerID, _obj=None):
+class LibAuthnRequest(Node):
+    def __init__(self, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.authn_request_new(providerID)
-        if self._o is None: raise Error('lasso_authn_request_new() failed')
-    
-    def set_requestAuthnContext(self, authnContextClassRefs=None,
-                                authnContextStatementRefs=None,
-                                authnContextComparison=None):
-        lassomod.authn_request_set_requestAuthnContext(self,
-                                                       authnContextClassRefs,
-                                                       authnContextStatementRefs,
-                                                       authnContextComparison)
+        _obj = lassomod.lib_authn_request_new()
+        if _obj is None: raise Error('lasso_lib_authn_request_new() failed')
+        Node.__init__(self, _obj=_obj)
+        
+    def set_forceAuthn(self, forceAuthn):
+        lassomod.lib_authn_request_set_forceAuthn(self, forceAuthn)
 
-    def set_scoping(self, proxyCount):
-        lassomod.authn_request_set_scoping(self, proxyCount)
+    def set_isPassive(self, isPassive):
+        lassomod.lib_authn_request_set_isPassive(self, isPassive)
 
+    def set_protocolProfile(self, protocolProfile):
+        lassomod.lib_authn_request_set_protocolProfile(self, protocolProfile)
 
-class AuthnResponse:
-    def __init__(self, query, verify_signature, public_key_file,
-                 private_key_file, certificate_file, is_authenticated,
-                 _obj=None):
+
+class LibFederationTerminationNotification(Node):
+    def __init__(self, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.authn_response_create(query,
-                                                 verify_signature,
-                                                 public_key_file,
-                                                 private_key_file,
-                                                 certificate_file,
-                                                 is_authenticated)
-        if self._o is None: raise Error('lasso_authn_response_create() failed')
+        _obj = lassomod.lib_federation_termination_notification_new()
+        if _obj is None:
+            raise Error('lasso_lib_federation_termination_notification_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
-
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.authn_response_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
-
-    def init(self, providerID, authentication_result):
-        return lassomod.authn_response_init(self, providerID,
-                                            authentication_result)
-    def add_assertion(self, assertion):
-        return lassomod.authn_response_add_assertion(self, assertion)
+    def set_consent(self, consent):
+        lassomod.lib_federation_termination_notification_set_consent(self, consent)
 
 
-class Request:
-    def __init__(self, assertionArtifact, _obj=None):
+class LibLogoutRequest(Node):
+    def __init__(self, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.request_create(assertionArtifact)
-        if self._o is None: raise Error('lasso_request_create() failed')
+        _obj = lassomod.lib_logout_request_new()
+        if _obj is None: raise Error('lasso_lib_logout_request_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
+    def set_consent(self, consent):
+        lassomod.lib_logout_request_set_consent(self, consent)
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.request_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+    def set_nameIdentifier(self, nameIdentifier):
+        lassomod.lib_logout_request_set_nameIdentifier(self, nameIdentifier)
 
+    def set_providerID(self, providerID):
+        lassomod.lib_logout_request_set_providerID(self, providerID)
 
-class Response:
-    def __init__(self,
-                 serialized_request,
-                 verify_signature,
-                 public_key_file, private_key_file, certificate_file,
-                 _obj=None):
+    def set_relayState(self, relayState):
+        lassomod.lib_logout_request_set_relayState(self, relayState)
+
+    def set_sessionIndex(self, sessionIndex):
+        lassomod.lib_logout_request_set_sessionIndex(self, sessionIndex)
+
+
+class LibNameIdentifierMappingRequest(Node):
+    def __init__(self, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.response_create(serialized_request,
-                                           verify_signature,
-                                           public_key_file, private_key_file, certificate_file)
-        if self._o is None: raise Error('lasso_response_create() failed')
-
-    def __isprivate(self, name):
-        return name == '_o'
-
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.response_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        elif name == "request_node":
-            ret = Node(_obj=ret)
-        return ret
+        _obj = lassomod.lib_name_identifier_mapping_request_new()
+        if _obj is None:
+            raise Error('lasso_lib_name_identifier_mapping_request_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-    def init(self, authentication_result):
-        return lassomod.response_init(self, authentication_result)
+    def set_consent(self, consent):
+        lassomod.lib_name_identifier_mapping_request_set_consent(self, consent)
 
-    def add_assertion(self, assertion):
-        return lassomod.response_add_assertion(self, assertion)
 
-class LogoutRequest(Node):
-    def __init__(self,
-                 providerID,
-		 nameIdentifier, nameQualifier, format,
-                 sessionIndex = None, relayState = None, consent = None,
-                 _obj=None):
+class SamlAssertion(Node):
+    def __init__(self, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.logout_request(providerID,
-                                          nameIdentifier,
-                                          nameQualifier,
-                                          format)
-        if self._o is None: raise Error('lasso_logout_request() failed')
+        _obj = lassomod.saml_assertion_new()
+        if _obj is None: raise Error('lasso_saml_assertion_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-        if sessionIndex:
-            lassomod.logout_request_set_sessionIndex(self, sessionIndex)
+    def add_authenticationStatement(self, authenticationStatement):
+        lassomod.saml_assertion_add_authenticationStatement(self,
+                                                            authenticationStatement)
 
-        if relayState:
-            lassomod.logout_request_set_relayState(self, relayState)
 
-        if consent:
-            lassomod.logout_request_set_consent(self, consent)
+class SamlAuthenticationStatement(Node):
+    def __init__(self, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.saml_authentication_statement_new()
+        if _obj is None: raise Error('lasso_saml_authentication_statement_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.logout_request_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+class SamlNameIdentifier(Node):
+    def __init__(self, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.saml_name_identifier_new()
+        if _obj is None: raise Error('lasso_saml_authentication_statement_new() failed')
+        Node.__init__(self, _obj=_obj)
 
+    def set_format(self, format):
+        lassomod.saml_name_identifier_set_format(self, format)
+    
+    def set_nameQualifier(self, nameQualifier):
+        lassomod.saml_name_identifier_set_nameQualifier(self, nameQualifier)
 
-class LogoutResponse(Node):
-    def __init__(self,
-                 providerID,
-                 statusCodeValue,
-                 request,
-                 _obj=None):
+################################################################################
+# protocols : high level classes
+################################################################################
+
+def authn_request_get_protocolProfile(query):
+    return lassomod.authn_request_get_protocolProfile(query)
+class AuthnRequest(LibAuthnRequest):
+    def __init__(self, providerID, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.logout_response(providerID,
-                                           statusCodeValue,
-                                           request)
-        if self._o is None: raise Error('lasso_logout_response() failed')
-
-    def __isprivate(self, name):
-        return name == '_o'
+        _obj = lassomod.authn_request_new(providerID)
+        if _obj is None: raise Error('lasso_authn_request_new() failed')
+        LibAuthnRequest.__init__(self, _obj=_obj)
+    
+    def set_requestAuthnContext(self, authnContextClassRefs=None,
+                                authnContextStatementRefs=None,
+                                authnContextComparison=None):
+        lassomod.authn_request_set_requestAuthnContext(self,
+                                                       authnContextClassRefs,
+                                                       authnContextStatementRefs,
+                                                       authnContextComparison)
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.logout_response_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret   
+    def set_scoping(self, proxyCount):
+        lassomod.authn_request_set_scoping(self, proxyCount)
 
 
-class RegisterNameIdentifierRequest(Node):
-    def __init__(self,
-                 providerID,
-                 idpNameIdentifier, idpNameQualifier, idpFormat,
-                 spNameIdentifier,  spNameQualifier,  spFormat,
-                 oldNameIdentifier, oldNameQualifier, oldFormat,
-                 relayState = None,
-		 _obj=None):
+class AuthnResponse(Node):
+    def __init__(self, query, providerID, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.register_name_identifier_request(providerID,
-                                                            idpNameIdentifier, idpNameQualifier, idpFormat,
-                                                            spNameIdentifier,  spNameQualifier,  spFormat,
-                                                            oldNameIdentifier, oldNameQualifier, oldFormat)
-        if self._o is None: raise Error('lasso_register_name_identifier_request() failed')
-
-        if relayState:
-            lassomod.register_name_identifier_request_set_relayState(self, relayState)
+        _obj = lassomod.authn_response_new(query, providerID)
+        if _obj is None: raise Error('lasso_authn_response_new() failed')
+        Node.__init__(self, _obj=_obj)
 
     def __isprivate(self, name):
         return name == '_o'
@@ -326,118 +252,132 @@ class RegisterNameIdentifierRequest(Node):
             return self.__dict__[name]
         if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
             raise AttributeError, name
-        ret = lassomod.register_name_identifier_request_getattr(self, name)
+        ret = lassomod.authn_response_getattr(self, name)
         if ret is None:
             raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
         return ret
 
-    def changeAttributeNamesIdentifiers(self):
-        lassomod.register_name_identifier_request_change_attribute_names_identifiers(self);
+    def add_assertion(self, assertion, private_key_file, certificate_file):
+        lassomod.authn_response_add_assertion(self, assertion,
+                                              private_key_file,
+                                              certificate_file)
 
+    def must_authenticate(self, is_authenticated):
+        return lassomod.authn_response_must_authenticate(self,
+                                                         is_authenticated)
 
-class RegisterNameIdentifierResponse(Node):
-    def __init__(self,
-                 providerID,
-                 statusCodeValue,
-                 request,
-                 _obj=None):
+    def process_authentication_result(self, authentication_result):
+        lassomod.authn_response_process_authentication_result(self,
+                                                              authentication_result)
+
+    def verify_signature(self, public_key_file, private_key_file):
+        return lassomod.authn_response_verify_signature(self, public_key_file,
+                                                        private_key_file)
+
+
+class FederationTerminationNotification(LibFederationTerminationNotification):
+    def __init__(self, providerID, nameIdentifier,
+                 nameQualifier=None, format=None, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.register_name_identifier_response(providerID,
-                                           statusCodeValue,
-                                           request)
-        if self._o is None: raise Error('lasso_register_name_identifier_response() failed')
+        self._o = lassomod.federation_termination_notification_new(providerID,
+                                                                   nameIdentifier,
+                                                                   nameQualifier,
+                                                                   format)
+        if self._o is None:
+            raise Error('lasso_federation_termination_notification_new() failed')
+        LibFederationTerminationNotification.__init__(self, _obj=_obj)
+
+
+class LogoutRequest(LibLogoutRequest):
+    def __init__(self, providerID, nameIdentifier,
+                 nameQualifier=None, format=None, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.logout_request_new(providerID,
+                                           nameIdentifier,
+                                           nameQualifier,
+                                           format)
+        if _obj is None: raise Error('lasso_logout_request_new() failed')
+        LibLogoutRequest.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.register_name_identifier_response_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+class LogoutResponse(Node):
+    def __init__(self, providerID, statusCodeValue, request, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.logout_response_new(providerID, statusCodeValue,
+                                            request)
+        if _obj is None: raise Error('lasso_logout_response_new() failed')
+        Node.__init__(self, _obj=_obj)
 
 
-class FederationTerminationNotification(Node):
-    def __init__(self,
-                 providerID,
-                 nameIdentifier, nameQualifier, format,
-                 consent = None,
-		 _obj=None):
+class NameIdentifierMappingRequest(LibNameIdentifierMappingRequest):
+    def __init__(self, providerID, nameIdentifier,
+                 nameQualifier=None, format=None, _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.federation_termination_notification(providerID,
-                                                               nameIdentifier, nameQualifier, format)
-        if self._o is None: raise Error('lasso_federation_termination_notification() failed')
-
-        if consent:
-            lassomod.federation_termination_notification_set_consent(self, consent)
+        _obj = lassomod.name_identifier_mapping_request_new(providerID,
+                                                            nameIdentifier,
+                                                            nameQualifier,
+                                                            format)
+        if _obj is None:
+            raise Error('lasso_name_identifier_mapping_request_new() failed')
+        LibNameIdentifierMappingRequest.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.federation_termination_notification_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+class NameIdentifierMappingResponse(Node):
+    def __init__(self, providerID, statusCodeValue, request, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.name_identifier_mapping_response_new(providerID,
+                                                             statusCodeValue,
+                                                             request)
+        if _obj is None:
+            raise Error('lasso_name_identifier_mapping_response_new() failed')
+        Node.__init__(self, _obj=_obj)
 
 
-class NameIdentifierMappingRequest(Node):
+class RegisterNameIdentifierRequest(Node):
     def __init__(self,
                  providerID,
-                 nameIdentifier, nameQualifier, format,
-                 consent = None,
+                 idpNameIdentifier, idpNameQualifier, idpFormat,
+                 spNameIdentifier,  spNameQualifier,  spFormat,
+                 oldNameIdentifier, oldNameQualifier, oldFormat,
 		 _obj=None):
         """
         """
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.name_identifier_mapping_request(providerID,
-                                                           nameIdentifier, nameQualifier, format)
-        if self._o is None: raise Error('lasso_name_identifier_mapping_request() failed')
+        _obj = lassomod.register_name_identifier_request_new(providerID,
+                                                             idpNameIdentifier, idpNameQualifier, idpFormat,
+                                                             spNameIdentifier,  spNameQualifier,  spFormat,
+                                                             oldNameIdentifier, oldNameQualifier, oldFormat)
+        if _obj is None:
+            raise Error('lasso_register_name_identifier_request_new() failed')
+        Node.__init__(self, _obj=_obj)
 
-        if consent:
-            lassomod.name_identifier_mapping_request_set_consent(self, consent)
-
-    def __isprivate(self, name):
-        return name == '_o'
-
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.name_identifier_mapping_request_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+    def changeAttributeNamesIdentifiers(self):
+        lassomod.register_name_identifier_request_change_attribute_names_identifiers(self);
 
 
-class NameIdentifierMappingResponse(Node):
+class RegisterNameIdentifierResponse(Node):
     def __init__(self,
                  providerID,
                  statusCodeValue,
@@ -448,22 +388,57 @@ class NameIdentifierMappingResponse(Node):
         if _obj != None:
             self._o = _obj
             return
-        self._o = lassomod.name_identifier_mapping_response(providerID,
-                                           statusCodeValue,
-                                           request)
-        if self._o is None: raise Error('lasso_name_identifier_mapping_response() failed')
+        _obj = lassomod.register_name_identifier_response_new(providerID,
+                                                              statusCodeValue,
+                                                              request)
+        if _obj is None:
+            raise Error('lasso_register_name_identifier_response_new() failed')
+        Node.__init__(self, _obj=_obj)
+
+################################################################################
+# elements
+################################################################################
+
+class Assertion(SamlAssertion):
+    def __init__(self, issuer, requestID, _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.assertion_new(issuer, requestID)
+        if _obj is None: raise Error('lasso_assertion_new() failed')
+        SamlAssertion.__init__(self, _obj=_obj)
 
-    def __isprivate(self, name):
-        return name == '_o'
 
-    def __getattr__(self, name):
-        if self.__isprivate(name):
-            return self.__dict__[name]
-        if name[:2] == "__" and name[-2:] == "__" and name != "__members__":
-            raise AttributeError, name
-        ret = lassomod.name_identifier_mapping_response_getattr(self, name)
-        if ret is None:
-            raise AttributeError, name
-        if name == "node":
-            ret = Node(_obj=ret)
-        return ret
+class AuthenticationStatement(Node):
+    def __init__(self,
+                 authenticationMethod,
+                 sessionIndex,
+                 reauthenticateOnOrAfter,
+                 nameIdentifier,
+                 nameQualifier,
+                 format,
+                 idp_nameIdentifier,
+                 idp_nameQualifier,
+                 idp_format,
+                 confirmationMethod,
+                 _obj=None):
+        """
+        """
+        if _obj != None:
+            self._o = _obj
+            return
+        _obj = lassomod.authentication_statement_new(authenticationMethod,
+                                                     sessionIndex,
+                                                     reauthenticateOnOrAfter,
+                                                     nameIdentifier,
+                                                     nameQualifier,
+                                                     format,
+                                                     idp_nameIdentifier,
+                                                     idp_nameQualifier,
+                                                     idp_format,
+                                                     confirmationMethod)
+        if _obj is None:
+            raise Error('lasso_authentication_statement_new() failed')
+        Node.__init__(self, _obj=_obj)
diff --git a/python/lassomod.c b/python/lassomod.c
index ae3c2712..49e86b31 100644
--- a/python/lassomod.c
+++ b/python/lassomod.c
@@ -25,20 +25,34 @@
 #include "lassomod.h"
 
 #include "py_lasso.h"
+
 #include "xml/py_xml.h"
+#include "xml/py_lib_authn_request.h"
+#include "xml/py_lib_federation_termination_notification.h"
+#include "xml/py_lib_logout_request.h"
+#include "xml/py_lib_name_identifier_mapping_request.h"
+#include "xml/py_lib_register_name_identifier_request.h"
+#include "xml/py_saml_assertion.h"
+#include "xml/py_saml_authentication_statement.h"
+#include "xml/py_saml_name_identifier.h"
+
 #include "protocols/py_authn_request.h"
+#include "protocols/py_authn_response.h"
+#include "protocols/py_federation_termination_notification.h"
 #include "protocols/py_logout_request.h"
 #include "protocols/py_logout_response.h"
-#include "protocols/py_register_name_identifier_request.h"
-#include "protocols/py_register_name_identifier_response.h"
-#include "protocols/py_federation_termination_notification.h"
 #include "protocols/py_name_identifier_mapping_request.h"
 #include "protocols/py_name_identifier_mapping_response.h"
+#include "protocols/py_register_name_identifier_request.h"
+#include "protocols/py_register_name_identifier_response.h"
+
+#include "protocols/elements/py_assertion.h"
+#include "protocols/elements/py_authentication_statement.h"
 
 static PyMethodDef lasso_methods[] = {
   /* py_lasso.h */
   {"init",                init,                METH_VARARGS},
-  {"shutdown",            shutdown,            METH_VARARGS},
+  {"shutdown",            shutdown2,           METH_VARARGS},
   {"check_version_exact", check_version_exact, METH_VARARGS},
   {"check_version",       check_version,       METH_VARARGS},
   {"check_version_ext",   check_version_ext,   METH_VARARGS},
@@ -52,65 +66,98 @@ static PyMethodDef lasso_methods[] = {
   {"node_url_encode",       node_url_encode,       METH_VARARGS},
   {"node_verify_signature", node_verify_signature, METH_VARARGS},
 
-  /* protocols */
-  /* py_logout_request.h */
-  {"logout_request_getattr",      logout_request_getattr,      METH_VARARGS},
-  {"logout_request",              logout_request,              METH_VARARGS},
+  /* py_lib_authn_request.h */
+  {"lib_authn_request_new",                 lib_authn_request_new,                 METH_VARARGS},
+  {"lib_authn_request_set_forceAuthn",      lib_authn_request_set_forceAuthn,      METH_VARARGS},
+  {"lib_authn_request_set_isPassive",       lib_authn_request_set_isPassive,       METH_VARARGS},
+  {"lib_authn_request_set_protocolProfile", lib_authn_request_set_protocolProfile, METH_VARARGS},
 
-  {"logout_request_set_sessionIndex", logout_request_set_sessionIndex, METH_VARARGS},
-  {"logout_request_set_relayState",   logout_request_set_relayState,   METH_VARARGS},
-  {"logout_request_set_consent",      logout_request_set_consent,      METH_VARARGS},
+  /* py_lib_federation_termination_notification.h */
+  {"lib_federation_termination_notification_new",         lib_federation_termination_notification_new,         METH_VARARGS},
+  {"lib_federation_termination_notification_set_consent", lib_federation_termination_notification_set_consent, METH_VARARGS},
 
-  /* py_logout_response.h */
-  {"logout_response_getattr", logout_response_getattr, METH_VARARGS},
-  {"logout_response",         logout_response,         METH_VARARGS},
+  /* py_lib_logout_request.h */
+  {"lib_logout_request_new",                lib_logout_request_new,                METH_VARARGS},
+  {"lib_logout_request_set_consent",        lib_logout_request_set_consent,        METH_VARARGS},
+  {"lib_logout_request_set_nameIdentifier", lib_logout_request_set_nameIdentifier, METH_VARARGS},
+  {"lib_logout_request_set_providerID",     lib_logout_request_set_providerID,     METH_VARARGS},
+  {"lib_logout_request_set_relayState",     lib_logout_request_set_relayState,     METH_VARARGS},
+  {"lib_logout_request_set_sessionIndex",   lib_logout_request_set_sessionIndex,   METH_VARARGS},
 
-  /* py_register_name_identifier_request.h */
-  {"register_name_identifier_request_getattr",        register_name_identifier_request_getattr,        METH_VARARGS},
-  {"register_name_identifier_request",                register_name_identifier_request,                METH_VARARGS},
-  {"register_name_identifier_request_change_attribute_names_identifiers",
-       register_name_identifier_request_change_attribute_names_identifiers, METH_VARARGS},
-  {"register_name_identifier_request_set_relayState", register_name_identifier_request_set_relayState, METH_VARARGS},
+  /* py_lib_name_identifier_mapping_request.h */
+  {"lib_name_identifier_mapping_request_new",         lib_name_identifier_mapping_request_new,         METH_VARARGS},
+  {"lib_name_identifier_mapping_request_set_consent", lib_name_identifier_mapping_request_set_consent, METH_VARARGS},
 
-  /* py_register_name_identifier_response.h */
-  {"register_name_identifier_response_getattr", register_name_identifier_response_getattr, METH_VARARGS},
-  {"register_name_identifier_response",         register_name_identifier_response,         METH_VARARGS},
+  /* py_lib_register_name_identifier_request.h */
+  {"lib_register_name_identifier_request_new",            lib_register_name_identifier_request_new,            METH_VARARGS},
+  {"lib_register_name_identifier_request_set_relayState", lib_register_name_identifier_request_set_relayState, METH_VARARGS},
+
+  /* py_saml_assertion.h */
+  {"saml_assertion_new",                         saml_assertion_new,                         METH_VARARGS},
+  {"saml_assertion_add_authenticationStatement", saml_assertion_add_authenticationStatement, METH_VARARGS},
+
+  /* py_saml_authentication_statement.h */
+  {"saml_authentication_statement_new", saml_authentication_statement_new, METH_VARARGS},
 
+  /* py_saml_name_identifier.h */
+  {"saml_name_identifier_new",               saml_name_identifier_new,               METH_VARARGS},
+  {"saml_name_identifier_set_format",        saml_name_identifier_set_format,        METH_VARARGS},
+  {"saml_name_identifier_set_nameQualifier", saml_name_identifier_set_nameQualifier, METH_VARARGS},
+
+  /* protocols */
   /* py_authn_request.h */
   {"authn_request_new",                     authn_request_new,                     METH_VARARGS},
   {"authn_request_set_requestAuthnContext", authn_request_set_requestAuthnContext, METH_VARARGS},
   {"authn_request_set_scoping",             authn_request_set_scoping,             METH_VARARGS},
+  {"authn_request_get_protocolProfile", authn_request_get_protocolProfile, METH_VARARGS},
 
   /* py_authn_response.h */
-/*   {"authn_response_getattr",       authn_response_getattr,       METH_VARARGS}, */
-/*   {"authn_response_create",        authn_response_create,        METH_VARARGS}, */
-/*   {"authn_response_init",          authn_response_init,          METH_VARARGS}, */
-/*   {"authn_response_add_assertion", authn_response_add_assertion, METH_VARARGS}, */
-/*   {"assertion_build",                       assertion_build,                       METH_VARARGS}, */
-/*   {"assertion_add_authenticationStatement", assertion_add_authenticationStatement, METH_VARARGS}, */
-/*   {"authentication_statement_build", authentication_statement_build, METH_VARARGS}, */
+  {"authn_response_getattr",                       authn_response_getattr,                       METH_VARARGS},
+  {"authn_response_new",                           authn_response_new,                           METH_VARARGS},
+  {"authn_response_add_assertion",                 authn_response_add_assertion,                 METH_VARARGS},
+  {"authn_response_must_authenticate",             authn_response_must_authenticate,             METH_VARARGS},
+  {"authn_response_process_authentication_result", authn_response_process_authentication_result, METH_VARARGS},
+  {"authn_response_verify_signature",              authn_response_verify_signature,              METH_VARARGS},
 
+  /* py_federation_termination_notification.h */
+  {"federation_termination_notification_new", federation_termination_notification_new, METH_VARARGS},
+
+  /* py_logout_request.h */
+  {"logout_request_new", logout_request_new, METH_VARARGS},
+
+  /* py_logout_response.h */
+  {"logout_response_new", logout_response_new, METH_VARARGS},
+
+  /* py_name_identifier_mapping_request.h */
+  {"name_identifier_mapping_request_new", name_identifier_mapping_request_new, METH_VARARGS},
+
+  /* py_name_identifier_mapping_response.h */
+  {"name_identifier_mapping_response_new", name_identifier_mapping_response_new, METH_VARARGS},
+
+  /* py_register_name_identifier_request.h */
+  {"register_name_identifier_request_new", register_name_identifier_request_new, METH_VARARGS},
+  {"register_name_identifier_request_change_attribute_names_identifiers",
+       register_name_identifier_request_change_attribute_names_identifiers, METH_VARARGS},
+
+  /* py_register_name_identifier_response.h */
+  {"register_name_identifier_response_new", register_name_identifier_response_new, METH_VARARGS},
+
+  /* py_request.h */
 /*   {"request_create", request_create, METH_VARARGS}, */
 /*   {"request_getattr", request_getattr, METH_VARARGS}, */
 
+  /* py_response.h */
 /*   {"response_create", response_create, METH_VARARGS}, */
 /*   {"response_getattr", response_getattr, METH_VARARGS}, */
 /*   {"response_init", response_init, METH_VARARGS}, */
 /*   {"response_add_assertion", response_add_assertion, METH_VARARGS}, */
 
-  /* py_federation_termination_notification.h */
-  {"federation_termination_notification_getattr", federation_termination_notification_getattr, METH_VARARGS},
-  {"federation_termination_notification",  federation_termination_notification,  METH_VARARGS},
-  {"federation_termination_notification_set_consent",  federation_termination_notification_set_consent,  METH_VARARGS},
-
-  /* py_name_identifier_mapping_request.h */
-  {"name_identifier_mapping_request_getattr", name_identifier_mapping_request_getattr, METH_VARARGS},
-  {"name_identifier_mapping_request",  name_identifier_mapping_request,  METH_VARARGS},
-  {"name_identifier_mapping_request_set_consent",  name_identifier_mapping_request_set_consent,  METH_VARARGS},
-
-  {"name_identifier_mapping_response_getattr", name_identifier_mapping_response_getattr, METH_VARARGS},
-  {"name_identifier_mapping_response",  name_identifier_mapping_response,  METH_VARARGS},
+  /* protocols/elements */
+  /* assertion.h */
+  {"assertion_new", assertion_new, METH_VARARGS},
 
+  /* authentication_statement.h */
+  {"authentication_statement_new", authentication_statement_new, METH_VARARGS},
 
   {NULL, NULL} /* End of Methods Sentinel */
 };
diff --git a/python/py_lasso.c b/python/py_lasso.c
index 0ff9c751..b3998e13 100644
--- a/python/py_lasso.c
+++ b/python/py_lasso.c
@@ -30,9 +30,8 @@ PyObject *init(PyObject *self, PyObject *args) {
   return (int_wrap(lasso_init()));
 }
 
-PyObject *shutdown(PyObject *self, PyObject *args) {
-  //return (int_wrap(lasso_shutdown()));
-  return (int_wrap(0));
+PyObject *shutdown2(PyObject *self, PyObject *args) {
+  return (int_wrap(lasso_shutdown()));
 }
 
 PyObject *check_version_exact(PyObject *self, PyObject *args) {
diff --git a/python/py_lasso.h b/python/py_lasso.h
index 772db156..aa51a8b9 100644
--- a/python/py_lasso.h
+++ b/python/py_lasso.h
@@ -26,7 +26,7 @@
 #define __PYLASSO_PY_LASSO_H__
 
 PyObject *init(PyObject *self, PyObject *args);
-PyObject *shutdown(PyObject *self, PyObject *args);
+PyObject *shutdown2(PyObject *self, PyObject *args);
 PyObject *check_version_exact(PyObject *self, PyObject *args);
 PyObject *check_version(PyObject *self, PyObject *args);
 PyObject *check_version_ext(PyObject *self, PyObject *args);
diff --git a/python/setup.py b/python/setup.py
index 255da0b3..0b8149ed 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -187,15 +187,27 @@ library_dirs.append('../lasso/.libs')
 libraries.append('lasso')
 
 em = Extension("lassomod",
-               sources = ["py_lasso.c", "xml/py_xml.c",
+               sources = ["py_lasso.c",
+                          "xml/py_xml.c",
+                          "xml/py_lib_authn_request.c",
+                          "xml/py_lib_federation_termination_notification.c",
+                          "xml/py_lib_logout_request.c",
+                          "xml/py_lib_name_identifier_mapping_request.c",
+                          "xml/py_lib_register_name_identifier_request.c",
+                          "xml/py_saml_assertion.c",
+                          "xml/py_saml_authentication_statement.c",
+                          "xml/py_saml_name_identifier.c",
 			  "protocols/py_authn_request.c",
+			  "protocols/py_authn_response.c",
+                          "protocols/py_federation_termination_notification.c",
 			  "protocols/py_logout_request.c",
                           "protocols/py_logout_response.c",
-                          "protocols/py_register_name_identifier_request.c",
-                          "protocols/py_register_name_identifier_response.c",
-                          "protocols/py_federation_termination_notification.c",
                           "protocols/py_name_identifier_mapping_request.c",
                           "protocols/py_name_identifier_mapping_response.c",
+                          "protocols/py_register_name_identifier_request.c",
+                          "protocols/py_register_name_identifier_response.c",
+                          "protocols/elements/py_assertion.c",
+                          "protocols/elements/py_authentication_statement.c",
                           "lassomod.c",
                           "utils.c", "wrap_objs.c"],
                define_macros = define_macros,
diff --git a/python/wrap_objs.c b/python/wrap_objs.c
index 777aa8e0..793cb66c 100644
--- a/python/wrap_objs.c
+++ b/python/wrap_objs.c
@@ -79,7 +79,7 @@ PyObject *xmlCharPtr_wrap(xmlChar *str) {
   }
   ret = PyString_FromString((char *) str);
   /* deallocation */
-  xmlFree(str);
+  //xmlFree(str);
   return (ret);
 }