xmltooling/security/impl/ChainingCredentialResolver.cpp

   1 /*
   2  *  Copyright 2001-2010 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  * ChainingCredentialResolver.cpp
  19  *
  20  * CredentialResolver with chaining capability.
  21  */
  22
  23 #include "internal.h"
  24 #include "logging.h"
  25 #include "XMLToolingConfig.h"
  26 #include "security/CredentialResolver.h"
  27 #include "util/NDC.h"
  28 #include "util/XMLHelper.h"
  29
  30 #include <algorithm>
  31 #include <xercesc/util/XMLUniDefs.hpp>
  32
  33 using namespace xmltooling::logging;
  34 using namespace xmltooling;
  35 using namespace std;
  36
  37 using xercesc::DOMElement;
  38
  39 namespace xmltooling {
  40     class XMLTOOL_DLLLOCAL ChainingCredentialResolver : public CredentialResolver
  41     {
  42     public:
  43         ChainingCredentialResolver(const DOMElement* e);
  44         virtual ~ChainingCredentialResolver() {
  45             for_each(m_resolvers.begin(), m_resolvers.end(), xmltooling::cleanup<CredentialResolver>());
  46         }
  47
  48         Lockable* lock() {
  49             for_each(m_resolvers.begin(), m_resolvers.end(), mem_fun(&Lockable::lock));
  50             return this;
  51         }
  52         void unlock() {
  53             for_each(m_resolvers.begin(), m_resolvers.end(), mem_fun(&Lockable::unlock));
  54         }
  55
  56         const Credential* resolve(const CredentialCriteria* criteria=nullptr) const {
  57             const Credential* cred = nullptr;
  58             for (vector<CredentialResolver*>::const_iterator cr = m_resolvers.begin(); !cred && cr!=m_resolvers.end(); ++cr)
  59                 cred = (*cr)->resolve(criteria);
  60             return cred;
  61         }
  62
  63         virtual vector<const Credential*>::size_type resolve(
  64             vector<const Credential*>& results, const CredentialCriteria* criteria=nullptr
  65             ) const {
  66             for (vector<CredentialResolver*>::const_iterator cr = m_resolvers.begin(); cr!=m_resolvers.end(); ++cr)
  67                 (*cr)->resolve(results, criteria);
  68             return results.size();
  69         }
  70
  71     private:
  72         vector<CredentialResolver*> m_resolvers;
  73     };
  74
  75     CredentialResolver* XMLTOOL_DLLLOCAL ChainingCredentialResolverFactory(const DOMElement* const & e)
  76     {
  77         return new ChainingCredentialResolver(e);
  78     }
  79
  80     static const XMLCh _CredentialResolver[] =  UNICODE_LITERAL_18(C,r,e,d,e,n,t,i,a,l,R,e,s,o,l,v,e,r);
  81     static const XMLCh type[] =                 UNICODE_LITERAL_4(t,y,p,e);
  82 };
  83
  84 ChainingCredentialResolver::ChainingCredentialResolver(const DOMElement* e)
  85 {
  86     XMLToolingConfig& conf = XMLToolingConfig::getConfig();
  87     Category& log=Category::getInstance(XMLTOOLING_LOGCAT".CredentialResolver."CHAINING_CREDENTIAL_RESOLVER);
  88
  89     // Load up the chain of resolvers.
  90     e = e ? XMLHelper::getFirstChildElement(e, _CredentialResolver) : nullptr;
  91     while (e) {
  92         string t = XMLHelper::getAttrString(e, nullptr, type);
  93         if (!t.empty()) {
  94             log.info("building CredentialResolver of type %s", t.c_str());
  95             try {
  96                 m_resolvers.push_back(conf.CredentialResolverManager.newPlugin(t.c_str(), e));
  97             }
  98             catch (exception& ex) {
  99                 log.error("caught exception processing embedded CredentialResolver element: %s", ex.what());
 100             }
 101         }
 102         e = XMLHelper::getNextSiblingElement(e, _CredentialResolver);
 103     }
 104 }