Ticket #12: assertion_query_metadata.patch

File assertion_query_metadata.patch, 23.2 kB (added by bdauvergne, 8 months ago)

Patch adding load of role associated to assertions queries, complete assertion_query profile object

  • a/lasso/id-ff/defederation.c

    old new  
    175175        if (remote_providerID != NULL) { 
    176176                profile->remote_providerID = g_strdup(remote_providerID); 
    177177        } else { 
    178                 profile->remote_providerID = lasso_server_get_first_providerID(profile->server); 
     178                LassoProvider *my_provider = LASSO_PROVIDER(profile->server); 
     179                LassoProviderRole role = LASSO_PROVIDER_ROLE_IDP; 
     180                if (my_provider->role == LASSO_PROVIDER_ROLE_IDP) { 
     181                        role = LASSO_PROVIDER_ROLE_SP; 
     182                } 
     183                profile->remote_providerID = lasso_server_get_first_providerID_by_role(profile->server, role); 
    179184                if (profile->remote_providerID == NULL) { 
    180185                        return critical_error(LASSO_SERVER_ERROR_PROVIDER_NOT_FOUND); 
    181186                } 
  • a/lasso/id-ff/login.c

    old new  
    12441244        if (remote_providerID != NULL) { 
    12451245                profile->remote_providerID = g_strdup(remote_providerID); 
    12461246        } else { 
    1247                 profile->remote_providerID = lasso_server_get_first_providerID(profile->server); 
     1247                profile->remote_providerID = lasso_server_get_first_providerID_by_role(profile->server, LASSO_PROVIDER_ROLE_IDP); 
    12481248                if (profile->remote_providerID == NULL) { 
    12491249                        return critical_error(LASSO_SERVER_ERROR_PROVIDER_NOT_FOUND); 
    12501250                } 
  • a/lasso/id-ff/provider.c

    old new  
    3636 
    3737#include <lasso/saml-2.0/providerprivate.h> 
    3838 
    39 static char *protocol_uris[] = { 
     39static char *protocol_uris[LASSO_MD_PROTOCOL_TYPE_LAST] = { 
    4040        "http://projectliberty.org/profiles/fedterm", 
    4141        "http://projectliberty.org/profiles/nim", 
    4242        "http://projectliberty.org/profiles/rni", 
    4343        "http://projectliberty.org/profiles/slo", 
    4444        NULL /* none for single sign on */ 
    4545}; 
    46 static char *protocol_md_nodename[] = { 
     46static char *protocol_md_nodename[LASSO_MD_PROTOCOL_TYPE_LAST] = { 
    4747        "FederationTerminationNotificationProtocolProfile", 
    4848        "NameIdentifierMappingProtocolProfile", 
    4949        "RegisterNameIdentifierProtocolProfile", 
    5050        "SingleLogoutProtocolProfile", 
    5151        "SingleSignOnProtocolProfile" 
    5252}; 
    53 static char *protocol_roles[] = { NULL, "sp", "idp"}; 
    54 char *protocol_methods[] = {"", "", "", "", "", "-http", "-soap"}; 
     53static char *protocol_roles[LASSO_PROVIDER_ROLE_LAST] = {  
     54        NULL, "sp", "idp",  
     55        "authn-authority", "pdp", "attribute-authority"  
     56}; 
     57char *protocol_methods[LASSO_HTTP_METHOD_LAST] = { 
     58        "", "", "", "",  
     59        "", "-http", "-soap" 
     60}; 
    5561 
    5662/*****************************************************************************/ 
    5763/* public methods */ 
     
    8086        if (sid == NULL) 
    8187                sid = provider->private_data->default_assertion_consumer; 
    8288 
    83         descriptor = provider->private_data->SPDescriptor
     89        descriptor = provider->private_data->Descriptors
    8490        if (descriptor == NULL) 
    8591                return NULL; 
    8692 
     
    110116        GHashTable *descriptor; 
    111117 
    112118        g_return_val_if_fail(LASSO_IS_PROVIDER(provider), NULL); 
    113         descriptor = provider->private_data->SPDescriptor; /* default to SP */ 
    114         if (provider->role == LASSO_PROVIDER_ROLE_IDP) 
    115                 descriptor = provider->private_data->IDPDescriptor; 
     119        descriptor = provider->private_data->Descriptors; /* default to SP */ 
    116120        if (descriptor == NULL) 
    117121                return NULL; 
    118122 
     
    141145        GHashTable *descriptor; 
    142146 
    143147        g_return_val_if_fail(LASSO_IS_PROVIDER(provider), NULL); 
    144         descriptor = provider->private_data->SPDescriptor; /* default to SP */ 
    145         if (provider->role == LASSO_PROVIDER_ROLE_IDP) 
    146                 descriptor = provider->private_data->IDPDescriptor; 
     148        descriptor = provider->private_data->Descriptors; 
    147149 
    148150        return g_hash_table_lookup(descriptor, name); 
    149151} 
     
    424426{ 
    425427        xmlNode *xmlnode; 
    426428        LassoProvider *provider = LASSO_PROVIDER(node); 
    427         char *roles[] = { "None", "SP", "IdP"}; 
     429        char *roles[LASSO_PROVIDER_ROLE_LAST] = { "None", "SP", "IdP", "AuthnAuthority", "PDP", "AttributeAuthority"}; 
    428430        char *encryption_mode[] = { "None", "NameId", "Assertion", "Both" }; 
    429431 
    430432        xmlnode = parent_class->get_xmlNode(node, lasso_dump); 
     
    447449init_from_xml(LassoNode *node, xmlNode *xmlnode) 
    448450{ 
    449451        LassoProvider *provider = LASSO_PROVIDER(node); 
     452        char *roles[LASSO_PROVIDER_ROLE_LAST] = { "None", "SP", "IdP", "AuthnAuthority", "PDP", "AttributeAuthority"}; 
    450453        xmlChar *s; 
     454        int i; 
    451455 
    452456        parent_class->init_from_xml(node, xmlnode); 
    453457         
     
    457461 
    458462        /* Load provider role */ 
    459463        s = xmlGetProp(xmlnode, (xmlChar*)"ProviderRole"); 
    460         if (s != NULL && strcmp((char*)s, "SP") == 0) { 
    461                 provider->role = LASSO_PROVIDER_ROLE_SP; 
    462         } else if (s != NULL && strcmp((char*)s, "IdP") == 0) { 
    463                 provider->role = LASSO_PROVIDER_ROLE_IDP; 
     464        provider->role = LASSO_PROVIDER_ROLE_NONE; 
     465        i = LASSO_PROVIDER_ROLE_NONE; 
     466        while (i < LASSO_PROVIDER_ROLE_LAST) { 
     467                if (strcmp((char*)s, roles[i]) == 0) { 
     468                        provider->role = i; 
     469                        break; 
     470                } 
     471                i++; 
    464472        } 
    465473        if (s != NULL) { 
    466474                xmlFree(s); 
     
    519527        } 
    520528        provider->private_data->dispose_has_run = TRUE; 
    521529 
    522         if (provider->private_data->IDPDescriptor) { 
    523                 g_hash_table_foreach(provider->private_data->IDPDescriptor, 
    524                                 (GHFunc)free_list_strings, NULL); 
    525                 g_hash_table_destroy(provider->private_data->IDPDescriptor); 
    526         } 
    527         provider->private_data->IDPDescriptor = NULL; 
    528  
    529         if (provider->private_data->SPDescriptor) { 
    530                 g_hash_table_foreach(provider->private_data->SPDescriptor, 
     530        if (provider->private_data->Descriptors) { 
     531                g_hash_table_foreach(provider->private_data->Descriptors, 
    531532                                (GHFunc)free_list_strings, NULL); 
    532                 g_hash_table_destroy(provider->private_data->SPDescriptor); 
     533                g_hash_table_destroy(provider->private_data->Descriptors); 
    533534        } 
    534         provider->private_data->SPDescriptor = NULL; 
     535        provider->private_data->Descriptors = NULL; 
    535536 
    536537        if (provider->private_data->organization) { 
    537538                xmlFreeNode(provider->private_data->organization); 
     
    614615        provider->private_data->encryption_mode = LASSO_ENCRYPTION_MODE_NONE; 
    615616 
    616617        /* no value_destroy_func since it shouldn't destroy the GList on insert */ 
    617         provider->private_data->IDPDescriptor = g_hash_table_new_full( 
    618                         g_str_hash, g_str_equal, g_free, NULL); 
    619         provider->private_data->SPDescriptor = g_hash_table_new_full( 
     618        provider->private_data->Descriptors = g_hash_table_new_full( 
    620619                        g_str_hash, g_str_equal, g_free, NULL); 
     620        provider->private_data->attributes = NULL; 
    621621} 
    622622 
    623623static void 
     
    729729        xpathObj = xmlXPathEvalExpression((xmlChar*)xpath_idp, xpathCtx); 
    730730        if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr == 1) { 
    731731                load_descriptor(xpathObj->nodesetval->nodeTab[0], 
    732                                 provider->private_data->IDPDescriptor, provider); 
     732                                provider->private_data->Descriptors, provider); 
    733733                if (provider->private_data->conformance < LASSO_PROTOCOL_LIBERTY_1_2) { 
    734734                        /* lookup ProviderID */ 
    735735                        node = xpathObj->nodesetval->nodeTab[0]->children; 
     
    747747        xpathObj = xmlXPathEvalExpression((xmlChar*)xpath_sp, xpathCtx); 
    748748        if (xpathObj && xpathObj->nodesetval && xpathObj->nodesetval->nodeNr == 1) { 
    749749                load_descriptor(xpathObj->nodesetval->nodeTab[0], 
    750                                 provider->private_data->SPDescriptor, provider); 
     750                                provider->private_data->Descriptors, provider); 
    751751                if (provider->private_data->conformance < LASSO_PROTOCOL_LIBERTY_1_2) { 
    752752                        /* lookup ProviderID */ 
    753753                        node = xpathObj->nodesetval->nodeTab[0]->children; 
  • a/lasso/id-ff/provider.h

    old new  
    7070        LASSO_HTTP_METHOD_REDIRECT, 
    7171        LASSO_HTTP_METHOD_SOAP, 
    7272        LASSO_HTTP_METHOD_ARTIFACT_GET, 
    73         LASSO_HTTP_METHOD_ARTIFACT_POST 
     73        LASSO_HTTP_METHOD_ARTIFACT_POST, 
     74        LASSO_HTTP_METHOD_LAST 
    7475} LassoHttpMethod; 
    7576 
    7677 
     
    9596        LASSO_MD_PROTOCOL_TYPE_SINGLE_SIGN_ON, 
    9697        LASSO_MD_PROTOCOL_TYPE_ARTIFACT_RESOLUTION, 
    9798        LASSO_MD_PROTOCOL_TYPE_MANAGE_NAME_ID, 
    98         LASSO_MD_PROTOCOL_TYPE_ASSERTION_ID_REQUEST 
     99        LASSO_MD_PROTOCOL_TYPE_ASSERTION_ID_REQUEST, 
     100        LASSO_MD_PROTOCOL_TYPE_AUTHN_QUERY, 
     101        LASSO_MD_PROTOCOL_TYPE_AUTHZ, 
     102        LASSO_MD_PROTOCOL_TYPE_ATTRIBUTE, 
     103        LASSO_MD_PROTOCOL_TYPE_LAST 
    99104} LassoMdProtocolType; 
    100105 
    101106 
     
    108113 * Provider Role. 
    109114 **/ 
    110115typedef enum { 
     116        LASSO_PROVIDER_ROLE_ANY = -1, 
    111117        LASSO_PROVIDER_ROLE_NONE = 0, 
     118        LASSO_PROVIDER_ROLE_IDP, 
    112119        LASSO_PROVIDER_ROLE_SP, 
    113         LASSO_PROVIDER_ROLE_IDP 
     120        LASSO_PROVIDER_ROLE_AUTHN_AUTHORITY, 
     121        LASSO_PROVIDER_ROLE_PDP, 
     122        LASSO_PROVIDER_ROLE_ATTRIBUTE_AUTHORITY, 
     123        LASSO_PROVIDER_ROLE_LAST 
    114124} LassoProviderRole; 
    115125 
    116126 
  • a/lasso/id-ff/providerprivate.h

    old new  
    4747        gboolean dispose_has_run; 
    4848 
    4949        LassoProtocolConformance conformance; 
    50         GHashTable *SPDescriptor; 
     50        GHashTable *Descriptors; 
     51        GList *attributes; /* of LassoSaml2Attribute */ 
    5152        char *default_assertion_consumer; 
    52         GHashTable *IDPDescriptor; 
    5353        xmlNode *organization; 
    5454 
    5555        char *affiliation_owner_id; 
  • a/lasso/saml-2.0/assertion_query.c

    old new  
    3030#include <lasso/id-ff/identityprivate.h> 
    3131#include <lasso/id-ff/serverprivate.h> 
    3232#include <lasso/xml/xml_enc.h> 
     33#include <lasso/xml/saml-2.0/saml2_assertion.h> 
    3334#include <lasso/xml/saml-2.0/samlp2_assertion_id_request.h> 
    3435#include <lasso/xml/saml-2.0/samlp2_authn_query.h> 
    3536#include <lasso/xml/saml-2.0/samlp2_attribute_query.h> 
     
    7071        LassoFederation *federation; 
    7172        LassoSamlp2RequestAbstract *request; 
    7273 
     74        g_return_val_if_fail(http_method == LASSO_HTTP_METHOD_ANY ||  
     75                        http_method == LASSO_HTTP_METHOD_SOAP,  
     76                        LASSO_PARAM_ERROR_INVALID_VALUE); 
    7377        g_return_val_if_fail(LASSO_IS_ASSERTION_QUERY(assertion_query), 
    7478                        LASSO_PARAM_ERROR_INVALID_VALUE); 
    75         g_return_val_if_fail(remote_provider_id != NULL, LASSO_PARAM_ERROR_INVALID_VALUE); 
    7679 
    7780        profile = LASSO_PROFILE(assertion_query); 
    7881 
     
    8285        } 
    8386 
    8487        /* set the remote provider id */ 
    85         profile->remote_providerID = g_strdup(remote_provider_id); 
     88        profile->remote_providerID = NULL; 
     89        if (remote_provider_id) { 
     90                profile->remote_providerID = g_strdup(remote_provider_id); 
     91        } else { 
     92                LassoProviderRole role = LASSO_PROVIDER_ROLE_NONE; 
     93                switch (query_request_type) { 
     94                        case LASSO_ASSERTION_QUERY_REQUEST_TYPE_AUTHN: 
     95                                role = LASSO_PROVIDER_ROLE_AUTHN_AUTHORITY; 
     96                                break; 
     97                        case LASSO_ASSERTION_QUERY_REQUEST_TYPE_ATTRIBUTE: 
     98                                role = LASSO_PROVIDER_ROLE_ATTRIBUTE_AUTHORITY; 
     99                                break; 
     100                        case LASSO_ASSERTION_QUERY_REQUEST_TYPE_AUTHZ_DECISION: 
     101                                role = LASSO_PROVIDER_ROLE_PDP; 
     102                                break; 
     103                } 
     104                profile->remote_providerID =  
     105                        lasso_server_get_first_providerID_by_role(profile->server, 
     106                                                                role); 
     107        } 
     108        g_return_val_if_fail(profile->remote_providerID != NULL,  
     109                LASSO_PARAM_ERROR_INVALID_VALUE); 
    86110 
     111        /* Lookup the remote provider */ 
    87112        remote_provider = g_hash_table_lookup(profile->server->providers, 
    88113                        profile->remote_providerID); 
    89114        if (LASSO_IS_PROVIDER(remote_provider) == FALSE) { 
    90115                return critical_error(LASSO_SERVER_ERROR_PROVIDER_NOT_FOUND); 
    91116        } 
    92  
    93         /* XXX: check HTTP method is supported */ 
    94  
     117         
    95118        assertion_query->private_data->query_request_type = query_request_type; 
    96119        switch (query_request_type) { 
    97120                case LASSO_ASSERTION_QUERY_REQUEST_TYPE_ASSERTION_ID: 
     
    111134        } 
    112135 
    113136        if (query_request_type != LASSO_ASSERTION_QUERY_REQUEST_TYPE_ASSERTION_ID) { 
     137                LassoSaml2NameID *nameID = NULL; 
    114138                /* fill <Subject> */ 
    115139                LassoSamlp2SubjectQueryAbstract *subject_query; 
    116140 
    117141                /* Get federation */ 
    118                 federation = g_hash_table_lookup(profile->identity->federations, 
    119                                 profile->remote_providerID); 
    120                 if (LASSO_IS_FEDERATION(federation) == FALSE) { 
    121                         return critical_error(LASSO_PROFILE_ERROR_FEDERATION_NOT_FOUND); 
    122                 } /* XXX: should support looking up transient id */ 
    123  
     142                if (profile->session) { 
     143                        LassoSaml2Assertion *assertion; 
     144                        assertion = LASSO_SAML2_ASSERTION(lasso_session_get_assertion( 
     145                                        profile->session, (gchar*)profile->remote_providerID)); 
     146                        if (assertion && assertion->Subject) { 
     147                                nameID = assertion->Subject->NameID; 
     148                        } 
     149                } 
     150                if (nameID == NULL) { 
     151                        federation = g_hash_table_lookup(profile->identity->federations, 
     152                                        profile->remote_providerID); 
     153                        if (LASSO_IS_FEDERATION(federation) == FALSE) { 
     154                                return critical_error(LASSO_PROFILE_ERROR_FEDERATION_NOT_FOUND); 
     155                        } /* XXX: should support looking up transient id */ 
     156                        nameID = LASSO_SAML2_NAME_ID(lasso_profile_get_nameIdentifier(profile)); 
     157                } 
    124158                subject_query = LASSO_SAMLP2_SUBJECT_QUERY_ABSTRACT(profile->request); 
    125159                subject_query->Subject = LASSO_SAML2_SUBJECT(lasso_saml2_subject_new()); 
    126                 subject_query->Subject->NameID =LASSO_SAML2_NAME_ID( 
    127                                 lasso_profile_get_nameIdentifier(profile)); 
    128  
     160                subject_query->Subject->NameID = g_object_ref(nameID); 
    129161        } 
    130  
     162        /* Setup usual request attributes */ 
    131163        request = LASSO_SAMLP2_REQUEST_ABSTRACT(profile->request); 
    132164        request->ID = lasso_build_unique_id(32); 
    133165        request->Version = g_strdup("2.0"); 
     
    135167                        LASSO_PROVIDER(profile->server)->ProviderID)); 
    136168        request->IssueInstant = lasso_get_current_time(); 
    137169 
     170        request->sign_method = LASSO_SIGNATURE_METHOD_RSA_SHA1; 
     171        if (profile->server->certificate) { 
     172                request->sign_type = LASSO_SIGNATURE_TYPE_WITHX509; 
     173        } else { 
     174                request->sign_type = LASSO_SIGNATURE_TYPE_SIMPLE; 
     175        } 
     176        request->private_key_file = g_strdup(profile->server->private_key); 
     177        request->certificate_file = g_strdup(profile->server->certificate); 
     178 
    138179        profile->http_request_method = http_method; 
    139180 
    140181        return 0; 
     
    166207        if (LASSO_IS_PROVIDER(remote_provider) == FALSE) { 
    167208                return critical_error(LASSO_SERVER_ERROR_PROVIDER_NOT_FOUND); 
    168209        } 
    169  
    170210        if (profile->http_request_method == LASSO_HTTP_METHOD_SOAP) { 
    171                 if (assertion_query->private_data->query_request_type == \ 
    172                                 LASSO_ASSERTION_QUERY_REQUEST_TYPE_ASSERTION_ID) { 
    173                         profile->msg_url = lasso_provider_get_metadata_one(remote_provider, 
    174                                         "AssertionIDRequestService SOAP"); 
    175                 } else { 
    176                         profile->msg_url = lasso_provider_get_metadata_one(remote_provider, 
    177                                         "AttributeService SOAP"); 
     211                LassoAssertionQueryRequestType type; 
     212                /* XXX: support only SOAP */ 
     213                static const gchar *servicepoints[LASSO_ASSERTION_QUERY_REQUEST_TYPE_LAST] = { 
     214                        "AssertionIDRequestService SOAP", 
     215                        "AuthnQueryService SOAP", 
     216                        "AuthzService SOAP", 
     217                        "AttributeService SOAP"  
     218                }; 
     219                type = assertion_query->private_data->query_request_type; 
     220                if (type <= LASSO_ASSERTION_QUERY_REQUEST_TYPE_ASSERTION_ID || 
     221                    type >= LASSO_ASSERTION_QUERY_REQUEST_TYPE_AUTHZ_DECISION) { 
     222                        return LASSO_PARAM_ERROR_INVALID_VALUE; 
    178223                } 
    179                 /* XXX set private key so message is signed */ 
     224                profile->msg_url = lasso_provider_get_metadata_one(remote_provider, 
     225                                        servicepoints[type]); 
     226 
     227                /* XXX set private key so message is signed */ 
    180228                profile->msg_body = lasso_node_export_to_soap(profile->request); 
    181229                return 0; 
    182230        } 
     
    228276        /* verify signatures */ 
    229277        profile->signature_status = lasso_provider_verify_signature( 
    230278                        remote_provider, request_msg, "ID", LASSO_MESSAGE_FORMAT_SOAP); 
    231         profile->signature_status = 0; /* XXX: signature check disabled for zxid */ 
     279 
     280//      profile->signature_status = 0; /* XXX: signature check disabled for zxid */ 
    232281 
    233282        profile->http_request_method = LASSO_HTTP_METHOD_SOAP; 
    234283 
  • a/lasso/saml-2.0/assertion_query.h

    old new  
    6767        LASSO_ASSERTION_QUERY_REQUEST_TYPE_AUTHN, 
    6868        LASSO_ASSERTION_QUERY_REQUEST_TYPE_ATTRIBUTE, 
    6969        LASSO_ASSERTION_QUERY_REQUEST_TYPE_AUTHZ_DECISION, 
     70        LASSO_ASSERTION_QUERY_REQUEST_TYPE_LAST 
    7071} LassoAssertionQueryRequestType; 
    7172 
    7273struct _LassoAssertionQuery { 
  • a/lasso/saml-2.0/ecp.c

    old new  
    170170        xmlOutputBufferClose(buf); 
    171171        xmlFreeDoc(doc); 
    172172 
    173         profile->remote_providerID = lasso_server_get_first_providerID(profile->server); 
     173        profile->remote_providerID = lasso_server_get_first_providerID_by_role(profile->server, LASSO_PROVIDER_ROLE_IDP); 
    174174        if (profile->remote_providerID == NULL) { 
    175175                return critical_error(LASSO_SERVER_ERROR_PROVIDER_NOT_FOUND); 
    176176        } 
  • a/lasso/saml-2.0/provider.c

    old new  
    2626 
    2727#include <lasso/saml-2.0/providerprivate.h> 
    2828#include <lasso/id-ff/providerprivate.h> 
     29#include <lasso/xml/saml-2.0/saml2_attribute.h> 
    2930 
    30 const char *profile_names[] = { 
     31const char *profile_names[LASSO_MD_PROTOCOL_TYPE_LAST] = { 
    3132        "", /* No fedterm in SAML 2.0 */ 
    32         "NameIDMappingService", 
     33        "NameIDMappingService",  /*IDPSSODescriptor*/ 
    3334        "", /* No rni in SAML 2.0 */ 
    34         "SingleLogoutService", 
    35         "SingleSignOnService", 
    36         "ArtifactResolutionService", 
    37         "ManageNameIDService", 
    38         "AssertionIDRequestService", 
    39         NULL 
     35        "SingleLogoutService",   /*SSODescriptor*/ 
     36        "SingleSignOnService",  /*IDPSSODescriptor*/ 
     37        "ArtifactResolutionService",  /*SSODescriptor*/ 
     38        "ManageNameIDService",    /*SSODescriptor*/ 
     39        "AssertionIDRequestService", /* IDPSSODescriptor, 
     40                                        AuthnAuhtorityDescriptor, 
     41                                        PDPDescriptor, 
     42                                        AttributeAuthorityDescriptor */ 
     43        "AuthnQueryService",  /*AuthnAuthorityDescriptor*/ 
     44        "AuthzService",  /*PDPDescriptor*/ 
     45        "AttributeService" /*AttributeAuthorityDescriptor*/ 
    4046}; 
    4147 
    4248static void 
     
    7278                        t = t->next; 
    7379                        continue; 
    7480                } 
     81                if (strcmp((char*)t->name, "Attribute") == 0) { 
     82                        LassoSaml2Attribute *attribute; 
     83                        attribute = LASSO_SAML2_ATTRIBUTE(lasso_node_new_from_xmlNode(t)); 
     84                        if (attribute) { 
     85                                provider->private_data->attributes = 
     86                                        g_list_append(provider->private_data->attributes, attribute); 
     87                        } 
     88                        continue; 
     89                } 
    7590                binding = (char*)xmlGetProp(t, (xmlChar*)"Binding"); 
    7691                if (binding) { 
    7792                        /* Endpoint type */ 
     
    109124                                name = g_strdup_printf("%s %s %s", t->name, binding_s, index); 
    110125                                xmlFree(index); 
    111126                                xmlFree(is_default); 
    112                         } else { 
     127                        }  
     128                        else { 
    113129                                name = g_strdup_printf("%s %s", t->name, binding_s); 
    114130                        } 
    115131                        xmlFree(binding); 
     
    179195 
    180196                if (strcmp((char*)descriptor_node->name, "IDPSSODescriptor") == 0) { 
    181197                        load_descriptor(descriptor_node, 
    182                                         provider->private_data->IDPDescriptor, provider); 
     198                                        provider->private_data->Descriptors, provider); 
    183199                        provider->role = LASSO_PROVIDER_ROLE_IDP; 
    184200                        continue; 
    185201                } 
    186202 
    187203                if (strcmp((char*)descriptor_node->name, "SPSSODescriptor") == 0) { 
    188204                        load_descriptor(descriptor_node, 
    189                                         provider->private_data->SPDescriptor, provider); 
     205                                        provider->private_data->Descriptors, provider); 
    190206                        provider->role = LASSO_PROVIDER_ROLE_SP; 
    191207                        continue; 
    192208                } 
    193209 
     210               if (strcmp((char*)descriptor_node->name, "AttributeAuthorityDescriptor") == 0) { 
     211                        load_descriptor(descriptor_node, 
     212                                        provider->private_data->Descriptors, provider); 
     213                        provider->role = LASSO_PROVIDER_ROLE_ATTRIBUTE_AUTHORITY; 
     214                        continue; 
     215                } 
     216 
     217               if (strcmp((char*)descriptor_node->name, "PDPDescriptor") == 0) { 
     218                        load_descriptor(descriptor_node, 
     219                                        provider->private_data->Descriptors, provider); 
     220                        provider->role = LASSO_PROVIDER_ROLE_PDP; 
     221                        continue; 
     222                } 
     223 
     224               if (strcmp((char*)descriptor_node->name, "AuthnAuthorityDescriptor") == 0) { 
     225                        load_descriptor(descriptor_node, 
     226                                        provider->private_data->Descriptors, provider); 
     227                        provider->role = LASSO_PROVIDER_ROLE_AUTHN_AUTHORITY; 
     228                        continue; 
     229                } 
     230 
    194231                if (strcmp((char*)descriptor_node->name, "Organization") == 0) { 
    195232                        provider->private_data->organization = xmlCopyNode( 
    196233                                        descriptor_node, 1); 
     
    216253                LASSO_HTTP_METHOD_SOAP, LASSO_HTTP_METHOD_REDIRECT, LASSO_HTTP_METHOD_POST 
    217254        }; 
    218255                         
    219         if (remote_provider->role == LASSO_PROVIDER_ROLE_SP) 
    220                 provider->role = LASSO_PROVIDER_ROLE_IDP; 
    221         if (remote_provider->role == LASSO_PROVIDER_ROLE_IDP) 
    222                 provider->role = LASSO_PROVIDER_ROLE_SP; 
    223  
    224256        for (i=0; possible_bindings[i] && method == LASSO_HTTP_METHOD_NONE; i++) { 
    225257                char *s; 
    226258                GList *l1, *l2; 
     
    255287                sid = g_strdup_printf("%d", service_id); 
    256288        } 
    257289 
    258         descriptor = provider->private_data->SPDescriptor
     290        descriptor = provider->private_data->Descriptors
    259291        if (descriptor == NULL) 
    260292                return NULL; 
    261293 
     
    292324        char *binding_s = NULL; 
    293325        int lname; 
    294326 
    295         descriptor = provider->private_data->SPDescriptor
     327        descriptor = provider->private_data->Descriptors
    296328        if (descriptor == NULL) 
    297329                return NULL; 
    298330 
     
    355387                sid = g_strdup_printf("%d", service_id); 
    356388        } 
    357389 
    358         descriptor = provider->private_data->SPDescriptor
     390        descriptor = provider->private_data->Descriptors
    359391        if (descriptor == NULL) 
    360392                return NULL; 
    361393 
     
    380412                LassoMdProtocolType protocol_type, LassoHttpMethod http_method, 
    381413                gboolean initiate_profile) 
    382414{        
    383         LassoProviderRole initiating_role; 
    384415        char *protocol_profile; 
    385416        char *http_methods[] = { 
    386417                NULL, 
     
    394425                NULL 
    395426        }; 
    396427 
    397  
    398         initiating_role = remote_provider->role; 
    399         if (remote_provider->role == LASSO_PROVIDER_ROLE_SP) { 
    400                 provider->role = LASSO_PROVIDER_ROLE_IDP; 
    401         } 
    402         if (remote_provider->role == LASSO_PROVIDER_ROLE_IDP) { 
    403                 provider->role = LASSO_PROVIDER_ROLE_SP; 
    404         } 
    405         if (initiate_profile) 
    406                 initiating_role = provider->role; 
    407  
    408428        protocol_profile = g_strdup_printf("%s %s", profile_names[protocol_type], 
    409429                        http_methods[http_method+1]); 
    410430