saml/saml2/metadata/impl/MetadataProvider.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * MetadataProvider.cpp
  23  *
  24  * Supplies an individual source of metadata.
  25  */
  26
  27 #include "internal.h"
  28 #include "saml2/metadata/MetadataFilter.h"
  29 #include "saml2/metadata/MetadataProvider.h"
  30
  31 #include <algorithm>
  32 #include <xercesc/util/XMLUniDefs.hpp>
  33 #include <xmltooling/logging.h>
  34 #include <xmltooling/unicode.h>
  35 #include <xmltooling/util/NDC.h>
  36 #include <xmltooling/util/XMLHelper.h>
  37
  38 using namespace opensaml::saml2md;
  39 using namespace opensaml;
  40 using namespace xmltooling::logging;
  41 using namespace xmltooling;
  42 using namespace std;
  43
  44 namespace opensaml {
  45     namespace saml2md {
  46         SAML_DLLLOCAL PluginManager<MetadataProvider,string,const DOMElement*>::Factory XMLMetadataProviderFactory;
  47         SAML_DLLLOCAL PluginManager<MetadataProvider,string,const DOMElement*>::Factory DynamicMetadataProviderFactory;
  48         SAML_DLLLOCAL PluginManager<MetadataProvider,string,const DOMElement*>::Factory ChainingMetadataProviderFactory;
  49         SAML_DLLLOCAL PluginManager<MetadataProvider,string,const DOMElement*>::Factory NullMetadataProviderFactory;
  50         SAML_DLLLOCAL PluginManager<MetadataFilter,string,const DOMElement*>::Factory BlacklistMetadataFilterFactory;
  51         SAML_DLLLOCAL PluginManager<MetadataFilter,string,const DOMElement*>::Factory WhitelistMetadataFilterFactory;
  52         SAML_DLLLOCAL PluginManager<MetadataFilter,string,const DOMElement*>::Factory SignatureMetadataFilterFactory;
  53         SAML_DLLLOCAL PluginManager<MetadataFilter,string,const DOMElement*>::Factory RequireValidUntilMetadataFilterFactory;
  54         SAML_DLLLOCAL PluginManager<MetadataFilter,string,const DOMElement*>::Factory EntityRoleMetadataFilterFactory;
  55     };
  56 };
  57
  58 void SAML_API opensaml::saml2md::registerMetadataProviders()
  59 {
  60     SAMLConfig& conf=SAMLConfig::getConfig();
  61     conf.MetadataProviderManager.registerFactory(XML_METADATA_PROVIDER, XMLMetadataProviderFactory);
  62     conf.MetadataProviderManager.registerFactory(DYNAMIC_METADATA_PROVIDER, DynamicMetadataProviderFactory);
  63     conf.MetadataProviderManager.registerFactory(CHAINING_METADATA_PROVIDER, ChainingMetadataProviderFactory);
  64     conf.MetadataProviderManager.registerFactory(NULL_METADATA_PROVIDER, NullMetadataProviderFactory);
  65 }
  66
  67 void SAML_API opensaml::saml2md::registerMetadataFilters()
  68 {
  69     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(BLACKLIST_METADATA_FILTER, BlacklistMetadataFilterFactory);
  70     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(WHITELIST_METADATA_FILTER, WhitelistMetadataFilterFactory);
  71     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(SIGNATURE_METADATA_FILTER, SignatureMetadataFilterFactory);
  72     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(REQUIREVALIDUNTIL_METADATA_FILTER, RequireValidUntilMetadataFilterFactory);
  73     // additional name matching Java code
  74     SAMLConfig::getConfig().MetadataFilterManager.registerFactory("RequiredValidUntil", RequireValidUntilMetadataFilterFactory);
  75     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(ENTITYROLE_METADATA_FILTER, EntityRoleMetadataFilterFactory);
  76 }
  77
  78 static const XMLCh _MetadataFilter[] =  UNICODE_LITERAL_14(M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  79 static const XMLCh Blacklist[] =        UNICODE_LITERAL_23(B,l,a,c,k,l,i,s,t,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  80 static const XMLCh Whitelist[] =        UNICODE_LITERAL_23(W,h,i,t,e,l,i,s,t,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  81 static const XMLCh SigFilter[] =        UNICODE_LITERAL_23(S,i,g,n,a,t,u,r,e,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  82 static const XMLCh Exclude[] =          UNICODE_LITERAL_7(E,x,c,l,u,d,e);
  83 static const XMLCh Include[] =          UNICODE_LITERAL_7(I,n,c,l,u,d,e);
  84 static const XMLCh type[] =             UNICODE_LITERAL_4(t,y,p,e);
  85
  86 MetadataProvider::MetadataProvider(const DOMElement* e)
  87 {
  88 #ifdef _DEBUG
  89     NDC ndc("MetadataProvider");
  90 #endif
  91     Category& log = Category::getInstance(SAML_LOGCAT".Metadata");
  92     SAMLConfig& conf = SAMLConfig::getConfig();
  93
  94     // Locate any default recognized filters and plugins.
  95     try {
  96         DOMElement* child = XMLHelper::getFirstChildElement(e);
  97         while (child) {
  98             if (XMLString::equals(child->getLocalName(), _MetadataFilter)) {
  99                 string t = XMLHelper::getAttrString(child, nullptr, type);
 100                 if (!t.empty()) {
 101                     log.info("building MetadataFilter of type %s", t.c_str());
 102                     m_filters.push_back(conf.MetadataFilterManager.newPlugin(t.c_str(), child));
 103                 }
 104             }
 105             else if (XMLString::equals(child->getLocalName(), SigFilter)) {
 106                 log.info("building MetadataFilter of type %s", SIGNATURE_METADATA_FILTER);
 107                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(SIGNATURE_METADATA_FILTER, child));
 108             }
 109             else if (XMLString::equals(child->getLocalName(), Whitelist)) {
 110                 log.info("building MetadataFilter of type %s", WHITELIST_METADATA_FILTER);
 111                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(WHITELIST_METADATA_FILTER, child));
 112             }
 113             else if (XMLString::equals(child->getLocalName(), Blacklist)) {
 114                 log.info("building MetadataFilter of type %s", BLACKLIST_METADATA_FILTER);
 115                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(BLACKLIST_METADATA_FILTER, child));
 116             }
 117             else if (XMLString::equals(child->getLocalName(), Include)) {
 118                 log.info("building MetadataFilter of type %s", WHITELIST_METADATA_FILTER);
 119                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(WHITELIST_METADATA_FILTER, e));
 120             }
 121             else if (XMLString::equals(child->getLocalName(), Exclude)) {
 122                 log.info("building MetadataFilter of type %s", BLACKLIST_METADATA_FILTER);
 123                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(BLACKLIST_METADATA_FILTER, e));
 124             }
 125             child = XMLHelper::getNextSiblingElement(child);
 126         }
 127     }
 128     catch (XMLToolingException& ex) {
 129         log.error("caught exception while installing filters: %s", ex.what());
 130         for_each(m_filters.begin(),m_filters.end(),xmltooling::cleanup<MetadataFilter>());
 131         throw;
 132     }
 133 }
 134
 135 MetadataProvider::~MetadataProvider()
 136 {
 137     for_each(m_filters.begin(), m_filters.end(), xmltooling::cleanup<MetadataFilter>());
 138 }
 139
 140 const char* MetadataProvider::getId() const
 141 {
 142     return nullptr;
 143 }
 144
 145 void MetadataProvider::addMetadataFilter(MetadataFilter* newFilter)
 146 {
 147     m_filters.push_back(newFilter);
 148 }
 149
 150 MetadataFilter* MetadataProvider::removeMetadataFilter(MetadataFilter* oldFilter)
 151 {
 152     for (vector<MetadataFilter*>::iterator i=m_filters.begin(); i!=m_filters.end(); i++) {
 153         if (oldFilter==(*i)) {
 154             m_filters.erase(i);
 155             return oldFilter;
 156         }
 157     }
 158     return nullptr;
 159 }
 160
 161 void MetadataProvider::doFilters(XMLObject& xmlObject) const
 162 {
 163 #ifdef _DEBUG
 164     NDC ndc("doFilters");
 165 #endif
 166     Category& log=Category::getInstance(SAML_LOGCAT".Metadata");
 167     for (std::vector<MetadataFilter*>::const_iterator i=m_filters.begin(); i!=m_filters.end(); i++) {
 168         log.info("applying metadata filter (%s)", (*i)->getId());
 169         (*i)->doFilter(xmlObject);
 170     }
 171 }
 172
 173 void MetadataProvider::outputStatus(ostream& os) const
 174 {
 175 }
 176
 177 const EntitiesDescriptor* MetadataProvider::getEntitiesDescriptor(const XMLCh* name, bool strict) const
 178 {
 179     auto_ptr_char temp(name);
 180     return getEntitiesDescriptor(temp.get(),strict);
 181 }
 182
 183 MetadataProvider::Criteria::Criteria()
 184     : entityID_unicode(nullptr), entityID_ascii(nullptr), artifact(nullptr), role(nullptr), protocol(nullptr), protocol2(nullptr), validOnly(true)
 185 {
 186 }
 187
 188 MetadataProvider::Criteria::Criteria(const XMLCh* id, const xmltooling::QName* q, const XMLCh* prot, bool valid)
 189     : entityID_unicode(id), entityID_ascii(nullptr), artifact(nullptr), role(q), protocol(prot), protocol2(nullptr), validOnly(valid)
 190 {
 191 }
 192
 193 MetadataProvider::Criteria::Criteria(const char* id, const xmltooling::QName* q, const XMLCh* prot, bool valid)
 194     : entityID_unicode(nullptr), entityID_ascii(id), artifact(nullptr), role(q), protocol(prot), protocol2(nullptr), validOnly(valid)
 195 {
 196 }
 197
 198 MetadataProvider::Criteria::Criteria(const SAMLArtifact* a, const xmltooling::QName* q, const XMLCh* prot, bool valid)
 199     : entityID_unicode(nullptr), entityID_ascii(nullptr), artifact(a), role(q), protocol(prot), protocol2(nullptr), validOnly(valid)
 200 {
 201 }
 202
 203 MetadataProvider::Criteria::~Criteria()
 204 {
 205 }
 206
 207 void MetadataProvider::Criteria::reset()
 208 {
 209     entityID_unicode=nullptr;
 210     entityID_ascii=nullptr;
 211     artifact=nullptr;
 212     role=nullptr;
 213     protocol=nullptr;
 214     protocol2=nullptr;
 215     validOnly=true;
 216 }
 217
 218 MetadataFilter::MetadataFilter()
 219 {
 220 }
 221
 222 MetadataFilter::~MetadataFilter()
 223 {
 224 }