saml/saml2/metadata/impl/WhitelistMetadataFilter.cpp

   1 /*
   2  *  Copyright 2001-2009 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * WhitelistMetadataFilter.cpp
  19  *
  20  * Removes non-whitelisted entities from a metadata instance
  21  */
  22
  23 #include "internal.h"
  24 #include "saml2/metadata/Metadata.h"
  25 #include "saml2/metadata/MetadataFilter.h"
  26
  27 #include <xmltooling/logging.h>
  28 #include <xmltooling/util/NDC.h>
  29
  30 using namespace opensaml::saml2md;
  31 using namespace xmltooling::logging;
  32 using namespace xmltooling;
  33 using namespace std;
  34
  35 namespace opensaml {
  36     namespace saml2md {
  37
  38         class SAML_DLLLOCAL WhitelistMetadataFilter : public MetadataFilter
  39         {
  40         public:
  41             WhitelistMetadataFilter(const DOMElement* e);
  42             ~WhitelistMetadataFilter() {}
  43
  44             const char* getId() const { return WHITELIST_METADATA_FILTER; }
  45             void doFilter(XMLObject& xmlObject) const;
  46
  47         private:
  48             void doFilter(EntitiesDescriptor& entities) const;
  49
  50             bool found(const XMLCh* id) const {
  51                 if (!id)
  52                     return false;
  53                 return m_set.count(id)==1;
  54             }
  55
  56             set<xstring> m_set;
  57         };
  58
  59         MetadataFilter* SAML_DLLLOCAL WhitelistMetadataFilterFactory(const DOMElement* const & e)
  60         {
  61             return new WhitelistMetadataFilter(e);
  62         }
  63
  64     };
  65 };
  66
  67 static const XMLCh Include[] =  UNICODE_LITERAL_7(I,n,c,l,u,d,e);
  68
  69 WhitelistMetadataFilter::WhitelistMetadataFilter(const DOMElement* e)
  70 {
  71     e = XMLHelper::getFirstChildElement(e);
  72     while (e) {
  73         if (XMLString::equals(e->getLocalName(), Include) && e->hasChildNodes()) {
  74             m_set.insert(e->getFirstChild()->getNodeValue());
  75         }
  76         e = XMLHelper::getNextSiblingElement(e);
  77     }
  78 }
  79
  80 void WhitelistMetadataFilter::doFilter(XMLObject& xmlObject) const
  81 {
  82 #ifdef _DEBUG
  83     NDC ndc("doFilter");
  84 #endif
  85
  86     try {
  87         doFilter(dynamic_cast<EntitiesDescriptor&>(xmlObject));
  88         return;
  89     }
  90     catch (bad_cast) {
  91     }
  92
  93     try {
  94         EntityDescriptor& entity = dynamic_cast<EntityDescriptor&>(xmlObject);
  95         if (!found(entity.getEntityID()))
  96             throw MetadataFilterException("WhitelistMetadataFilter instructed to filter the root/only entity in the metadata.");
  97         return;
  98     }
  99     catch (bad_cast) {
 100     }
 101
 102     throw MetadataFilterException("WhitelistMetadataFilter was given an improper metadata instance to filter.");
 103 }
 104
 105 void WhitelistMetadataFilter::doFilter(EntitiesDescriptor& entities) const
 106 {
 107     Category& log=Category::getInstance(SAML_LOGCAT".MetadataFilter.Whitelist");
 108
 109     VectorOf(EntityDescriptor) v=entities.getEntityDescriptors();
 110     for (VectorOf(EntityDescriptor)::size_type i=0; i<v.size(); ) {
 111         const XMLCh* id=v[i]->getEntityID();
 112         if (!found(id)) {
 113             auto_ptr_char id2(id);
 114             log.info("filtering out non-whitelisted entity (%s)", id2.get());
 115             v.erase(v.begin() + i);
 116         }
 117         else {
 118             i++;
 119         }
 120     }
 121
 122     const vector<EntitiesDescriptor*>& groups=const_cast<const EntitiesDescriptor&>(entities).getEntitiesDescriptors();
 123     for (vector<EntitiesDescriptor*>::const_iterator j=groups.begin(); j!=groups.end(); j++)
 124         doFilter(*(*j));
 125 }