shib/shib.h

   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
  51 /* shib.h - Shibboleth header file
  52
  53    Scott Cantor
  54    6/4/02
  55
  56    $History:$
  57 */
  58
  59 #ifndef __shib_h__
  60 #define __shib_h__
  61
  62 #include <saml/saml.h>
  63 #include <shib/shib-threads.h>
  64 #include <xsec/xenc/XENCEncryptionMethod.hpp>
  65
  66 #ifdef WIN32
  67 # ifndef SHIB_EXPORTS
  68 #  define SHIB_EXPORTS __declspec(dllimport)
  69 # endif
  70 #else
  71 # define SHIB_EXPORTS
  72 #endif
  73
  74 namespace shibboleth
  75 {
  76     DECLARE_SAML_EXCEPTION(SHIB_EXPORTS,ResourceAccessException,SAMLException);
  77     DECLARE_SAML_EXCEPTION(SHIB_EXPORTS,MetadataException,SAMLException);
  78     DECLARE_SAML_EXCEPTION(SHIB_EXPORTS,CredentialException,SAMLException);
  79     DECLARE_SAML_EXCEPTION(SHIB_EXPORTS,InvalidHandleException,RetryableProfileException);
  80     DECLARE_SAML_EXCEPTION(SHIB_EXPORTS,InvalidSessionException,RetryableProfileException);
  81
  82     // Metadata abstract interfaces, based on SAML 2.0
  83
  84     struct SHIB_EXPORTS IContactPerson
  85     {
  86         enum ContactType { technical, support, administrative, billing, other };
  87         virtual ContactType getType() const=0;
  88         virtual const char* getCompany() const=0;
  89         virtual const char* getGivenName() const=0;
  90         virtual const char* getSurName() const=0;
  91         virtual saml::Iterator<std::string> getEmailAddresses() const=0;
  92         virtual saml::Iterator<std::string> getTelephoneNumbers() const=0;
  93         virtual const DOMElement* getElement() const=0;
  94         virtual ~IContactPerson() {}
  95     };
  96
  97     struct SHIB_EXPORTS IOrganization
  98     {
  99         virtual const char* getName(const char* lang="en") const=0;
 100         virtual const char* getDisplayName(const char* lang="en") const=0;
 101         virtual const char* getURL(const char* lang="en") const=0;
 102         virtual const DOMElement* getElement() const=0;
 103         virtual ~IOrganization() {}
 104     };
 105
 106     struct SHIB_EXPORTS IKeyDescriptor
 107     {
 108         enum KeyUse { unspecified, encryption, signing };
 109         virtual KeyUse getUse() const=0;
 110         virtual DSIGKeyInfoList* getKeyInfo() const=0;
 111         virtual saml::Iterator<const XENCEncryptionMethod*> getEncryptionMethods() const=0;
 112         virtual ~IKeyDescriptor() {}
 113     };
 114
 115     struct SHIB_EXPORTS IEndpoint
 116     {
 117         virtual const XMLCh* getBinding() const=0;
 118         virtual const XMLCh* getLocation() const=0;
 119         virtual const XMLCh* getResponseLocation() const=0;
 120         virtual const DOMElement* getElement() const=0;
 121         virtual ~IEndpoint() {}
 122     };
 123
 124     struct SHIB_EXPORTS IIndexedEndpoint : public virtual IEndpoint
 125     {
 126         virtual unsigned short getIndex() const=0;
 127         virtual ~IIndexedEndpoint() {}
 128     };
 129
 130     struct SHIB_EXPORTS IEndpointManager
 131     {
 132         virtual saml::Iterator<const IEndpoint*> getEndpoints() const=0;
 133         virtual const IEndpoint* getDefaultEndpoint() const=0;
 134         virtual const IEndpoint* getEndpointByIndex(unsigned short index) const=0;
 135         virtual const IEndpoint* getEndpointByBinding(const XMLCh* binding) const=0;
 136         virtual ~IEndpointManager() {}
 137     };
 138
 139     struct SHIB_EXPORTS IEntityDescriptor;
 140     struct SHIB_EXPORTS IRoleDescriptor
 141     {
 142         virtual const IEntityDescriptor* getEntityDescriptor() const=0;
 143         virtual saml::Iterator<const XMLCh*> getProtocolSupportEnumeration() const=0;
 144         virtual bool hasSupport(const XMLCh* protocol) const=0;
 145         virtual bool isValid() const=0;
 146         virtual const char* getErrorURL() const=0;
 147         virtual saml::Iterator<const IKeyDescriptor*> getKeyDescriptors() const=0;
 148         virtual const IOrganization* getOrganization() const=0;
 149         virtual saml::Iterator<const IContactPerson*> getContactPersons() const=0;
 150         virtual const DOMElement* getElement() const=0;
 151         virtual ~IRoleDescriptor() {}
 152     };
 153
 154     struct SHIB_EXPORTS ISSODescriptor : public virtual IRoleDescriptor
 155     {
 156         virtual const IEndpointManager* getArtifactResolutionServiceManager() const=0;
 157         virtual const IEndpointManager* getSingleLogoutServiceManager() const=0;
 158         virtual const IEndpointManager* getManageNameIDServiceManager() const=0;
 159         virtual saml::Iterator<const XMLCh*> getNameIDFormats() const=0;
 160         virtual ~ISSODescriptor() {}
 161     };
 162
 163     struct SHIB_EXPORTS IIDPSSODescriptor : public virtual ISSODescriptor
 164     {
 165         virtual bool getWantAuthnRequestsSigned() const=0;
 166         virtual const IEndpointManager* getSingleSignOnServiceManager() const=0;
 167         virtual const IEndpointManager* getNameIDMappingServiceManager() const=0;
 168         virtual const IEndpointManager* getAssertionIDRequestServiceManager() const=0;
 169         virtual saml::Iterator<const XMLCh*> getAttributeProfiles() const=0;
 170         virtual saml::Iterator<const saml::SAMLAttribute*> getAttributes() const=0;
 171         virtual ~IIDPSSODescriptor() {}
 172     };
 173
 174     struct SHIB_EXPORTS IAttributeConsumingService
 175     {
 176         virtual const XMLCh* getName(const char* lang="en") const=0;
 177         virtual const XMLCh* getDescription(const char* lang="en") const=0;
 178         virtual saml::Iterator<std::pair<const saml::SAMLAttribute*,bool> > getRequestedAttributes() const=0;
 179         virtual ~IAttributeConsumingService() {}
 180     };
 181
 182     struct SHIB_EXPORTS ISPSSODescriptor : public virtual ISSODescriptor
 183     {
 184         virtual bool getAuthnRequestsSigned() const=0;
 185         virtual bool getWantAssertionsSigned() const=0;
 186         virtual const IEndpointManager* getAssertionConsumerServiceManager() const=0;
 187         virtual saml::Iterator<const IAttributeConsumingService*> getAttributeConsumingServices() const=0;
 188         virtual const IAttributeConsumingService* getDefaultAttributeConsumingService() const=0;
 189         virtual const IAttributeConsumingService* getAttributeConsumingServiceByID(const XMLCh* id) const=0;
 190         virtual ~ISPSSODescriptor() {}
 191     };
 192
 193     struct SHIB_EXPORTS IAuthnAuthorityDescriptor : public virtual IRoleDescriptor
 194     {
 195         virtual const IEndpointManager* getAuthnQueryServiceManager() const=0;
 196         virtual const IEndpointManager* getAssertionIDRequestServiceManager() const=0;
 197         virtual saml::Iterator<const XMLCh*> getNameIDFormats() const=0;
 198         virtual ~IAuthnAuthorityDescriptor() {}
 199     };
 200
 201     struct SHIB_EXPORTS IPDPDescriptor : public virtual IRoleDescriptor
 202     {
 203         virtual const IEndpointManager* getAuthzServiceManager() const=0;
 204         virtual const IEndpointManager* getAssertionIDRequestServiceManager() const=0;
 205         virtual saml::Iterator<const XMLCh*> getNameIDFormats() const=0;
 206         virtual ~IPDPDescriptor() {}
 207     };
 208
 209     struct SHIB_EXPORTS IAttributeAuthorityDescriptor : public virtual IRoleDescriptor
 210     {
 211         virtual const IEndpointManager* getAttributeServiceManager() const=0;
 212         virtual const IEndpointManager* getAssertionIDRequestServiceManager() const=0;
 213         virtual saml::Iterator<const XMLCh*> getNameIDFormats() const=0;
 214         virtual saml::Iterator<const XMLCh*> getAttributeProfiles() const=0;
 215         virtual saml::Iterator<const saml::SAMLAttribute*> getAttributes() const=0;
 216         virtual ~IAttributeAuthorityDescriptor() {}
 217     };
 218
 219     struct SHIB_EXPORTS IAffiliationDescriptor
 220     {
 221         virtual const IEntityDescriptor* getEntityDescriptor() const=0;
 222         virtual const XMLCh* getOwnerID() const=0;
 223         virtual bool isValid() const=0;
 224         virtual saml::Iterator<const XMLCh*> getMembers() const=0;
 225         virtual bool isMember(const XMLCh* id) const=0;
 226         virtual saml::Iterator<const IKeyDescriptor*> getKeyDescriptors() const=0;
 227         virtual const DOMElement* getElement() const=0;
 228         virtual ~IAffiliationDescriptor() {}
 229     };
 230
 231     struct SHIB_EXPORTS IEntitiesDescriptor;
 232     struct SHIB_EXPORTS IEntityDescriptor
 233     {
 234         virtual const XMLCh* getId() const=0;
 235         virtual bool isValid() const=0;
 236         virtual saml::Iterator<const IRoleDescriptor*> getRoleDescriptors() const=0;
 237         virtual const IIDPSSODescriptor* getIDPSSODescriptor(const XMLCh* protocol) const=0;
 238         virtual const ISPSSODescriptor* getSPSSODescriptor(const XMLCh* protocol) const=0;
 239         virtual const IAuthnAuthorityDescriptor* getAuthnAuthorityDescriptor(const XMLCh* protocol) const=0;
 240         virtual const IAttributeAuthorityDescriptor* getAttributeAuthorityDescriptor(const XMLCh* protocol) const=0;
 241         virtual const IPDPDescriptor* getPDPDescriptor(const XMLCh* protocol) const=0;
 242         virtual const IAffiliationDescriptor* getAffiliationDescriptor() const=0;
 243         virtual const IOrganization* getOrganization() const=0;
 244         virtual saml::Iterator<const IContactPerson*> getContactPersons() const=0;
 245         virtual saml::Iterator<std::pair<const XMLCh*,const XMLCh*> > getAdditionalMetadataLocations() const=0;
 246         virtual const IEntitiesDescriptor* getEntitiesDescriptor() const=0;
 247         virtual const DOMElement* getElement() const=0;
 248         virtual ~IEntityDescriptor() {}
 249     };
 250
 251     struct SHIB_EXPORTS IEntitiesDescriptor
 252     {
 253         virtual const XMLCh* getName() const=0;
 254         virtual bool isValid() const=0;
 255         virtual const IEntitiesDescriptor* getEntitiesDescriptor() const=0;
 256         virtual saml::Iterator<const IEntitiesDescriptor*> getEntitiesDescriptors() const=0;
 257         virtual saml::Iterator<const IEntityDescriptor*> getEntityDescriptors() const=0;
 258         virtual const DOMElement* getElement() const=0;
 259         virtual ~IEntitiesDescriptor() {}
 260     };
 261
 262     // Supports Shib role extension describing attribute scoping rules
 263     struct SHIB_EXPORTS IScopedRoleDescriptor : public virtual IRoleDescriptor
 264     {
 265         virtual saml::Iterator<std::pair<const XMLCh*,bool> > getScopes() const=0;
 266         virtual ~IScopedRoleDescriptor() {}
 267     };
 268
 269     // Shib extension interfaces to key authority data
 270     struct SHIB_EXPORTS IKeyAuthority
 271     {
 272         virtual int getVerifyDepth() const=0;
 273         virtual saml::Iterator<DSIGKeyInfoList*> getKeyInfos() const=0;
 274         virtual ~IKeyAuthority() {}
 275     };
 276
 277     struct SHIB_EXPORTS IExtendedEntityDescriptor : public virtual IEntityDescriptor
 278     {
 279         virtual saml::Iterator<const IKeyAuthority*> getKeyAuthorities() const=0;
 280         virtual ~IExtendedEntityDescriptor() {}
 281     };
 282
 283     struct SHIB_EXPORTS IExtendedEntitiesDescriptor : public virtual IEntitiesDescriptor
 284     {
 285         virtual saml::Iterator<const IKeyAuthority*> getKeyAuthorities() const=0;
 286         virtual ~IExtendedEntitiesDescriptor() {}
 287     };
 288
 289     struct SHIB_EXPORTS IMetadata : public virtual saml::ILockable, public virtual saml::IPlugIn
 290     {
 291         virtual const IEntityDescriptor* lookup(const char* id, bool strict=true) const=0;
 292         virtual const IEntityDescriptor* lookup(const XMLCh* id, bool strict=true) const=0;
 293         virtual const IEntityDescriptor* lookup(const saml::SAMLArtifact* artifact) const=0;
 294         virtual std::pair<const IEntitiesDescriptor*,const IEntityDescriptor*> getRoot() const=0;
 295         virtual ~IMetadata() {}
 296     };
 297
 298     struct SHIB_EXPORTS IRevocation : public virtual saml::ILockable, public virtual saml::IPlugIn
 299     {
 300         virtual saml::Iterator<void*> getRevocationLists(const IEntityDescriptor* provider, const IRoleDescriptor* role=NULL) const=0;
 301         virtual ~IRevocation() {}
 302     };
 303
 304     // Trust interface hides *all* details of signature and SSL validation.
 305     // Pluggable providers can fully override the Shibboleth trust model here.
 306
 307     struct SHIB_EXPORTS ITrust : public virtual saml::IPlugIn
 308     {
 309         virtual bool validate(
 310             const saml::Iterator<IRevocation*>& revocations,
 311             const IRoleDescriptor* role, const saml::SAMLSignedObject& token,
 312             const saml::Iterator<IMetadata*>& metadatas=EMPTY(IMetadata*)
 313             )=0;
 314         virtual bool attach(const saml::Iterator<IRevocation*>& revocations, const IRoleDescriptor* role, void* ctx)=0;
 315         virtual ~ITrust() {}
 316     };
 317
 318     // Credentials interface abstracts access to "owned" keys and certificates.
 319
 320     struct SHIB_EXPORTS ICredResolver : public virtual saml::IPlugIn
 321     {
 322         virtual void attach(void* ctx) const=0;
 323         virtual XSECCryptoKey* getKey() const=0;
 324         virtual saml::Iterator<XSECCryptoX509*> getCertificates() const=0;
 325         virtual void dump(FILE* f) const=0;
 326         virtual void dump() const { dump(stdout); }
 327         virtual ~ICredResolver() {}
 328     };
 329
 330     struct SHIB_EXPORTS ICredentials : public virtual saml::ILockable, public virtual saml::IPlugIn
 331     {
 332         virtual const ICredResolver* lookup(const char* id) const=0;
 333         virtual ~ICredentials() {}
 334     };
 335
 336     // Attribute acceptance processing interfaces, applied to incoming attributes.
 337
 338     struct SHIB_EXPORTS IAttributeRule
 339     {
 340         virtual const XMLCh* getName() const=0;
 341         virtual const XMLCh* getNamespace() const=0;
 342         virtual const char* getFactory() const=0;
 343         virtual const char* getAlias() const=0;
 344         virtual const char* getHeader() const=0;
 345         virtual bool getCaseSensitive() const=0;
 346         virtual void apply(saml::SAMLAttribute& attribute, const IRoleDescriptor* role=NULL) const=0;
 347         virtual ~IAttributeRule() {}
 348     };
 349
 350     struct SHIB_EXPORTS IAAP : public virtual saml::ILockable, public virtual saml::IPlugIn
 351     {
 352         virtual bool anyAttribute() const=0;
 353         virtual const IAttributeRule* lookup(const XMLCh* attrName, const XMLCh* attrNamespace=NULL) const=0;
 354         virtual const IAttributeRule* lookup(const char* alias) const=0;
 355         virtual saml::Iterator<const IAttributeRule*> getAttributeRules() const=0;
 356         virtual ~IAAP() {}
 357     };
 358
 359 #ifdef SHIB_INSTANTIATE
 360     template class SHIB_EXPORTS saml::Iterator<const IContactPerson*>;
 361     template class SHIB_EXPORTS saml::Iterator<const XENCEncryptionMethod*>;
 362     template class SHIB_EXPORTS saml::Iterator<const IKeyDescriptor*>;
 363     template class SHIB_EXPORTS saml::Iterator<const IAttributeConsumingService*>;
 364     template class SHIB_EXPORTS saml::Iterator<const IRoleDescriptor*>;
 365     template class SHIB_EXPORTS saml::Iterator<const IEntityDescriptor*>;
 366     template class SHIB_EXPORTS saml::Iterator<const IEntitiesDescriptor*>;
 367     template class SHIB_EXPORTS saml::Iterator<const IEndpoint*>;
 368     template class SHIB_EXPORTS saml::Iterator<const IAttributeRule*>;
 369     template class SHIB_EXPORTS saml::Iterator<const IKeyAuthority*>;
 370     template class SHIB_EXPORTS saml::Iterator<DSIGKeyInfoList*>;
 371     template class SHIB_EXPORTS saml::Iterator<IMetadata*>;
 372     template class SHIB_EXPORTS saml::ArrayIterator<IMetadata*>;
 373     template class SHIB_EXPORTS saml::Iterator<ITrust*>;
 374     template class SHIB_EXPORTS saml::ArrayIterator<ITrust*>;
 375     template class SHIB_EXPORTS saml::Iterator<IRevocation*>;
 376     template class SHIB_EXPORTS saml::ArrayIterator<IRevocation*>;
 377     template class SHIB_EXPORTS saml::Iterator<ICredentials*>;
 378     template class SHIB_EXPORTS saml::ArrayIterator<ICredentials*>;
 379     template class SHIB_EXPORTS saml::Iterator<IAAP*>;
 380     template class SHIB_EXPORTS saml::ArrayIterator<IAAP*>;
 381 #endif
 382
 383     struct SHIB_EXPORTS Constants
 384     {
 385         static const XMLCh SHIB_ATTRIBUTE_NAMESPACE_URI[];
 386         static const XMLCh SHIB_NAMEID_FORMAT_URI[];
 387         static const XMLCh SHIB_AUTHNREQUEST_PROFILE_URI[];
 388         static const XMLCh SHIB_NS[];
 389         static const XMLCh InvalidHandle[];
 390     };
 391
 392     // Glue classes between abstract metadata and concrete providers
 393
 394     class SHIB_EXPORTS Metadata
 395     {
 396     public:
 397         Metadata(const saml::Iterator<IMetadata*>& metadatas) : m_metadatas(metadatas), m_mapper(NULL) {}
 398         ~Metadata();
 399
 400         const IEntityDescriptor* lookup(const char* id, bool strict=true);
 401         const IEntityDescriptor* lookup(const XMLCh* id, bool strict=true);
 402         const IEntityDescriptor* lookup(const saml::SAMLArtifact* artifact);
 403
 404     private:
 405         Metadata(const Metadata&);
 406         void operator=(const Metadata&);
 407         IMetadata* m_mapper;
 408         const saml::Iterator<IMetadata*>& m_metadatas;
 409     };
 410
 411     class SHIB_EXPORTS Revocation
 412     {
 413     public:
 414         Revocation(const saml::Iterator<IRevocation*>& revocations) : m_revocations(revocations), m_mapper(NULL) {}
 415         ~Revocation();
 416
 417         saml::Iterator<void*> getRevocationLists(const IEntityDescriptor* provider, const IRoleDescriptor* role=NULL);
 418
 419     private:
 420         Revocation(const Revocation&);
 421         void operator=(const Revocation&);
 422         IRevocation* m_mapper;
 423         const saml::Iterator<IRevocation*>& m_revocations;
 424     };
 425
 426     class SHIB_EXPORTS Trust
 427     {
 428     public:
 429         Trust(const saml::Iterator<ITrust*>& trusts) : m_trusts(trusts) {}
 430         ~Trust() {}
 431
 432         bool validate(
 433             const saml::Iterator<IRevocation*>& revocations,
 434             const IRoleDescriptor* role, const saml::SAMLSignedObject& token,
 435             const saml::Iterator<IMetadata*>& metadatas=EMPTY(IMetadata*)
 436             ) const;
 437         bool attach(const saml::Iterator<IRevocation*>& revocations, const IRoleDescriptor* role, void* ctx) const;
 438
 439     private:
 440         Trust(const Trust&);
 441         void operator=(const Trust&);
 442         const saml::Iterator<ITrust*>& m_trusts;
 443     };
 444
 445     class SHIB_EXPORTS Credentials
 446     {
 447     public:
 448         Credentials(const saml::Iterator<ICredentials*>& creds) : m_creds(creds), m_mapper(NULL) {}
 449         ~Credentials();
 450
 451         const ICredResolver* lookup(const char* id);
 452
 453     private:
 454         Credentials(const Credentials&);
 455         void operator=(const Credentials&);
 456         ICredentials* m_mapper;
 457         const saml::Iterator<ICredentials*>& m_creds;
 458     };
 459
 460     class SHIB_EXPORTS AAP
 461     {
 462     public:
 463         AAP(const saml::Iterator<IAAP*>& aaps, const XMLCh* attrName, const XMLCh* attrNamespace=NULL);
 464         AAP(const saml::Iterator<IAAP*>& aaps, const char* alias);
 465         ~AAP();
 466         bool fail() const {return m_mapper==NULL;}
 467         const IAttributeRule* operator->() const {return m_rule;}
 468         operator const IAttributeRule*() const {return m_rule;}
 469
 470         static void apply(const saml::Iterator<IAAP*>& aaps, saml::SAMLAssertion& assertion, const IRoleDescriptor* role=NULL);
 471
 472     private:
 473         AAP(const AAP&);
 474         void operator=(const AAP&);
 475         IAAP* m_mapper;
 476         const IAttributeRule* m_rule;
 477     };
 478
 479     // Subclass around the OpenSAML browser profile interface,
 480     // incoporates additional functionality using Shib-defined APIs.
 481     class SHIB_EXPORTS ShibBrowserProfile : virtual public saml::SAMLBrowserProfile
 482     {
 483     public:
 484         ShibBrowserProfile(
 485             const saml::Iterator<IMetadata*>& metadatas=EMPTY(IMetadata*),
 486             const saml::Iterator<IRevocation*>& revocations=EMPTY(IRevocation*),
 487             const saml::Iterator<ITrust*>& trusts=EMPTY(ITrust*)
 488             );
 489         virtual ~ShibBrowserProfile();
 490
 491         virtual void setVersion(int major, int minor);
 492         virtual saml::SAMLBrowserProfile::BrowserProfileResponse receive(
 493             const char* packet,
 494             const XMLCh* recipient,
 495             int supportedProfiles,
 496             saml::IReplayCache* replayCache=NULL,
 497             saml::SAMLBrowserProfile::ArtifactMapper* callback=NULL
 498             ) const;
 499
 500     private:
 501         saml::SAMLBrowserProfile* m_profile;
 502         saml::Iterator<IMetadata*> m_metadatas;
 503         saml::Iterator<IRevocation*> m_revocations;
 504         saml::Iterator<ITrust*> m_trusts;
 505     };
 506
 507     // Instead of wrapping the binding to deal with mutual authentication, we
 508     // just use the HTTP hook functionality offered by OpenSAML. The hook will
 509     // register "itself" as a globalCtx pointer with the SAML binding and the caller
 510     // will declare and pass the embedded struct as callCtx for use by the hook.
 511     class SHIB_EXPORTS ShibHTTPHook : virtual public saml::SAMLSOAPHTTPBinding::HTTPHook
 512     {
 513     public:
 514         ShibHTTPHook(
 515             const saml::Iterator<IRevocation*>& revocations,
 516             const saml::Iterator<ITrust*>& trusts,
 517             const saml::Iterator<ICredentials*>& creds
 518             ) : m_revocations(revocations), m_trusts(trusts), m_creds(creds) {}
 519         virtual ~ShibHTTPHook() {}
 520
 521         // Only hook we need here is for outgoing connection to server.
 522         virtual bool outgoing(saml::HTTPClient* conn, void* globalCtx=NULL, void* callCtx=NULL);
 523
 524         // Client declares a context object and pass as callCtx to send() method.
 525         class SHIB_EXPORTS ShibHTTPHookCallContext {
 526         public:
 527             ShibHTTPHookCallContext(const char* credResolverId, const IRoleDescriptor* role)
 528                 : m_credResolverId(credResolverId), m_role(role), m_hook(NULL) {}
 529         private:
 530             const char* m_credResolverId;
 531             const IRoleDescriptor* m_role;
 532             ShibHTTPHook* m_hook;
 533             friend class ShibHTTPHook;
 534             friend bool ssl_ctx_callback(void* ssl_ctx, void* userptr);
 535         };
 536     private:
 537         friend bool ssl_ctx_callback(void* ssl_ctx, void* userptr);
 538         saml::Iterator<IRevocation*> m_revocations;
 539         saml::Iterator<ITrust*> m_trusts;
 540         saml::Iterator<ICredentials*> m_creds;
 541     };
 542
 543     class SHIB_EXPORTS ShibConfig
 544     {
 545     public:
 546         ShibConfig() {}
 547         virtual ~ShibConfig() {}
 548
 549         // global per-process setup and shutdown of Shibboleth runtime
 550         virtual bool init();
 551         virtual void term();
 552
 553         // enables runtime and clients to access configuration
 554         static ShibConfig& getConfig();
 555     };
 556
 557     /* Helper classes for implementing reloadable XML-based config files
 558        The ILockable interface will usually be inherited twice, once as
 559        part of the external interface to clients and once as an implementation
 560        detail of the reloading class below.
 561      */
 562
 563     class SHIB_EXPORTS ReloadableXMLFileImpl
 564     {
 565     public:
 566         ReloadableXMLFileImpl(const char* pathname);
 567         ReloadableXMLFileImpl(const DOMElement* pathname);
 568         virtual ~ReloadableXMLFileImpl();
 569
 570     protected:
 571         DOMDocument* m_doc;
 572         const DOMElement* m_root;
 573     };
 574
 575     class SHIB_EXPORTS ReloadableXMLFile : protected virtual saml::ILockable
 576     {
 577     public:
 578         ReloadableXMLFile(const DOMElement* e);
 579         ~ReloadableXMLFile() { delete m_lock; delete m_impl; }
 580
 581         virtual void lock();
 582         virtual void unlock() { if (m_lock) m_lock->unlock(); }
 583
 584         ReloadableXMLFileImpl* getImplementation() const;
 585
 586     protected:
 587         virtual ReloadableXMLFileImpl* newImplementation(const char* pathname, bool first=true) const=0;
 588         virtual ReloadableXMLFileImpl* newImplementation(const DOMElement* e, bool first=true) const=0;
 589         mutable ReloadableXMLFileImpl* m_impl;
 590
 591     private:
 592         const DOMElement* m_root;
 593         std::string m_source;
 594         time_t m_filestamp;
 595         RWLock* m_lock;
 596     };
 597
 598     /* These helpers attach metadata-derived information as exception properties and then
 599      * rethrow the object. The following properties are attached, when possible:
 600      *
 601      *  providerId          The unique ID of the entity
 602      *  errorURL            The error support URL of the entity or role
 603      *  contactName         A formatted support or technical contact name
 604      *  contactEmail        A contact email address
 605      */
 606     SHIB_EXPORTS void annotateException(saml::SAMLException& e, const IEntityDescriptor* entity, bool rethrow=true);
 607     SHIB_EXPORTS void annotateException(saml::SAMLException& e, const IRoleDescriptor* role, bool rethrow=true);
 608 }
 609
 610 #endif