xmlproviders/XMLMetadata.cpp

   1 /*
   2  * The Shibboleth License, Version 1.
   3  * Copyright (c) 2002
   4  * University Corporation for Advanced Internet Development, Inc.
   5  * All rights reserved
   6  *
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * Redistributions of source code must retain the above copyright notice, this
  12  * list of conditions and the following disclaimer.
  13  *
  14  * Redistributions in binary form must reproduce the above copyright notice,
  15  * this list of conditions and the following disclaimer in the documentation
  16  * and/or other materials provided with the distribution, if any, must include
  17  * the following acknowledgment: "This product includes software developed by
  18  * the University Corporation for Advanced Internet Development
  19  * <http://www.ucaid.edu>Internet2 Project. Alternately, this acknowledegement
  20  * may appear in the software itself, if and wherever such third-party
  21  * acknowledgments normally appear.
  22  *
  23  * Neither the name of Shibboleth nor the names of its contributors, nor
  24  * Internet2, nor the University Corporation for Advanced Internet Development,
  25  * Inc., nor UCAID may be used to endorse or promote products derived from this
  26  * software without specific prior written permission. For written permission,
  27  * please contact shibboleth@shibboleth.org
  28  *
  29  * Products derived from this software may not be called Shibboleth, Internet2,
  30  * UCAID, or the University Corporation for Advanced Internet Development, nor
  31  * may Shibboleth appear in their name, without prior written permission of the
  32  * University Corporation for Advanced Internet Development.
  33  *
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  36  * AND WITH ALL FAULTS. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  38  * PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED AND THE ENTIRE RISK
  39  * OF SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS WITH LICENSEE.
  40  * IN NO EVENT SHALL THE COPYRIGHT OWNER, CONTRIBUTORS OR THE UNIVERSITY
  41  * CORPORATION FOR ADVANCED INTERNET DEVELOPMENT, INC. BE LIABLE FOR ANY DIRECT,
  42  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  43  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  44  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  47  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 /* XMLMetadata.cpp - a metadata implementation that uses an XML-based registry
  51
  52    Scott Cantor
  53    9/27/02
  54
  55    $History:$
  56 */
  57
  58 #include "internal.h"
  59
  60 #include <sys/types.h>
  61 #include <sys/stat.h>
  62
  63 #include <log4cpp/Category.hh>
  64 #include <xercesc/util/XMLChar.hpp>
  65 #include <xsec/enc/XSECCryptoException.hpp>
  66 #include <xsec/enc/XSECKeyInfoResolverDefault.hpp>
  67 #include <xsec/enc/OpenSSL/OpenSSLCryptoX509.hpp>
  68
  69 using namespace shibboleth;
  70 using namespace saml;
  71 using namespace log4cpp;
  72 using namespace std;
  73
  74 namespace {
  75
  76     class XMLMetadataImpl : public ReloadableXMLFileImpl
  77     {
  78     public:
  79         class ContactPerson : public IContactPerson
  80         {
  81         public:
  82             ContactPerson(const DOMElement* e);
  83             ~ContactPerson() {}
  84
  85             ContactType getType() const { return m_type; }
  86             const char* getCompany() const { return m_company.get(); }
  87             const char* getGivenName() const { return m_givenName.get(); }
  88             const char* getSurName() const { return m_surName.get(); }
  89             Iterator<string> getEmailAddresses() const { return m_emails; }
  90             Iterator<string> getTelephoneNumbers() const { return m_phones; }
  91             const DOMElement* getElement() const { return m_root; }
  92
  93         private:
  94             const DOMElement* m_root;
  95             ContactType m_type;
  96             auto_ptr<char> m_givenName,m_surName,m_company;
  97             vector<string> m_emails,m_phones;
  98         };
  99
 100         class Organization : public IOrganization
 101         {
 102         public:
 103             Organization(const DOMElement* e);
 104             ~Organization() {}
 105
 106             const char* getName(const char* lang="en") const { return forLang(m_names,lang); }
 107             const char* getDisplayName(const char* lang="en") const { return forLang(m_displays,lang); }
 108             const char* getURL(const char* lang="en") const { return forLang(m_urls,lang); }
 109             const DOMElement* getElement() const { return m_root; }
 110
 111         private:
 112             const char* forLang(const map<string,string>& m, const char* lang) const {
 113                 map<string,string>::const_iterator i=m.find(lang);
 114                 return (i==m.end()) ? NULL : i->second.c_str();
 115             }
 116             const DOMElement* m_root;
 117             map<string,string> m_names,m_displays,m_urls;
 118         };
 119
 120         class EntityDescriptor;
 121
 122         class EncryptionMethod : public XENCEncryptionMethod
 123         {
 124         public:
 125             EncryptionMethod(const DOMElement* e);
 126             ~EncryptionMethod() {}
 127
 128             const XMLCh * getAlgorithm(void) const { return m_alg; }
 129             const XMLCh * getDigestMethod(void) const { return m_digest; }
 130             const XMLCh * getOAEPparams(void) const { return m_params; }
 131             int getKeySize(void) const { return m_size; }
 132             DOMElement* getElement(void) const { return const_cast<DOMElement*>(m_root); }
 133             void setDigestMethod(const XMLCh * method) {throw exception();}
 134             void setOAEPparams(const XMLCh * params) {throw exception();}
 135             void setKeySize(int size) {throw exception();}
 136
 137         private:
 138             const DOMElement* m_root;
 139             const XMLCh* m_alg;
 140             const XMLCh* m_digest;
 141             const XMLCh* m_params;
 142             int m_size;
 143         };
 144
 145         class KeyDescriptor : public IKeyDescriptor
 146         {
 147         public:
 148             KeyDescriptor(const DOMElement* e);
 149             ~KeyDescriptor();
 150
 151             KeyUse getUse() const { return m_use; }
 152             DSIGKeyInfoList* getKeyInfo() const { return &m_klist; }
 153             saml::Iterator<const XENCEncryptionMethod*> getEncryptionMethods() const { return m_methods; }
 154             const DOMElement* getElement() const { return m_root; }
 155
 156         private:
 157             const DOMElement* m_root;
 158             KeyUse m_use;
 159             mutable DSIGKeyInfoList m_klist;
 160             vector<const XENCEncryptionMethod*> m_methods;
 161         };
 162
 163         class Role : public virtual IRoleDescriptor
 164         {
 165         public:
 166             Role(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e);
 167             ~Role();
 168
 169             // External contract
 170             const IEntityDescriptor* getEntityDescriptor() const {return m_provider;}
 171             Iterator<const XMLCh*> getProtocolSupportEnumeration() const {return m_protocolEnum;}
 172             bool hasSupport(const XMLCh* protocol) const;
 173             const char* getErrorURL() const {return (m_errorURL ? m_errorURL : m_provider->getErrorURL());}
 174             bool isValid() const {return time(NULL) < m_validUntil;}
 175             Iterator<const IKeyDescriptor*> getKeyDescriptors() const {return m_keys;}
 176             const IOrganization* getOrganization() const {return m_org ? m_org : m_provider->getOrganization();}
 177             Iterator<const IContactPerson*> getContactPersons() const
 178                 {return (m_contacts.empty() ? m_provider->getContactPersons() : m_contacts);}
 179             const DOMElement* getElement() const {return m_root;}
 180
 181         protected:
 182             vector<const XMLCh*> m_protocolEnum;
 183             vector<const IKeyDescriptor*> m_keys;
 184
 185         private:
 186             const EntityDescriptor* m_provider;
 187             const DOMElement* m_root;
 188             XMLCh* m_protocolEnumCopy;
 189             char* m_errorURL;
 190             Organization* m_org;
 191             vector<const IContactPerson*> m_contacts;
 192             time_t m_validUntil;
 193         };
 194
 195         class Endpoint : public virtual IEndpoint
 196         {
 197         public:
 198             Endpoint(const DOMElement* e) : m_root(e),
 199                 m_binding(e->getAttributeNS(NULL,L(Binding))),
 200                 m_location(e->getAttributeNS(NULL,SHIB_L(Location))),
 201                 m_resploc(e->getAttributeNS(NULL,SHIB_L(ResponseLocation))) {}
 202             Endpoint(const XMLCh* binding, const XMLCh* loc)
 203                 : m_root(NULL), m_binding(binding), m_location(loc), m_resploc(NULL) {}
 204             ~Endpoint() {}
 205
 206             const XMLCh* getBinding() const { return m_binding; }
 207             const XMLCh* getLocation() const { return m_location; }
 208             const XMLCh* getResponseLocation() const { return m_resploc; }
 209             const DOMElement* getElement() const { return m_root; }
 210
 211         private:
 212             const DOMElement* m_root;
 213             const XMLCh* m_binding;
 214             const XMLCh* m_location;
 215             const XMLCh* m_resploc;
 216         };
 217
 218         class IndexedEndpoint : public Endpoint, public virtual IIndexedEndpoint
 219         {
 220         public:
 221             IndexedEndpoint(const DOMElement* e) : Endpoint(e), m_index(XMLString::parseInt(e->getAttributeNS(NULL,SHIB_L(index)))) {}
 222             unsigned short getIndex() const {return m_index;}
 223
 224         private:
 225             unsigned short m_index;
 226         };
 227
 228         class EndpointManager : public IEndpointManager
 229         {
 230         public:
 231             EndpointManager() : m_soft(NULL), m_hard(NULL) {}
 232             ~EndpointManager() {
 233                 for (vector<const IEndpoint*>::iterator i=m_endpoints.begin(); i!=m_endpoints.end(); i++)
 234                     delete const_cast<IEndpoint*>(*i);
 235             }
 236             saml::Iterator<const IEndpoint*> getEndpoints() const {return m_endpoints;}
 237             const IEndpoint* getDefaultEndpoint() const {
 238                 if (m_hard) return m_hard;
 239                 if (m_soft) return m_soft;
 240                 if (!m_endpoints.empty()) return *(m_endpoints.begin());
 241                 return NULL;
 242             }
 243             const IEndpoint* getEndpointByIndex(unsigned short index) const {
 244                 for (vector<const IEndpoint*>::const_iterator i=m_endpoints.begin(); i!=m_endpoints.end(); i++) {
 245                     const IIndexedEndpoint* temp=dynamic_cast<const IIndexedEndpoint*>(*i);
 246                     if (temp && index==temp->getIndex())
 247                         return temp;
 248                 }
 249                 return NULL;
 250             }
 251             const IEndpoint* getEndpointByBinding(const XMLCh* binding) const {
 252                 for (vector<const IEndpoint*>::const_iterator i=m_endpoints.begin(); i!=m_endpoints.end(); i++)
 253                     if (!XMLString::compareString(binding,(*i)->getBinding()))
 254                         return *i;
 255                 return NULL;
 256             }
 257             void add(IEndpoint* e) {
 258                 m_endpoints.push_back(e);
 259                 if (!m_hard && e->getElement()) {
 260                     const XMLCh* v=e->getElement()->getAttributeNS(NULL,SHIB_L(isDefault));
 261                     if (v && (*v==chDigit_1 || *v==chLatin_t))  // explicit default
 262                         m_hard=e;
 263                     else if ((!v || !*v) && !m_soft)            // implicit default
 264                         m_soft=e;
 265                 }
 266                 else if (!m_hard && !m_soft) {
 267                     // No default yet, so this one qualifies as an implicit.
 268                     m_soft=e;
 269                 }
 270             }
 271
 272         private:
 273             vector<const IEndpoint*> m_endpoints;
 274             const IEndpoint* m_soft;    // Soft default (not explicit)
 275             const IEndpoint* m_hard;    // Hard default (explicit)
 276         };
 277
 278         class SSORole : public Role, public virtual ISSODescriptor
 279         {
 280         public:
 281             SSORole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e);
 282             ~SSORole() {}
 283             const IEndpointManager* getArtifactResolutionServiceManager() const {return &m_artifact;}
 284             const IEndpointManager* getSingleLogoutServiceManager() const {return &m_logout;}
 285             const IEndpointManager* getManageNameIDServiceManager() const {return &m_nameid;}
 286             saml::Iterator<const XMLCh*> getNameIDFormats() const {return m_formats;}
 287
 288         private:
 289             EndpointManager m_artifact,m_logout,m_nameid;
 290             vector<const XMLCh*> m_formats;
 291         };
 292
 293         class ScopedRole : public virtual IScopedRoleDescriptor
 294         {
 295         public:
 296             ScopedRole(const DOMElement* e);
 297             saml::Iterator<std::pair<const XMLCh*,bool> > getScopes() const {return m_scopes;}
 298
 299         private:
 300             vector<pair<const XMLCh*,bool> > m_scopes;
 301         };
 302
 303         class IDPRole : public SSORole, public ScopedRole, public virtual IIDPSSODescriptor
 304         {
 305         public:
 306             IDPRole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e);
 307             ~IDPRole();
 308             bool getWantAuthnRequestsSigned() const {return m_wantAuthnRequestsSigned;}
 309             const IEndpointManager* getSingleSignOnServiceManager() const {return &m_sso;}
 310             const IEndpointManager* getNameIDMappingServiceManager() const {return &m_mapping;}
 311             const IEndpointManager* getAssertionIDRequestServiceManager() const {return &m_idreq;}
 312             saml::Iterator<const XMLCh*> getAttributeProfiles() const {return m_attrprofs;}
 313             saml::Iterator<const saml::SAMLAttribute*> getAttributes() const {return m_attrs;}
 314
 315         private:
 316             EndpointManager m_sso,m_mapping,m_idreq;
 317             vector<const XMLCh*> m_attrprofs;
 318             vector<const SAMLAttribute*> m_attrs;
 319             bool m_wantAuthnRequestsSigned;
 320             const XMLCh* m_sourceId;
 321             friend class EntityDescriptor;
 322         };
 323
 324         class AARole : public Role, public ScopedRole, public virtual IAttributeAuthorityDescriptor
 325         {
 326         public:
 327             AARole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e);
 328             ~AARole();
 329             const IEndpointManager* getAttributeServiceManager() const {return &m_query;}
 330             const IEndpointManager* getAssertionIDRequestServiceManager() const {return &m_idreq;}
 331             saml::Iterator<const XMLCh*> getNameIDFormats() const {return m_formats;}
 332             saml::Iterator<const XMLCh*> getAttributeProfiles() const {return m_attrprofs;}
 333             saml::Iterator<const saml::SAMLAttribute*> getAttributes() const {return m_attrs;}
 334
 335         private:
 336             EndpointManager m_query,m_idreq;
 337             vector<const XMLCh*> m_formats,m_attrprofs;
 338             vector<const SAMLAttribute*> m_attrs;
 339         };
 340
 341         class EntityDescriptor : public IEntityDescriptor
 342         {
 343         public:
 344             EntityDescriptor(
 345                 const DOMElement* e,
 346                 XMLMetadataImpl* wrapper,
 347                 time_t validUntil=LONG_MAX,
 348                 const IEntitiesDescriptor* parent=NULL
 349                 );
 350             ~EntityDescriptor();
 351
 352             // External contract
 353             const XMLCh* getId() const {return m_id;}
 354             bool isValid() const {return time(NULL) < m_validUntil;}
 355             Iterator<const IRoleDescriptor*> getRoleDescriptors() const {return m_roles;}
 356             const IIDPSSODescriptor* getIDPSSODescriptor(const XMLCh* protocol) const;
 357             const ISPSSODescriptor* getSPSSODescriptor(const XMLCh* protocol) const {return NULL;}
 358             const IAuthnAuthorityDescriptor* getAuthnAuthorityDescriptor(const XMLCh* protocol) const {return NULL;}
 359             const IAttributeAuthorityDescriptor* getAttributeAuthorityDescriptor(const XMLCh* protocol) const;
 360             const IPDPDescriptor* getPDPDescriptor(const XMLCh* protocol) const {return NULL;}
 361             const IAffiliationDescriptor* getAffiliationDescriptor() const {return NULL;}
 362             const IOrganization* getOrganization() const {return m_org;}
 363             Iterator<const IContactPerson*> getContactPersons() const {return m_contacts;}
 364             saml::Iterator<std::pair<const XMLCh*,const XMLCh*> > getAdditionalMetadataLocations() const {return m_locs;}
 365             const IEntitiesDescriptor* getEntitiesDescriptor() const {return m_parent;}
 366             const DOMElement* getElement() const {return m_root;}
 367
 368             // Used internally
 369             const char* getErrorURL() const {return m_errorURL.get();}
 370             time_t getValidUntil() const {return m_validUntil;}
 371         private:
 372             const DOMElement* m_root;
 373             const IEntitiesDescriptor* m_parent;
 374             const XMLCh* m_id;
 375             auto_ptr<char> m_errorURL;
 376             IOrganization* m_org;
 377             vector<const IContactPerson*> m_contacts;
 378             vector<const IRoleDescriptor*> m_roles;
 379             vector<pair<const XMLCh*,const XMLCh*> > m_locs;
 380             time_t m_validUntil;
 381         };
 382
 383         class EntitiesDescriptor : public IEntitiesDescriptor
 384         {
 385         public:
 386             EntitiesDescriptor(
 387                 const DOMElement* e,
 388                 XMLMetadataImpl* wrapper,
 389                 time_t validUntil=LONG_MAX,
 390                 const IEntitiesDescriptor* parent=NULL
 391                 );
 392             ~EntitiesDescriptor();
 393
 394             const XMLCh* getName() const {return m_name;}
 395             bool isValid() const {return time(NULL) < m_validUntil;}
 396             const IEntitiesDescriptor* getEntitiesDescriptor() const {return m_parent;}
 397             saml::Iterator<const IEntitiesDescriptor*> getEntitiesDescriptors() const {return m_groups;}
 398             saml::Iterator<const IEntityDescriptor*> getEntityDescriptors() const {return m_providers;}
 399             const DOMElement* getElement() const {return m_root;}
 400
 401         private:
 402             const DOMElement* m_root;
 403             const IEntitiesDescriptor* m_parent;
 404             const XMLCh* m_name;
 405             vector<const IEntitiesDescriptor*> m_groups;
 406             vector<const IEntityDescriptor*> m_providers;
 407             time_t m_validUntil;
 408         };
 409
 410         XMLMetadataImpl(const char* pathname) : ReloadableXMLFileImpl(pathname), m_rootProvider(NULL), m_rootGroup(NULL) { init(); }
 411         XMLMetadataImpl(const DOMElement* e) : ReloadableXMLFileImpl(e), m_rootProvider(NULL), m_rootGroup(NULL) { init(); }
 412         void init();
 413         ~XMLMetadataImpl();
 414
 415         typedef multimap<string,const EntityDescriptor*> sitemap_t;
 416         sitemap_t m_sites;
 417         sitemap_t m_sources;
 418         EntityDescriptor* m_rootProvider;
 419         EntitiesDescriptor* m_rootGroup;
 420     };
 421
 422     class XMLMetadata : public IMetadata, public ReloadableXMLFile
 423     {
 424     public:
 425         XMLMetadata(const DOMElement* e) : ReloadableXMLFile(e) {}
 426         ~XMLMetadata() {}
 427
 428         const IEntityDescriptor* lookup(const XMLCh* providerId) const;
 429         const IEntityDescriptor* lookup(const saml::SAMLArtifact* artifact) const;
 430
 431     protected:
 432         virtual ReloadableXMLFileImpl* newImplementation(const char* pathname, bool first=true) const;
 433         virtual ReloadableXMLFileImpl* newImplementation(const DOMElement* e, bool first=true) const;
 434     };
 435 }
 436
 437 IPlugIn* XMLMetadataFactory(const DOMElement* e)
 438 {
 439     XMLMetadata* m=new XMLMetadata(e);
 440     try {
 441         m->getImplementation();
 442     }
 443     catch (...) {
 444         delete m;
 445         throw;
 446     }
 447     return m;
 448 }
 449
 450 ReloadableXMLFileImpl* XMLMetadata::newImplementation(const DOMElement* e, bool first) const
 451 {
 452     return new XMLMetadataImpl(e);
 453 }
 454
 455 ReloadableXMLFileImpl* XMLMetadata::newImplementation(const char* pathname, bool first) const
 456 {
 457     return new XMLMetadataImpl(pathname);
 458 }
 459
 460 XMLMetadataImpl::ContactPerson::ContactPerson(const DOMElement* e) : m_root(e)
 461 {
 462     const XMLCh* type=NULL;
 463
 464     // Old metadata or new?
 465     if (saml::XML::isElementNamed(e,::XML::SHIB_NS,SHIB_L(Contact))) {
 466         type=e->getAttributeNS(NULL,SHIB_L(Type));
 467         m_surName=auto_ptr<char>(toUTF8(e->getAttributeNS(NULL,SHIB_L(Name))));
 468         if (e->hasAttributeNS(NULL,SHIB_L(Email))) {
 469             auto_ptr<char> temp(toUTF8(e->getAttributeNS(NULL,SHIB_L(Email))));
 470             if (temp.get())
 471                 m_emails.push_back(temp.get());
 472         }
 473     }
 474     else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(ContactPerson))) {
 475         type=e->getAttributeNS(NULL,SHIB_L(contactType));
 476         DOMNode* n=NULL;
 477         e=saml::XML::getFirstChildElement(e);
 478         while (e) {
 479             if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(Company))) {
 480                 n=e->getFirstChild();
 481                 if (n) m_company=auto_ptr<char>(toUTF8(n->getNodeValue()));
 482             }
 483             else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(GivenName))) {
 484                 n=e->getFirstChild();
 485                 if (n) m_givenName=auto_ptr<char>(toUTF8(n->getNodeValue()));
 486             }
 487             else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(SurName))) {
 488                 n=e->getFirstChild();
 489                 if (n) m_surName=auto_ptr<char>(toUTF8(n->getNodeValue()));
 490             }
 491             else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(EmailAddress))) {
 492                 n=e->getFirstChild();
 493                 if (n) {
 494                     auto_ptr<char> temp(toUTF8(n->getNodeValue()));
 495                     if (temp.get()) m_emails.push_back(temp.get());
 496                 }
 497             }
 498             else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(TelephoneNumber))) {
 499                 n=e->getFirstChild();
 500                 if (n) {
 501                     auto_ptr<char> temp(toUTF8(n->getNodeValue()));
 502                     if (temp.get()) m_phones.push_back(temp.get());
 503                 }
 504             }
 505             e=saml::XML::getNextSiblingElement(e);
 506         }
 507     }
 508
 509     if (!XMLString::compareString(type,SHIB_L(technical)))
 510         m_type=IContactPerson::technical;
 511     else if (!XMLString::compareString(type,SHIB_L(support)))
 512         m_type=IContactPerson::support;
 513     else if (!XMLString::compareString(type,SHIB_L(administrative)))
 514         m_type=IContactPerson::administrative;
 515     else if (!XMLString::compareString(type,SHIB_L(billing)))
 516         m_type=IContactPerson::billing;
 517     else if (!XMLString::compareString(type,SHIB_L(other)))
 518         m_type=IContactPerson::other;
 519 }
 520
 521 XMLMetadataImpl::Organization::Organization(const DOMElement* e) : m_root(e)
 522 {
 523     DOMNode* n=NULL;
 524     e=saml::XML::getFirstChildElement(e);
 525     while (e) {
 526         if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(OrganizationName))) {
 527             n=e->getFirstChild();
 528             if (n) {
 529                 auto_ptr<char> name(toUTF8(n->getNodeValue()));
 530                 auto_ptr_char lang(e->getAttributeNS(saml::XML::XML_NS,L(lang)));
 531                 m_names[lang.get()]=name.get();
 532             }
 533         }
 534         else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(OrganizationDisplayName))) {
 535             n=e->getFirstChild();
 536             if (n) {
 537                 auto_ptr<char> display(toUTF8(n->getNodeValue()));
 538                 auto_ptr_char lang(e->getAttributeNS(saml::XML::XML_NS,L(lang)));
 539                 m_displays[lang.get()]=display.get();
 540             }
 541         }
 542         else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(OrganizationURL))) {
 543             n=e->getFirstChild();
 544             if (n) {
 545                 auto_ptr<char> url(toUTF8(n->getNodeValue()));
 546                 auto_ptr_char lang(e->getAttributeNS(saml::XML::XML_NS,L(lang)));
 547                 m_urls[lang.get()]=url.get();
 548             }
 549         }
 550         e=saml::XML::getNextSiblingElement(e);
 551     }
 552 }
 553
 554 XMLMetadataImpl::EncryptionMethod::EncryptionMethod(const DOMElement* e) : m_root(e)
 555 {
 556     m_alg=e->getAttributeNS(NULL,SHIB_L(Algorithm));
 557     e=saml::XML::getFirstChildElement(e);
 558     while (e) {
 559         if (saml::XML::isElementNamed(e,::XML::XMLENC_NS,SHIB_L(KeySize))) {
 560             DOMNode* n=e->getFirstChild();
 561             if (n) m_size=XMLString::parseInt(n->getNodeValue());
 562         }
 563         else if (saml::XML::isElementNamed(e,saml::XML::XMLSIG_NS,SHIB_L(DigestMethod))) {
 564             DOMNode* n=e->getFirstChild();
 565             if (n) m_digest=n->getNodeValue();
 566         }
 567         else if (saml::XML::isElementNamed(e,::XML::XMLENC_NS,SHIB_L(OAEParams))) {
 568             DOMNode* n=e->getFirstChild();
 569             if (n) m_params=n->getNodeValue();
 570         }
 571         e=saml::XML::getNextSiblingElement(e);
 572     }
 573 }
 574
 575 XMLMetadataImpl::KeyDescriptor::KeyDescriptor(const DOMElement* e) : m_root(e), m_use(unspecified), m_klist(NULL)
 576 {
 577     if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(use)),SHIB_L(encryption)))
 578         m_use=encryption;
 579     else if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(use)),SHIB_L(signing)))
 580         m_use=signing;
 581
 582     // Process ds:KeyInfo
 583     e=saml::XML::getFirstChildElement(e);
 584
 585     // We let XMLSec hack through anything it can. This should evolve over time, or we can
 586     // plug in our own KeyResolver later...
 587     DOMElement* child=saml::XML::getFirstChildElement(e);
 588     while (child) {
 589         try {
 590             if (!m_klist.addXMLKeyInfo(child)) {
 591                 Category::getInstance(XMLPROVIDERS_LOGCAT".XMLMetadataImpl.KeyDescriptor").warn(
 592                     "skipped unsupported ds:KeyInfo child element");
 593             }
 594         }
 595         catch (XSECCryptoException& xe) {
 596             Category::getInstance(XMLPROVIDERS_LOGCAT".XMLMetadataImpl.KeyDescriptor").error(
 597                 "unable to process ds:KeyInfo child element: %s",xe.getMsg());
 598         }
 599         child=saml::XML::getNextSiblingElement(child);
 600     }
 601
 602     // Check for encryption methods.
 603     e=saml::XML::getNextSiblingElement(e);
 604     while (e && saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(EncryptionMethod)))
 605         m_methods.push_back(new EncryptionMethod(e));
 606 }
 607
 608 XMLMetadataImpl::KeyDescriptor::~KeyDescriptor()
 609 {
 610     for (vector<const XENCEncryptionMethod*>::iterator i=m_methods.begin(); i!=m_methods.end(); i++)
 611         delete const_cast<XENCEncryptionMethod*>(*i);
 612 }
 613
 614 XMLMetadataImpl::Role::Role(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e)
 615     : m_provider(provider), m_errorURL(NULL), m_protocolEnumCopy(NULL), m_org(NULL), m_validUntil(validUntil), m_root(e)
 616 {
 617     // Check the root element namespace. If SAML2, assume it's the std schema.
 618     if (e && !XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 619
 620         if (e->hasAttributeNS(NULL,SHIB_L(validUntil))) {
 621             SAMLDateTime exp(e->getAttributeNS(NULL,SHIB_L(validUntil)));
 622             exp.parseDateTime();
 623             m_validUntil=min(m_validUntil,exp.getEpoch());
 624         }
 625
 626         if (e->hasAttributeNS(NULL,SHIB_L(errorURL)))
 627             m_errorURL=toUTF8(e->getAttributeNS(NULL,SHIB_L(errorURL)));
 628
 629         // Chop the protocol list into pieces...assume any whitespace can appear in between.
 630         m_protocolEnumCopy=XMLString::replicate(e->getAttributeNS(NULL,SHIB_L(protocolSupportEnumeration)));
 631         XMLCh* temp=m_protocolEnumCopy;
 632         while (temp && *temp) {
 633             XMLCh* start=temp++;
 634             while (*temp && !XMLChar1_1::isWhitespace(*temp)) temp++;
 635             *temp=chNull;
 636             m_protocolEnum.push_back(start);
 637             temp++;
 638             while (*temp && XMLChar1_1::isWhitespace(*temp)) temp++;
 639         }
 640
 641         e=saml::XML::getFirstChildElement(m_root,::XML::SAML2META_NS,SHIB_L(KeyDescriptor));
 642         while (e) {
 643             m_keys.push_back(new KeyDescriptor(e));
 644             e=saml::XML::getNextSiblingElement(e,::XML::SAML2META_NS,SHIB_L(KeyDescriptor));
 645         }
 646
 647         e=saml::XML::getFirstChildElement(m_root,::XML::SAML2META_NS,SHIB_L(Organization));
 648         if (e)
 649             m_org=new Organization(e);
 650
 651         e=saml::XML::getFirstChildElement(m_root,::XML::SAML2META_NS,SHIB_L(ContactPerson));
 652         while (e) {
 653             m_contacts.push_back(new ContactPerson(e));
 654             e=saml::XML::getNextSiblingElement(e,::XML::SAML2META_NS,SHIB_L(ContactPerson));
 655         }
 656     }
 657 }
 658
 659 XMLMetadataImpl::Role::~Role()
 660 {
 661     delete m_org;
 662     delete m_errorURL;
 663     if (m_protocolEnumCopy) XMLString::release(&m_protocolEnumCopy);
 664     for (vector<const IKeyDescriptor*>::iterator i=m_keys.begin(); i!=m_keys.end(); i++)
 665         delete const_cast<IKeyDescriptor*>(*i);
 666     for (vector<const IContactPerson*>::iterator j=m_contacts.begin(); j!=m_contacts.end(); j++)
 667         delete const_cast<IContactPerson*>(*j);
 668 }
 669
 670 bool XMLMetadataImpl::Role::hasSupport(const XMLCh* protocol) const
 671 {
 672     Iterator<const XMLCh*> i(m_protocolEnum);
 673     while (i.hasNext()) {
 674         if (!XMLString::compareString(protocol,i.next()))
 675             return true;
 676     }
 677     return false;
 678 }
 679
 680 XMLMetadataImpl::SSORole::SSORole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e)
 681     : Role(provider,validUntil,e)
 682 {
 683     // Check the root element namespace. If SAML2, assume it's the std schema.
 684     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 685         int i;
 686         DOMNodeList* nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(ArtifactResolutionService));
 687         for (i=0; nlist && i<nlist->getLength(); i++)
 688             m_artifact.add(new IndexedEndpoint(static_cast<DOMElement*>(nlist->item(i))));
 689
 690         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(SingleLogoutService));
 691         for (i=0; nlist && i<nlist->getLength(); i++)
 692             m_logout.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 693
 694         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(ManageNameIDService));
 695         for (i=0; nlist && i<nlist->getLength(); i++)
 696             m_nameid.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 697
 698         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(NameIDFormat));
 699         for (i=0; nlist && i<nlist->getLength(); i++) {
 700             DOMNode* n=nlist->item(i)->getFirstChild();
 701             if (n) m_formats.push_back(n->getNodeValue());
 702         }
 703     }
 704     else {
 705         // For old style, we just do SAML 1.1 compatibility with Shib handles.
 706         m_protocolEnum.push_back(saml::XML::SAML11_PROTOCOL_ENUM);
 707         m_formats.push_back(shibboleth::Constants::SHIB_NAMEID_FORMAT_URI);
 708     }
 709 }
 710
 711 XMLMetadataImpl::ScopedRole::ScopedRole(const DOMElement* e)
 712 {
 713     // Check the root element namespace. If SAML2, assume it's the std schema.
 714     DOMNodeList* nlist=NULL;
 715     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 716         e=saml::XML::getFirstChildElement(e,::XML::SAML2META_NS,SHIB_L(Extensions));
 717         nlist=e->getElementsByTagNameNS(::XML::SHIBMETA_NS,SHIB_L(Domain));
 718     }
 719     else {
 720         nlist=e->getElementsByTagNameNS(::XML::SHIB_NS,SHIB_L(Domain));
 721     }
 722
 723     for (int i=0; nlist && i < nlist->getLength(); i++) {
 724         const XMLCh* dom=(nlist->item(i)->hasChildNodes()) ? nlist->item(i)->getFirstChild()->getNodeValue() : NULL;
 725         if (dom && *dom) {
 726             const XMLCh* regexp=static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(regexp));
 727             m_scopes.push_back(
 728                 pair<const XMLCh*,bool>(dom,(regexp && (*regexp==chLatin_t || *regexp==chDigit_1)))
 729                 );
 730         }
 731     }
 732 }
 733
 734 XMLMetadataImpl::IDPRole::IDPRole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e)
 735     : SSORole(provider,validUntil,e), ScopedRole(e), m_wantAuthnRequestsSigned(false), m_sourceId(NULL)
 736 {
 737     // Check the root element namespace. If SAML2, assume it's the std schema.
 738     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 739         const XMLCh* flag=e->getAttributeNS(NULL,SHIB_L(WantAuthnRequestsSigned));
 740         m_wantAuthnRequestsSigned=(flag && (*flag==chDigit_1 || *flag==chLatin_t));
 741
 742         // Check for SourceID extension.
 743         DOMElement* ext=saml::XML::getFirstChildElement(e,::XML::SAML2META_NS,SHIB_L(Extensions));
 744         if (ext) {
 745             ext=saml::XML::getFirstChildElement(ext,saml::XML::SAML_ARTIFACT_SOURCEID,SHIB_L(SourceID));
 746             if (ext && ext->hasChildNodes())
 747                 m_sourceId=ext->getFirstChild()->getNodeValue();
 748         }
 749
 750         int i;
 751         DOMNodeList* nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(SingleSignOnService));
 752         for (i=0; nlist && i<nlist->getLength(); i++)
 753             m_sso.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 754
 755         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(NameIDMappingService));
 756         for (i=0; nlist && i<nlist->getLength(); i++)
 757             m_mapping.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 758
 759         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(AssertionIDRequestService));
 760         for (i=0; nlist && i<nlist->getLength(); i++)
 761             m_idreq.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 762
 763         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(AttributeProfile));
 764         for (i=0; nlist && i<nlist->getLength(); i++) {
 765             DOMNode* n=nlist->item(i)->getFirstChild();
 766             if (n) m_attrprofs.push_back(n->getNodeValue());
 767         }
 768
 769         nlist=e->getElementsByTagNameNS(::XML::SAML2ASSERT_NS,L(Attribute));
 770         for (i=0; nlist && i<nlist->getLength(); i++) {
 771             // For now, we need to convert these to plain SAML 1.1 attributes.
 772             DOMElement* src=static_cast<DOMElement*>(nlist->item(i));
 773             DOMElement* copy=e->getOwnerDocument()->createElementNS(saml::XML::SAML_NS,L(Attribute));
 774             copy->setAttributeNS(NULL,L(AttributeName),src->getAttributeNS(NULL,SHIB_L(Name)));
 775             copy->setAttributeNS(NULL,L(AttributeNamespace),src->getAttributeNS(NULL,SHIB_L(NameFormat)));
 776             src=saml::XML::getFirstChildElement(src,::XML::SAML2ASSERT_NS,L(AttributeValue));
 777             while (src) {
 778                 src=saml::XML::getNextSiblingElement(src,::XML::SAML2ASSERT_NS,L(AttributeValue));
 779                 DOMElement* val=e->getOwnerDocument()->createElementNS(saml::XML::SAML_NS,L(AttributeValue));
 780                 DOMNamedNodeMap* attrs = src->getAttributes();
 781                 for (int j=0; j<attrs->getLength(); j++)
 782                     val->setAttributeNodeNS(static_cast<DOMAttr*>(e->getOwnerDocument()->importNode(attrs->item(j),true)));
 783                 while (src->hasChildNodes())
 784                     val->appendChild(src->getFirstChild());
 785                 copy->appendChild(val);
 786             }
 787             m_attrs.push_back(SAMLAttribute::getInstance(copy));
 788         }
 789     }
 790     else {
 791         m_attrprofs.push_back(Constants::SHIB_ATTRIBUTE_NAMESPACE_URI);
 792         int i;
 793         DOMNodeList* nlist=e->getElementsByTagNameNS(::XML::SHIB_NS,SHIB_L(HandleService));
 794         for (i=0; nlist && i<nlist->getLength(); i++) {
 795             // Manufacture an endpoint for the "Shib" binding.
 796             m_sso.add(
 797                 new Endpoint(Constants::SHIB_AUTHNREQUEST_PROFILE_URI,static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(Location)))
 798                 );
 799
 800             // We're going to "mock up" a KeyDescriptor that contains the specified Name as a ds:KeyName.
 801             DOMElement* kd=e->getOwnerDocument()->createElementNS(::XML::SAML2META_NS,SHIB_L(KeyDescriptor));
 802             DOMElement* ki=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,L(KeyInfo));
 803             DOMElement* kn=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,SHIB_L(KeyName));
 804             kn->appendChild(
 805                 e->getOwnerDocument()->createTextNode(
 806                     static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(Name))
 807                     )
 808                 );
 809             ki->appendChild(kn);
 810             kd->appendChild(ki);
 811             kd->setAttributeNS(NULL,SHIB_L(use),SHIB_L(signing));
 812             m_keys.push_back(new KeyDescriptor(kd));
 813         }
 814     }
 815 }
 816
 817 XMLMetadataImpl::IDPRole::~IDPRole()
 818 {
 819     for (vector<const SAMLAttribute*>::iterator i=m_attrs.begin(); i!=m_attrs.end(); i++)
 820         delete const_cast<SAMLAttribute*>(*i);
 821 }
 822
 823 XMLMetadataImpl::AARole::AARole(const EntityDescriptor* provider, time_t validUntil, const DOMElement* e)
 824     : Role(provider,validUntil,e), ScopedRole(e)
 825 {
 826     // Check the root element namespace. If SAML2, assume it's the std schema.
 827     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 828         int i;
 829         DOMNodeList* nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(AttributeService));
 830         for (i=0; nlist && i<nlist->getLength(); i++)
 831             m_query.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 832
 833         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(AssertionIDRequestService));
 834         for (i=0; nlist && i<nlist->getLength(); i++)
 835             m_idreq.add(new Endpoint(static_cast<DOMElement*>(nlist->item(i))));
 836
 837         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(NameIDFormat));
 838         for (i=0; nlist && i<nlist->getLength(); i++) {
 839             DOMNode* n=nlist->item(i)->getFirstChild();
 840             if (n) m_formats.push_back(n->getNodeValue());
 841         }
 842
 843         nlist=e->getElementsByTagNameNS(::XML::SAML2META_NS,SHIB_L(AttributeProfile));
 844         for (i=0; nlist && i<nlist->getLength(); i++) {
 845             DOMNode* n=nlist->item(i)->getFirstChild();
 846             if (n) m_attrprofs.push_back(n->getNodeValue());
 847         }
 848
 849         nlist=e->getElementsByTagNameNS(::XML::SAML2ASSERT_NS,L(Attribute));
 850         for (i=0; nlist && i<nlist->getLength(); i++) {
 851             // For now, we need to convert these to plain SAML 1.1 attributes.
 852             DOMElement* src=static_cast<DOMElement*>(nlist->item(i));
 853             DOMElement* copy=e->getOwnerDocument()->createElementNS(saml::XML::SAML_NS,L(Attribute));
 854             copy->setAttributeNS(NULL,L(AttributeName),src->getAttributeNS(NULL,SHIB_L(Name)));
 855             copy->setAttributeNS(NULL,L(AttributeNamespace),src->getAttributeNS(NULL,SHIB_L(NameFormat)));
 856             src=saml::XML::getFirstChildElement(src,::XML::SAML2ASSERT_NS,L(AttributeValue));
 857             while (src) {
 858                 src=saml::XML::getNextSiblingElement(src,::XML::SAML2ASSERT_NS,L(AttributeValue));
 859                 DOMElement* val=e->getOwnerDocument()->createElementNS(saml::XML::SAML_NS,L(AttributeValue));
 860                 DOMNamedNodeMap* attrs = src->getAttributes();
 861                 for (int j=0; j<attrs->getLength(); j++)
 862                     val->setAttributeNodeNS(static_cast<DOMAttr*>(e->getOwnerDocument()->importNode(attrs->item(j),true)));
 863                 while (src->hasChildNodes())
 864                     val->appendChild(src->getFirstChild());
 865                 copy->appendChild(val);
 866             }
 867             m_attrs.push_back(SAMLAttribute::getInstance(copy));
 868         }
 869     }
 870     else {
 871         // For old style, we just do SAML 1.1 compatibility with Shib handles.
 872         m_protocolEnum.push_back(saml::XML::SAML11_PROTOCOL_ENUM);
 873         m_formats.push_back(Constants::SHIB_NAMEID_FORMAT_URI);
 874         m_attrprofs.push_back(Constants::SHIB_ATTRIBUTE_NAMESPACE_URI);
 875         int i;
 876         DOMNodeList* nlist=e->getElementsByTagNameNS(::XML::SHIB_NS,SHIB_L(AttributeAuthority));
 877         for (i=0; nlist && i<nlist->getLength(); i++) {
 878             // Manufacture an endpoint for the SOAP binding.
 879             m_query.add(
 880                 new Endpoint(
 881                     SAMLBinding::SOAP,
 882                     static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(Location))
 883                     )
 884                 );
 885
 886             // We're going to "mock up" a KeyDescriptor that contains the specified Name as a ds:KeyName.
 887             DOMElement* kd=e->getOwnerDocument()->createElementNS(::XML::SAML2META_NS,SHIB_L(KeyDescriptor));
 888             DOMElement* ki=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,L(KeyInfo));
 889             DOMElement* kn=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,SHIB_L(KeyName));
 890             kn->appendChild(
 891                 e->getOwnerDocument()->createTextNode(
 892                     static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(Name))
 893                     )
 894                 );
 895             ki->appendChild(kn);
 896             kd->appendChild(ki);
 897             m_keys.push_back(new KeyDescriptor(kd));
 898         }
 899     }
 900 }
 901
 902 XMLMetadataImpl::AARole::~AARole()
 903 {
 904     for (vector<const SAMLAttribute*>::iterator i=m_attrs.begin(); i!=m_attrs.end(); i++)
 905         delete const_cast<SAMLAttribute*>(*i);
 906 }
 907
 908 XMLMetadataImpl::EntityDescriptor::EntityDescriptor(
 909     const DOMElement* e, XMLMetadataImpl* wrapper, time_t validUntil, const IEntitiesDescriptor* parent
 910     ) : m_root(e), m_parent(parent), m_org(NULL), m_validUntil(validUntil)
 911 {
 912     // Check the root element namespace. If SAML2, assume it's the std schema.
 913     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
 914         m_id=e->getAttributeNS(NULL,SHIB_L(entityID));
 915
 916         if (e->hasAttributeNS(NULL,SHIB_L(validUntil))) {
 917             SAMLDateTime exp(e->getAttributeNS(NULL,SHIB_L(validUntil)));
 918             exp.parseDateTime();
 919             m_validUntil=min(validUntil,exp.getEpoch());
 920         }
 921
 922         DOMElement* child=saml::XML::getFirstChildElement(e);
 923         while (child) {
 924             // Process the various kinds of children that we care about...
 925             if (saml::XML::isElementNamed(child,::XML::SAML2META_NS,SHIB_L(ContactPerson))) {
 926                 m_contacts.push_back(new ContactPerson(child));
 927             }
 928             else if (saml::XML::isElementNamed(child,::XML::SAML2META_NS,SHIB_L(Organization))) {
 929                 m_org=new Organization(child);
 930             }
 931             else if (saml::XML::isElementNamed(child,::XML::SAML2META_NS,SHIB_L(AdditionalMetadataLocation))) {
 932                 DOMNode* loc=child->getFirstChild();
 933                 if (loc)
 934                     m_locs.push_back(
 935                     pair<const XMLCh*,const XMLCh*>(child->getAttributeNS(NULL,::XML::Literals::_namespace),loc->getNodeValue())
 936                         );
 937             }
 938             else if (saml::XML::isElementNamed(child,::XML::SAML2META_NS,SHIB_L(IDPSSODescriptor))) {
 939                 m_roles.push_back(new IDPRole(this,m_validUntil,child));
 940             }
 941             else if (saml::XML::isElementNamed(child,::XML::SAML2META_NS,SHIB_L(AttributeAuthorityDescriptor))) {
 942                 m_roles.push_back(new AARole(this,m_validUntil,child));
 943             }
 944             child = saml::XML::getNextSiblingElement(child);
 945         }
 946     }
 947     else {
 948         m_id=e->getAttributeNS(NULL,SHIB_L(Name));
 949         m_errorURL=auto_ptr<char>(toUTF8(e->getAttributeNS(NULL,SHIB_L(ErrorURL))));
 950
 951         bool idp=false,aa=false;    // only want to build a role once
 952         DOMElement* child=saml::XML::getFirstChildElement(e);
 953         while (child) {
 954             // Process the various kinds of OriginSite children that we care about...
 955             if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(Contact))) {
 956                 m_contacts.push_back(new ContactPerson(child));
 957             }
 958             else if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(HandleService)) && !idp) {
 959                 // Create the IDP role if needed.
 960                 m_roles.push_back(new IDPRole(this, m_validUntil, e));
 961                 idp=true;
 962             }
 963             else if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(AttributeAuthority)) && !aa) {
 964                 // Create the AA role if needed.
 965                 m_roles.push_back(new AARole(this, m_validUntil, e));
 966                 aa=true;
 967             }
 968             child = saml::XML::getNextSiblingElement(child);
 969         }
 970     }
 971
 972     auto_ptr_char id(m_id);
 973     wrapper->m_sites.insert(pair<string,const EntityDescriptor*>(id.get(),this));
 974
 975     // Look for an IdP role, and register the artifact source ID and endpoints.
 976     const IDPRole* idp=NULL;
 977     for (vector<const IRoleDescriptor*>::const_iterator r=m_roles.begin(); r!=m_roles.end(); r++) {
 978         if (idp=dynamic_cast<const IDPRole*>(*r)) {
 979             if (idp->m_sourceId) {
 980                 auto_ptr_char sourceid(idp->m_sourceId);
 981                 wrapper->m_sources.insert(pair<string,const EntityDescriptor*>(sourceid.get(),this));
 982             }
 983             else {
 984                 string sourceid=SAMLArtifact::toHex(SAMLArtifactType0001::generateSourceId(id.get()));
 985                 wrapper->m_sources.insert(pair<string,const EntityDescriptor*>(sourceid,this));
 986             }
 987             Iterator<const IEndpoint*> locs=idp->getArtifactResolutionServiceManager()->getEndpoints();
 988             while (locs.hasNext()) {
 989                 auto_ptr_char loc(locs.next()->getLocation());
 990                 wrapper->m_sources.insert(pair<string,const EntityDescriptor*>(loc.get(),this));
 991             }
 992         }
 993     }
 994 }
 995
 996 const IIDPSSODescriptor* XMLMetadataImpl::EntityDescriptor::getIDPSSODescriptor(const XMLCh* protocol) const
 997 {
 998     const IIDPSSODescriptor* ret=NULL;
 999     for (vector<const IRoleDescriptor*>::const_iterator i=m_roles.begin(); i!=m_roles.end(); i++) {
1000         if ((*i)->hasSupport(protocol) && (*i)->isValid() && (ret=dynamic_cast<const IIDPSSODescriptor*>(*i)))
1001             return ret;
1002     }
1003     return NULL;
1004 }
1005
1006 const IAttributeAuthorityDescriptor* XMLMetadataImpl::EntityDescriptor::getAttributeAuthorityDescriptor(const XMLCh* protocol) const
1007 {
1008     const IAttributeAuthorityDescriptor* ret=NULL;
1009     for (vector<const IRoleDescriptor*>::const_iterator i=m_roles.begin(); i!=m_roles.end(); i++) {
1010         if ((*i)->hasSupport(protocol) && (*i)->isValid() && (ret=dynamic_cast<const IAttributeAuthorityDescriptor*>(*i)))
1011             return ret;
1012     }
1013     return NULL;
1014 }
1015
1016 XMLMetadataImpl::EntityDescriptor::~EntityDescriptor()
1017 {
1018     delete m_org;
1019     for (vector<const IContactPerson*>::iterator i=m_contacts.begin(); i!=m_contacts.end(); i++)
1020         delete const_cast<IContactPerson*>(*i);
1021     for (vector<const IRoleDescriptor*>::iterator j=m_roles.begin(); j!=m_roles.end(); j++)
1022         delete const_cast<IRoleDescriptor*>(*j);
1023 }
1024
1025 XMLMetadataImpl::EntitiesDescriptor::EntitiesDescriptor(
1026     const DOMElement* e, XMLMetadataImpl* wrapper, time_t validUntil, const IEntitiesDescriptor* parent
1027     ) : m_root(e), m_name(e->getAttributeNS(NULL,SHIB_L(Name))), m_parent(parent), m_validUntil(validUntil)
1028 {
1029     // Check the root element namespace. If SAML2, assume it's the std schema.
1030     if (!XMLString::compareString(e->getNamespaceURI(),::XML::SAML2META_NS)) {
1031
1032         if (e->hasAttributeNS(NULL,SHIB_L(validUntil))) {
1033             SAMLDateTime exp(e->getAttributeNS(NULL,SHIB_L(validUntil)));
1034             exp.parseDateTime();
1035             m_validUntil=min(validUntil,exp.getEpoch());
1036         }
1037
1038         e=saml::XML::getFirstChildElement(e);
1039         while (e) {
1040             if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(EntitiesDescriptor)))
1041                 m_groups.push_back(new EntitiesDescriptor(e,wrapper,m_validUntil,this));
1042             else if (saml::XML::isElementNamed(e,::XML::SAML2META_NS,SHIB_L(EntityDescriptor)))
1043                 m_providers.push_back(new EntityDescriptor(e,wrapper,m_validUntil,this));
1044             e=saml::XML::getNextSiblingElement(e);
1045         }
1046     }
1047     else {
1048         e=saml::XML::getFirstChildElement(e);
1049         while (e) {
1050             if (saml::XML::isElementNamed(e,::XML::SHIB_NS,SHIB_L(SiteGroup)))
1051                 m_groups.push_back(new EntitiesDescriptor(e,wrapper,m_validUntil,this));
1052             else if (saml::XML::isElementNamed(e,::XML::SHIB_NS,SHIB_L(OriginSite)))
1053                 m_providers.push_back(new EntityDescriptor(e,wrapper,m_validUntil,this));
1054             e=saml::XML::getNextSiblingElement(e);
1055         }
1056     }
1057 }
1058
1059 XMLMetadataImpl::EntitiesDescriptor::~EntitiesDescriptor()
1060 {
1061     for (vector<const IEntityDescriptor*>::iterator i=m_providers.begin(); i!=m_providers.end(); i++)
1062         delete const_cast<IEntityDescriptor*>(*i);
1063     for (vector<const IEntitiesDescriptor*>::iterator j=m_groups.begin(); j!=m_groups.end(); j++)
1064         delete const_cast<IEntitiesDescriptor*>(*j);
1065 }
1066
1067 void XMLMetadataImpl::init()
1068 {
1069     NDC ndc("XMLMetadataImpl");
1070     Category& log=Category::getInstance(XMLPROVIDERS_LOGCAT".XMLMetadataImpl");
1071
1072     try
1073     {
1074         if (saml::XML::isElementNamed(m_root,::XML::SAML2META_NS,SHIB_L(EntitiesDescriptor)))
1075             m_rootGroup=new EntitiesDescriptor(m_root,this);
1076         else if (saml::XML::isElementNamed(m_root,::XML::SAML2META_NS,SHIB_L(EntityDescriptor)))
1077             m_rootProvider=new EntityDescriptor(m_root,this);
1078         else if (saml::XML::isElementNamed(m_root,::XML::SHIB_NS,SHIB_L(SiteGroup)))
1079             m_rootGroup=new EntitiesDescriptor(m_root,this);
1080         else if (saml::XML::isElementNamed(m_root,::XML::SHIB_NS,SHIB_L(OriginSite)))
1081             m_rootProvider=new EntityDescriptor(m_root,this);
1082         else {
1083             log.error("Construction requires a valid SAML metadata file");
1084             throw MetadataException("Construction requires a valid SAML metadata file");
1085         }
1086     }
1087     catch (SAMLException& e)
1088     {
1089         log.errorStream() << "Error while parsing SAML metadata: " << e.what() << CategoryStream::ENDLINE;
1090         this->~XMLMetadataImpl();
1091         throw;
1092     }
1093     catch (...)
1094     {
1095         log.error("Unexpected error while parsing SAML metadata");
1096         this->~XMLMetadataImpl();
1097         throw;
1098     }
1099 }
1100
1101 XMLMetadataImpl::~XMLMetadataImpl()
1102 {
1103     delete m_rootGroup;
1104     delete m_rootProvider;
1105 }
1106
1107 const IEntityDescriptor* XMLMetadata::lookup(const XMLCh* providerId) const
1108 {
1109     XMLMetadataImpl* impl=dynamic_cast<XMLMetadataImpl*>(getImplementation());
1110     auto_ptr_char temp(providerId);
1111     pair<XMLMetadataImpl::sitemap_t::const_iterator,XMLMetadataImpl::sitemap_t::const_iterator> range=
1112         impl->m_sites.equal_range(temp.get());
1113
1114     time_t now=time(NULL);
1115     for (XMLMetadataImpl::sitemap_t::const_iterator i=range.first; i!=range.second; i++)
1116         if (now < i->second->getValidUntil())
1117             return i->second;
1118     return NULL;
1119 }
1120
1121 const IEntityDescriptor* XMLMetadata::lookup(const SAMLArtifact* artifact) const
1122 {
1123     time_t now=time(NULL);
1124     XMLMetadataImpl* impl=dynamic_cast<XMLMetadataImpl*>(getImplementation());
1125     pair<XMLMetadataImpl::sitemap_t::const_iterator,XMLMetadataImpl::sitemap_t::const_iterator> range;
1126
1127     // Depends on type of artifact.
1128     const SAMLArtifactType0001* type1=dynamic_cast<const SAMLArtifactType0001*>(artifact);
1129     if (type1) {
1130         range=impl->m_sources.equal_range(type1->getSourceID());
1131     }
1132     else {
1133         const SAMLArtifactType0002* type2=dynamic_cast<const SAMLArtifactType0002*>(artifact);
1134         if (type2) {
1135             range=impl->m_sources.equal_range(type2->getSourceLocation());
1136         }
1137         else
1138             return NULL;
1139     }
1140     for (XMLMetadataImpl::sitemap_t::const_iterator i=range.first; i!=range.second; i++)
1141         if (now < i->second->getValidUntil())
1142             return i->second;
1143     return NULL;
1144 }