*** empty log message ***

10 files changed, 406 insertions, 215 deletions

diff --git a/lasso/Attic/protocols/identity.c b/lasso/Attic/protocols/identity.c
index c7dd3c03..dce69443 100644
--- a/lasso/Attic/protocols/identity.c
+++ b/lasso/Attic/protocols/identity.c
@@ -28,6 +28,40 @@
 /* public methods                                                            */
 /*****************************************************************************/
 
+xmlChar *
+lasso_identity_dump(LassoIdentity *identity)
+{
+  LassoNode *identity_node, *nameIdentifier;
+  LassoNodeClass *identity_class, *class;
+
+  identity_node = lasso_node_new();
+  identity_class = LASSO_NODE_GET_CLASS(identity_node);
+  identity_class->set_name(identity_node, "Identity");
+
+  /* set the remote providerID */
+  identity_class->set_prop(identity_node, "RemoteProviderID", identity->remote_providerID);
+
+  /* add the remote name identifier */
+  if(identity->remote_nameIdentifier){
+    nameIdentifier = lasso_node_new();
+    class = LASSO_NODE_GET_CLASS(nameIdentifier);
+    class->set_name(nameIdentifier, "RemoteNameIdentifier");
+    class->add_child(nameIdentifier, identity->remote_nameIdentifier, FALSE);
+    identity_class->add_child(identity_node, nameIdentifier, FALSE);
+  }
+
+  /* add the local name identifier */
+  if(identity->local_nameIdentifier){
+    nameIdentifier = lasso_node_new();
+    class = LASSO_NODE_GET_CLASS(nameIdentifier);
+    class->set_name(nameIdentifier, "LocalNameIdentifier");
+    class->add_child(nameIdentifier, identity->local_nameIdentifier, FALSE);
+    identity_class->add_child(identity_node, nameIdentifier, FALSE);
+  }
+
+  return(lasso_node_export(identity_node));
+}
+
 void
 lasso_identity_set_local_nameIdentifier(LassoIdentity *identity,
 					LassoNode     *nameIdentifier)
@@ -88,7 +122,7 @@ GType lasso_identity_get_type() {
       (GInstanceInitFunc) lasso_identity_instance_init,
     };
     
-    this_type = g_type_register_static(LASSO_TYPE_NODE,
+    this_type = g_type_register_static(G_TYPE_OBJECT,
 				       "LassoIdentity",
 				       &this_info, 0);
   }
@@ -106,3 +140,13 @@ lasso_identity_new(gchar *remote_providerID)
 
   return(identity);
 }
+
+LassoIdentity*
+lasso_identity_new_from_dump(xmlChar *dump)
+{
+  LassoIdentity *identity;
+
+  identity = LASSO_IDENTITY(g_object_new(LASSO_TYPE_IDENTITY, NULL));
+
+  return(identity);
+}
diff --git a/lasso/Attic/protocols/identity.h b/lasso/Attic/protocols/identity.h
index 38711829..9f5eb7cd 100644
--- a/lasso/Attic/protocols/identity.h
+++ b/lasso/Attic/protocols/identity.h
@@ -44,7 +44,7 @@ typedef struct _LassoIdentity LassoIdentity;
 typedef struct _LassoIdentityClass LassoIdentityClass;
 
 struct _LassoIdentity {
-  LassoNode parent;
+  GObject parent;
   
   gchar *remote_providerID;
 
@@ -55,16 +55,19 @@ struct _LassoIdentity {
 };
 
 struct _LassoIdentityClass {
-  LassoNodeClass parent;
+  GObjectClass parent;
 };
 
 LASSO_EXPORT GType          lasso_identity_get_type                  (void);
 
 LASSO_EXPORT LassoIdentity *lasso_identity_new                       (gchar *remote_providerID);
+LASSO_EXPORT LassoIdentity *lasso_identity_new_from_dump             (xmlChar *dump);
 
+LASSO_EXPORT xmlChar       *lasso_identity_dump                      (LassoIdentity *identity);
+LASSO_EXPORT LassoNode     *lasso_identity_get_remote_nameIdentifier (LassoIdentity *identity);
+LASSO_EXPORT LassoNode     *lasso_identity_get_local_nameIdentifier  (LassoIdentity *identity);
 LASSO_EXPORT void           lasso_identity_set_local_nameIdentifier  (LassoIdentity *identity,
 								      LassoNode     *nameIdentifier);
-
 LASSO_EXPORT void           lasso_identity_set_remote_nameIdentifier (LassoIdentity *identity,
 								      LassoNode     *nameIdentifier);
 
diff --git a/lasso/Attic/protocols/provider.c b/lasso/Attic/protocols/provider.c
index eac45141..ec5abedc 100644
--- a/lasso/Attic/protocols/provider.c
+++ b/lasso/Attic/protocols/provider.c
@@ -29,6 +29,26 @@
 /*****************************************************************************/
 
 xmlChar *
+lasso_provider_dump(LassoProvider *provider)
+{
+  LassoNode *provider_node;
+  LassoNodeClass *provider_class;
+
+  provider_node = lasso_node_new();
+
+  /* set the public key, certificate, metadata */
+  provider_class = LASSO_NODE_GET_CLASS(provider_node);
+  provider_class->set_name(provider_node, "Provider");
+  provider_class->add_child(provider_node, provider->metadata, FALSE);
+  if(provider->public_key)
+    provider_class->set_prop(provider_node, "PublicKey", provider->public_key);
+  if(provider->certificate)
+    provider_class->set_prop(provider_node, "Certificate", provider->certificate);
+
+  return(lasso_node_export(provider_node));
+}
+
+xmlChar *
 lasso_provider_get_assertionConsumerServiceURL(LassoProvider *provider)
 {
   return(lasso_node_get_child_content(provider->metadata, "AssertionConsumerServiceURL", NULL));
@@ -96,9 +116,7 @@ static xmlChar *lasso_provider_get_direct_child_content(LassoProvider *provider,
 static void
 lasso_provider_instance_init(LassoProvider *provider)
 {
-    LassoNodeClass *class = LASSO_NODE_GET_CLASS(LASSO_NODE(provider));
 
-    class->set_name(LASSO_NODE(provider), "Provider");
 }
 
 static void
@@ -121,7 +139,7 @@ GType lasso_provider_get_type() {
       (GInstanceInitFunc) lasso_provider_instance_init,
     };
     
-    this_type = g_type_register_static(LASSO_TYPE_NODE,
+    this_type = g_type_register_static(G_TYPE_OBJECT,
 				       "LassoProvider",
 				       &this_info, 0);
   }
diff --git a/lasso/Attic/protocols/provider.h b/lasso/Attic/protocols/provider.h
index acb873a6..aefc72ff 100644
--- a/lasso/Attic/protocols/provider.h
+++ b/lasso/Attic/protocols/provider.h
@@ -42,7 +42,7 @@ typedef struct _LassoProvider LassoProvider;
 typedef struct _LassoProviderClass LassoProviderClass;
 
 struct _LassoProvider {
-  LassoNode parent;
+  GObject parent;
 
   LassoNode *metadata;
 
@@ -53,7 +53,7 @@ struct _LassoProvider {
 };
 
 struct _LassoProviderClass {
-  LassoNodeClass parent;
+  GObjectClass parent;
 };
 
 LASSO_EXPORT GType          lasso_provider_get_type                         (void);
diff --git a/lasso/id-ff/logout.c b/lasso/id-ff/logout.c
index 8532704b..1006791a 100644
--- a/lasso/id-ff/logout.c
+++ b/lasso/id-ff/logout.c
@@ -28,121 +28,180 @@
 /* public methods                                                            */
 /*****************************************************************************/
 
-xmlChar *lasso_logout_build_request(LassoLogout *logout){
-     char          *protocolProfile;
-     char          *message, *url, *query, *nameIdentifier, *nameQualifier, *format;
-     LassoNode     *request, identifier;
-     LassoProvider *provider;
-
-     provider = lasso_server_find_provider(logout->server, logout->peer_providerID);
-     if(!provider)
-	  return(NULL);
-
-     identifier = lasso_user_get_nameIdentifier_by_peer_providerID(logout->user, logout->peer_providerID);
-     nameIdentifier = lasso_nameIdentifier_get_content(identifier);
-     nameQualifier = lasso_nameIdentifier_get_nameQualifier(identifier);
-     format = lasso_nameIdentifier_get_format(identifier);
-     
-     request = lasso_logout_request_new(logout->local_providerID,
-					nameIdentifier,
-					nameQualifier,
-					format);
-     if(!request)
-	  return(NULL);
-
-     url = lasso_provider_get_singleLogoutServiceUrl(provider);
-     if(!url)
-	  return(NULL);
-
-     protocolProfile = lasso_provider_get_singleLogoutProtocolProfile(provider);
-     if(!protocolProfile)
-	  return(NULL);
-
-     /* FIXME : do we need to store the url in the logout context ? */
-     if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpHttp) ||
-	xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpHttp)){
-	  /* FIXME : use a constant instead a integer for the signature method */
-	  query = lasso_node_export_to_query(logout->request, 0, logout->server->private_key);
-          /* FIXME : use a more proper method to allocate the message ? */
-	  message = (xmlChar *)malloc(strlen(url)+strlen(query)+2); /* +2 : ? and end of line */
-	  sprintf(message , "%s?%s", url, query);
-	  logout->request_protocol_method = lasso_protocol_method_redirect;
-     }
-     else if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpSoap) ||
-	xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpSoap)){
-	  message = lasso_node_exort_to_soap(logout->request);
-	  logout->request_protocol_method = lasso_protocol_method_soap;
-     }
-
-     return(message);
+xmlChar *
+lasso_logout_build_request_msg(LassoLogout *logout)
+{
+  LassoProfileContext *profileContext;
+  LassoProvider *provider;
+  xmlChar *protocolProfile;
+  
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+
+  /* get the prototocol profile of the logout */
+  provider = lasso_server_get_provider(profileContext->server, profileContext->remote_providerID);
+  if(provider==NULL){
+    printf("provider not found\n");
+    return(NULL);
+  }
+
+  protocolProfile = lasso_provider_get_singleLogoutProtocolProfile(provider);
+  if(protocolProfile==NULL){
+    printf("No protocol profile for logout request message\n");
+    return(NULL);
+  }
+
+  if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpSoap) || xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpSoap)){
+    logout->url = lasso_provider_get_singleLogoutServiceUrl(provider);
+    logout->method = lassoProfileContextMethodSoap;
+    return(lasso_node_export_to_soap(profileContext->request));
+  }
+
+  return(NULL);
+}
+
+xmlChar *
+lasso_logout_build_response_msg(LassoLogout *logout)
+{
+  LassoProfileContext *profileContext;
+  LassoProvider *provider;
+  xmlChar *protocolProfile;
+  
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+
+  /* get the prototocol profile of the logout */
+  provider = lasso_server_get_provider(profileContext->server, profileContext->remote_providerID);
+  if(provider==NULL){
+    printf("provider not found\n");
+    return(NULL);
+  }
+
+  protocolProfile = lasso_provider_get_singleLogoutProtocolProfile(provider);
+  if(protocolProfile==NULL){
+    printf("No protocol profile for logout response message\n");
+    return(NULL);
+  }
+
+  if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpSoap) || xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpSoap)){
+    logout->url = lasso_provider_get_singleLogoutServiceUrl(provider);
+    logout->method = lassoProfileContextMethodSoap;
+    return(lasso_node_export_to_soap(profileContext->response));
+  }
+
+  return(NULL);
+}
+
+gint
+lasso_logout_init_request(LassoLogout *logout,
+			  xmlChar     *remote_providerID)
+{
+  LassoProfileContext *profileContext;
+  LassoNode           *nameIdentifier;
+  LassoIdentity       *identity;
+  LassoLogoutRequest  *request;
+
+  xmlChar *content, *nameQualifier, *format;
+
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+
+  /* get identity */
+  identity = lasso_user_get_identity(profileContext->user, profileContext->remote_providerID);
+  if(!identity)
+    return(1);
+
+  /* get the name identifier (!!! depend on the provider type : SP or IDP !!!)*/
+  switch(logout->provider_type){
+  case lassoProfileContextServiceProviderType:
+    nameIdentifier = LASSO_NODE(lasso_identity_get_local_nameIdentifier(identity, profileContext->remote_providerID));
+    if(!nameIdentifier)
+      nameIdentifier = LASSO_NODE(lasso_identity_get_remote_nameIdentifier(identity, profileContext->remote_providerID));
+    break;
+  case lassoProfileContextIdentityProviderType:
+    /* get the next assertion ( next authenticated service provider ) */
+    nameIdentifier = LASSO_NODE(lasso_identity_get_remote_nameIdentifier(identity, profileContext->remote_providerID));
+    if(!nameIdentifier)
+      nameIdentifier = LASSO_NODE(lasso_identity_get_local_nameIdentifier(identity, profileContext->remote_providerID));
+    break;
+  }
+  
+  if(!nameIdentifier){
+    printf("error, name identifier not found\n");
+    return(2);
+  }
+
+  /* build the request */
+  content = lasso_node_get_content(nameIdentifier);
+  nameQualifier = lasso_node_get_attr_value(nameIdentifier, "NameQualifier");
+  format = lasso_node_get_attr_value(nameIdentifier, "Format");
+  profileContext->request = lasso_logout_request_new(lasso_provider_get_providerID(LASSO_PROVIDER(profileContext->server)),
+						     content,
+						     nameQualifier,
+						     format);
+
+  return(0);
+}
+
+gint lasso_logout_handle_request(LassoLogout *logout, xmlChar *request_msg, gint request_method)
+{
+  LassoProfileContext *profileContext;
+  xmlChar *statusCodeValue = lassoSamlStatusCodeSuccess;
+  LassoNode *nameIdentifier;
+
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+
+  /* parse LogoutRequest */
+  switch(request_method){
+  case lassoProfileContextMethodSoap:
+    profileContext->request = lasso_logout_request_new_from_soap(request_msg);
+    break;
+  case lassoProfileContextMethodRedirect:
+    printf("TODO, implement the redirect method\n");
+    break;
+  case lassoProfileContextMethodGet:
+    printf("TODO, implement the get method\n");
+    break;
+  default:
+    printf("error while parsing the request\n");
+    return(0);
+  }
+
+  /* set LogoutResponse */
+  profileContext->response = lasso_logout_response_new(lasso_provider_get_providerID(LASSO_PROVIDER(profileContext->server)),
+						       statusCodeValue,
+						       profileContext->request);
+
+  /* Verify federation and */
+  nameIdentifier = lasso_node_get_child(profileContext->request, "NameIdentifier", NULL);
+  if(lasso_user_verify_federation(profileContext->user, nameIdentifier)==FALSE){
+    // TODO : implement a simple method to set the status code value
+    
+  }
+
+  /* verify authentication (if ok, delete assertion) */
+  if(lasso_user_verify_authentication(profileContext->user, nameIdentifier)==FALSE){
+    // TODO : implement verify authentication
+  }
+
+  return(1);
 }
 
-xmlChar *lasso_logout_process_request(LassoLogout *logout,
-				      gchar       *request,
-				      gint         request_method){
-
-     LassoNode     *nameIdentifier, *identity;
-     LassoProvider *provider;
-     char          *protocolProfile;
-     xmlChar       *url, *query, *message;
-
-     switch(request_method){
-     case lasso_protocol_method_redirect:
-	  logout->request = lasso_logout_request_new_from_query(request);
-	  break;
-     case lasso_protocol_method_soap:
-	  logout->request = lasso_logout_request_new_from_soap(request);
-	  break;
-     default:
-	  return(NULL);
-     }
-
-     logout->response = lasso_logout_response_new(logout->local_providerID, lassoSamlStatusCodeSuccess, logout->request);
-
-     logout->peer_providerID = lasso_logout_request_get_providerID(logout->request);
-     
-     /* older and odd method : lasso_node_get_child(logout->request, "NameIdentifier", NULL); */
-     nameIdentifier = lasso_logout_request_get_nameIdentifier(logout->request);
-
-     if(!lasso_profile_context_verify_federation(logout->user, logout->peer_providerID, nameIdentifier)){
-	  lasso_logout_response_set_statusCode_value(logout->response, lassoLibStatusCodeFederationDoesNotExist);
-	  logout->response_status_code_value = lasso_status_response_federation_does_not_exists;
-     }
-
-     if(!lasso_logout_verify_authentication(logout->user, logout->peer_providerID, nameIdentifier)){
-	  lasso_logout_response_set_statusCode_value(logout->response, lassoSamlStatusCodeRequestDenied);
-	  logout->response_status_code_value = lasso_status_response_request_denied;
-     }
-
-     provider = lasso_server_find_provider(logout->server, logout->peer_providerID);
-     if(!provider)
-	  return(NULL);
-
-     url = lasso_provider_get_singleLogoutProtocolServiceReturnUrl(provider);
-     if(!url)
-	  return(NULL);
-
-     protocolProfile = lasso_provider_get_singleLogoutProtocolProfile(provider);
-     if(!protocolProfile)
-	  return(NULL);
-
-     /* FIXME : do we need to store the url in the logout context ? */
-     if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpHttp) ||
-	xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpHttp)){
-	  query = lasso_node_export_to_query(request, 0, NULL);
-	  message = (char *)malloc(strlen(url)+strlen(query)+2); /* FIXME */
-	  sprintf(message , "%s?%s", url, query);
-	  logout->request_protocol_method = lasso_protocol_method_redirect;
-     }
-     else if(xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloSpSoap) ||
-	xmlStrEqual(protocolProfile, lassoLibProtocolProfileSloIdpSoap)){
-	  message = lasso_node_exort_to_soap(request);
-	  logout->request_protocol_method = lasso_protocol_method_soap;
-     }
-
-     logout->response_status_code_value = lasso_status_response_success;
-
-     return(message);
+gint lasso_logout_handle_response(LassoLogout *logout, xmlChar *response_msg, gint response_method)
+{
+  LassoProfileContext *profileContext;
+  gint codeError;
+
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+
+  /* parse LogoutResponse */
+  if(response_method==lassoProfileContextMethodSoap){
+    profileContext->response = lasso_logout_response_new_from_soap(response_msg);
+  }
+    
+  /* verify status code value */
+  // TODO : do the developer needs to get the value of the status code with the level 2 of lasso ?
+  // node = lasso_node_get_child(profileContext->response, "StatusCode", NULL);
+  // statusCodeValue = lasso_node_get_attr_value(node, "Value");
+  
+  return(codeError);
 }
 
 /*****************************************************************************/
@@ -154,7 +213,7 @@ lasso_logout_instance_init(LassoLogout *logout){
 }
 
 static void
-lasso_identity_class_init(LassoLogoutClass *klass) {
+lasso_logout_class_init(LassoLogoutClass *klass) {
 }
 
 GType lasso_logout_get_type() {
@@ -173,19 +232,29 @@ GType lasso_logout_get_type() {
       (GInstanceInitFunc) lasso_logout_instance_init,
     };
     
-    this_type = g_type_register_static(LASSO_TYPE_NODE,
+    this_type = g_type_register_static(LASSO_TYPE_PROFILE_CONTEXT,
 				       "LassoLogout",
 				       &this_info, 0);
   }
   return this_type;
 }
 
-LassoLogout*
-lasso_logout_new()
+LassoLogout *
+lasso_logout_new(LassoServer *server,
+		 LassoUser   *user,
+		 gint         provider_type)
 {
   LassoLogout *logout;
+  LassoProfileContext *profileContext;
 
+  /* set the logout object */
   logout = g_object_new(LASSO_TYPE_LOGOUT, NULL);
+  logout->provider_type = provider_type;
+
+  /* set the properties */
+  profileContext = LASSO_PROFILE_CONTEXT(logout);
+  profileContext->user = user;
+  profileContext->server = server;
 
   return(logout);
 }
diff --git a/lasso/id-ff/logout.h b/lasso/id-ff/logout.h
index f31764c8..9815a612 100644
--- a/lasso/id-ff/logout.h
+++ b/lasso/id-ff/logout.h
@@ -31,6 +31,8 @@ extern "C" {
 #endif /* __cplusplus */ 
 
 #include <lasso/xml/xml.h>
+#include <lasso/environs/profile_context.h>
+#include <lasso/protocols/logout_request.h>
 
 #define LASSO_TYPE_LOGOUT (lasso_logout_get_type())
 #define LASSO_LOGOUT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), LASSO_TYPE_LOGOUT, LassoLogout))
@@ -43,7 +45,9 @@ typedef struct _LassoLogout LassoLogout;
 typedef struct _LassoLogoutClass LassoLogoutClass;
 
 struct _LassoLogout {
-  LassoContext parent;
+  LassoProfileContext parent;
+  int method;
+  int provider_type;
 
   /*< private >*/
 };
@@ -54,12 +58,12 @@ struct _LassoLogoutClass {
 };
 
 LASSO_EXPORT GType        lasso_logout_get_type        (void);
-LASSO_EXPORT LassoLogout *lasso_logout_new             (char *peer_providerID);
+LASSO_EXPORT LassoLogout *lasso_logout_new             (LassoServer *server,
+							LassoUser   *user,
+							gint         provider_type);
+
+
 
-LASSO_EXPORT xmlChar     *lasso_logout_build_request   (LassoLogout *logout);
-LASSO_EXPORT xmlChar     *lasso_logout_process_request (LassoLogout *logout,
-							gchar       *request,
-							gint         request_method);
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/lasso/id-ff/server.c b/lasso/id-ff/server.c
index 34e3c093..3314a551 100644
--- a/lasso/id-ff/server.c
+++ b/lasso/id-ff/server.c
@@ -28,6 +28,49 @@
 /* public methods                                                            */
 /*****************************************************************************/
 
+xmlChar *
+lasso_server_dump(LassoServer *server)
+{
+  LassoProvider *provider;
+  LassoNode *server_node, *providers_node;
+  LassoNodeClass *server_class, *providers_class;
+  xmlChar *signature_method_str, *dump;
+  gint i;
+
+  server_node = lasso_node_new();
+  server_class = LASSO_NODE_GET_CLASS(server_node);
+  server_class->set_name(server_node, "Server");
+
+  /* set private key and signature method */
+  if(server->private_key)
+    server_class->set_prop(server_node, "PrivateKey", server->private_key);
+
+  /* TODO : add the signature method in the dump */
+
+  /* set public key, certificate, metadata */
+  provider = LASSO_PROVIDER(server);
+  server_class->add_child(server_node, provider->metadata, FALSE);
+  if(provider->public_key)
+    server_class->set_prop(server_node, "PublicKey", provider->public_key);
+  if(provider->certificate)
+    server_class->set_prop(server_node, "Certificate", provider->certificate);
+
+  /* set Providers node */
+  providers_node = lasso_node_new();
+  providers_class = LASSO_NODE_GET_CLASS(providers_node);
+  providers_class->set_name(providers_node, "Providers");
+
+  /* add providers */
+  for(i = 0; i<server->providers->len; i++){
+    dump = lasso_provider_dump(g_ptr_array_index(server->providers, i));
+    providers_class->add_child(providers_node, lasso_node_new_from_dump(dump), TRUE);
+  }
+
+  server_class->add_child(server_node, providers_node, FALSE);
+
+  return(lasso_node_export(server_node));
+}
+
 gint
 lasso_server_add_provider(LassoServer *server,
 			  gchar       *metadata,
@@ -71,7 +114,6 @@ static void
 lasso_server_instance_init(LassoServer *server)
 {
   server->providers = g_ptr_array_new();
-
   server->private_key = NULL;
 }
 
@@ -129,3 +171,13 @@ lasso_server_new(const gchar *metadata,
 
   return(server);
 }
+
+LassoServer *
+lasso_server_new_from_dump(xmlChar *dump)
+{
+  LassoServer *server;
+
+  server = LASSO_SERVER(g_object_new(LASSO_TYPE_SERVER, NULL));
+
+  return(server);
+}
diff --git a/lasso/id-ff/server.h b/lasso/id-ff/server.h
index b1e1422c..8d70d795 100644
--- a/lasso/id-ff/server.h
+++ b/lasso/id-ff/server.h
@@ -61,19 +61,18 @@ LASSO_EXPORT LassoServer*   lasso_server_new                    (const gchar *me
 								 const gchar *private_key,
 								 const gchar *certificate,
 								 guint        signature_method);
+LASSO_EXPORT LassoServer   *lasso_server_new_from_dump          (xmlChar *dump);
 
 LASSO_EXPORT gint           lasso_server_add_provider           (LassoServer *server,
 								 gchar       *metadata,
 								 const gchar *public_key,
 								 const gchar *certificate);
 
+LASSO_EXPORT xmlChar       *lasso_server_dump                   (LassoServer *server);
+
 LASSO_EXPORT LassoProvider* lasso_server_get_provider           (LassoServer *server,
 								 gchar       *providerID);
 
-LASSO_EXPORT gint           lasso_server_set_security           (gchar *private_key,
-								 gchar *public_key,
-								 gchar *certificate);
-
 
 #ifdef __cplusplus
 }
diff --git a/lasso/id-ff/user.c b/lasso/id-ff/user.c
index 971f4d4c..e48a20a5 100644
--- a/lasso/id-ff/user.c
+++ b/lasso/id-ff/user.c
@@ -29,52 +29,53 @@
 /*****************************************************************************/
 
 static void
-lasso_user_node_identity_add(xmlChar *key, LassoIdentity *identity, LassoNode *userNode)
+lasso_user_dump_assertion(gpointer   key,
+			  gpointer   value,
+			  LassoNode *assertions)
 {
-  LassoNode *node, *child;
-  LassoNodeClass *class;
-
-  /* set the Identity node */
-/*   node = lasso_node_new(); */
-/*   class = LASSO_NODE_GET_CLASS(LASSO_NODE(node)); */
-/*   class->set_name(LASSO_NODE(node), "Identity"); */
-
-  /* add the remote provider id */
-/*   class->new_child(node, "RemoteProviderID", key, FALSE); */
-
-  /* add the local name identifier */
-/*   child = lasso_node_new(); */
-/*   class = LASSO_NODE_GET_CLASS(LASSO_NODE(node)); */
-/*   class->set_name(LASSO_NODE(node), "LocalNameIdentifier"); */
-/*   class->lasso_node_add_child(child, identity->local_nameIdentifier); */
-/*   class->lasso_node_add_child(node, child); */
-  
-  /* add the remote provider id */
-/*   child = lasso_node_new(); */
-/*   class = LASSO_NODE_GET_CLASS(LASSO_NODE(node)); */
-/*   class->set_name(LASSO_NODE(node), "RemoteNameIdentifier"); */
-/*   lasso_node_add_child(child, identity->remote_nameIdentifier); */
-/*   lasso_node_add_child(node, child); */
-
-  /* add the identity node to the user node */
-/*   lasso_node_add_child(userNode, identity); */
+
+}
+
+static void
+lasso_user_dump_identity(gpointer   key,
+			 gpointer   value,
+			 LassoNode *identities)
+{
+  LassoNode      *identity_node;
+  LassoNodeClass *identity_class;
+  xmlChar        *dump;
+
+  dump = lasso_identity_dump(value);
+  identity_node = lasso_node_new_from_dump(dump);
+  identity_class = LASSO_NODE_GET_CLASS(identity_node);
+  identity_class->add_child(identities, identity_node, TRUE);
 }
 
 xmlChar *
-lasso_user_export(LassoUser *user)
+lasso_user_dump(LassoUser *user)
 {
-  LassoNode *user_node, *identities, *assertions, *assertion_artifacts;
-  LassoNodeClass *class;
+  LassoNode      *user_node, *assertions_node, *identities_node;
+  LassoNodeClass *user_class, *assertions_class, *identities_class;
 
-  /* set the user node  */
   user_node = lasso_node_new();
-  class = LASSO_NODE_GET_CLASS(LASSO_NODE(user_node));
-  class->set_name(LASSO_NODE(user_node), "User");
-
-  /* insert all of the identity of the user */
-  g_hash_table_foreach(user->identities, lasso_user_node_identity_add, user);
-  
-  return(lasso_node_export(user));
+  user_class = LASSO_NODE_GET_CLASS(user_node);
+  user_class->set_name(user_node, "User");
+
+  /* dump the assertions */
+  assertions_node = lasso_node_new();
+  assertions_class = LASSO_NODE_GET_CLASS(assertions_node);
+  assertions_class->set_name(assertions_node, "Assertions");
+  g_hash_table_foreach(user->assertions, lasso_user_dump_assertion, assertions_node);
+  user_class->add_child(user_node, assertions_node, FALSE);
+
+  /* dump the identities */
+  identities_node = lasso_node_new();
+  identities_class = LASSO_NODE_GET_CLASS(identities_node);
+  identities_class->set_name(identities_node, "Identities");
+  g_hash_table_foreach(user->identities, lasso_user_dump_identity, identities_node);
+  user_class->add_child(user_node, identities_node, FALSE);
+
+  return(lasso_node_export(user_node));
 }
 
 void
@@ -82,45 +83,23 @@ lasso_user_add_assertion(LassoUser *user,
 			 xmlChar   *remote_providerID,
 			 LassoNode *assertion)
 {
-  g_hash_table_insert(user->assertions, remote_providerID, assertion);
+  g_hash_table_insert(user->assertions, g_strdup(remote_providerID), assertion);
 }
 
 LassoNode *
 lasso_user_get_assertion(LassoUser *user,
-			 xmlChar   *nameIdentifier)
-{
-  return(g_hash_table_lookup(user->assertions, nameIdentifier));
-}
-
-void
-lasso_user_store_response(LassoUser     *user,
-			  xmlChar       *assertionArtifact,
-			  LassoResponse *response)
+			 xmlChar   *remote_providerID)
 {
-  g_hash_table_insert(user->assertion_artifacts,
-		      g_strdup(assertionArtifact),
-		      lasso_node_copy(LASSO_NODE(response)));
+  return(g_hash_table_lookup(user->assertions, remote_providerID));
 }
 
-LassoNode *lasso_user_get_assertionArtifact(LassoUser *user,
-					    xmlChar   *artifact)
-{
-  LassoNode *assertion;
-
-  assertion = g_hash_table_lookup(user->assertion_artifacts, artifact);
-  if(assertion){
-    g_hash_table_steal(user->assertion_artifacts, artifact);
-  }
-
-  return(assertion);
-}
 
 void
 lasso_user_add_identity(LassoUser     *user,
 			xmlChar       *remote_providerID,
 			LassoIdentity *identity)
 {
-  g_hash_table_insert(user->identities, remote_providerID, identity);
+  g_hash_table_insert(user->identities, g_strdup(remote_providerID), identity);
 }
 
 LassoIdentity*
@@ -130,6 +109,7 @@ lasso_user_get_identity(LassoUser *user,
   return(g_hash_table_lookup(user->identities, remote_providerID));
 }
 
+
 /*****************************************************************************/
 /* instance and class init functions                                         */
 /*****************************************************************************/
@@ -139,7 +119,6 @@ lasso_user_instance_init(LassoUser *user)
 {
   user->identities = g_hash_table_new(g_str_hash,  g_str_equal);
   user->assertions = g_hash_table_new(g_str_hash,  g_str_equal);
-  user->assertion_artifacts = g_hash_table_new(g_str_hash,  g_str_equal);
 }
 
 static void
@@ -172,15 +151,43 @@ GType lasso_user_get_type() {
 }
 
 LassoUser*
-lasso_user_new(xmlChar *user_str)
+lasso_user_new()
+{
+  LassoUser *user;
+
+  user = LASSO_USER(g_object_new(LASSO_TYPE_USER, NULL));
+
+  return(user);
+}
+
+LassoUser*
+lasso_user_new_from_dump(xmlChar *dump)
 {
+  LassoNode *user_node, *identities_node;
+  LassoNodeClass *identities_class;
+  LassoIdentity *identity;
+  xmlNodePtr xmlNode;
   LassoUser *user;
+  xmlChar *remote_providerID;
 
   user = LASSO_USER(g_object_new(LASSO_TYPE_USER, NULL));
 
-  if(user_str){
-    /* parse the user str */
+  user_node = lasso_node_new_from_dump(dump);
+
+  /* set the assertions */
+
+  /* set the identities */
+  identities_node = lasso_node_get_child(user, "Identities", NULL);
+  identities_class = LASSO_NODE_GET_CLASS(user_node);
+  xmlNode = identities_class->get_xmlNode(identities_node);
+  xmlNode = xmlNode->children;
+  while(xmlNode){
+    if(xmlNode->type==XML_ELEMENT_NODE && xmlStrEqual(xmlNode->name, "Identity")){
+      identity = lasso_identity_new(xmlGetProp(xmlNode, "RemoteProviderID"));
+      lasso_identity_set_localNameIdentifier(user);
+    }
   }
 
+
   return(user);
 }
diff --git a/lasso/id-ff/user.h b/lasso/id-ff/user.h
index 611daf45..143a8c01 100644
--- a/lasso/id-ff/user.h
+++ b/lasso/id-ff/user.h
@@ -51,7 +51,6 @@ struct _LassoUser {
   /*< public >*/
   GHashTable *assertions;          /* hash for assertions with nameIdentifier as key */
   GHashTable *identities;          /* hash for identities with remote ProviderID as key */
-  GHashTable *assertion_artifacts; /* hash for temporary assertions with AssertionArtifact as key */
 
   /*< private >*/
 };
@@ -61,7 +60,10 @@ struct _LassoUserClass {
 };
 
 LASSO_EXPORT GType          lasso_user_get_type              (void);
-LASSO_EXPORT LassoUser*     lasso_user_new                   (xmlChar *user_str);
+LASSO_EXPORT LassoUser     *lasso_user_new                   (void);
+LASSO_EXPORT LassoUser     *lasso_user_new_from_dump         (xmlChar *dump);
+
+LASSO_EXPORT xmlChar       *lasso_user_dump                  (LassoUser *user);
 
 LASSO_EXPORT void           lasso_user_add_assertion         (LassoUser *user,
 							      xmlChar   *remote_providerID,
@@ -70,13 +72,6 @@ LASSO_EXPORT void           lasso_user_add_assertion         (LassoUser *user,
 LASSO_EXPORT LassoNode     *lasso_user_get_assertion         (LassoUser *user,
 							      xmlChar   *nameIdentifier);
 
-LASSO_EXPORT void           lasso_user_store_response        (LassoUser     *user,
-							      xmlChar       *assertionArtifact,
-							      LassoResponse *response);
-
-LASSO_EXPORT LassoNode     *lasso_user_get_assertionArtifact (LassoUser *user,
-							      xmlChar   *artifact);
-
 LASSO_EXPORT void           lasso_user_add_identity          (LassoUser     *user,
 							      xmlChar       *remote_providerID,
 							      LassoIdentity *identity);