SSPCPP-616 - clean up concatenated string literals

diff --git a/xmltooling/AbstractXMLObject.cpp b/xmltooling/AbstractXMLObject.cpp
index 4ba5d7c..59c41d0 100644 (file)
--- a/xmltooling/AbstractXMLObject.cpp
+++ b/xmltooling/AbstractXMLObject.cpp
@@ -87,7 +87,7 @@ void XMLObject::setNil(const XMLCh* value)
 }
 
 AbstractXMLObject::AbstractXMLObject(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
-    : m_log(logging::Category::getInstance(XMLTOOLING_LOGCAT".XMLObject")),
+    : m_log(logging::Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject")),
        m_schemaLocation(nullptr), m_noNamespaceSchemaLocation(nullptr), m_nil(xmlconstants::XML_BOOL_NULL),
         m_parent(nullptr), m_elementQname(nsURI, localName, prefix)
 {

diff --git a/xmltooling/XMLObjectBuilder.cpp b/xmltooling/XMLObjectBuilder.cpp
index ec08c16..6b33a6d 100644 (file)
--- a/xmltooling/XMLObjectBuilder.cpp
+++ b/xmltooling/XMLObjectBuilder.cpp
@@ -85,7 +85,7 @@ const XMLObjectBuilder* XMLObjectBuilder::getBuilder(const DOMElement* domElemen
 #ifdef _DEBUG
     xmltooling::NDC ndc("getBuilder");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Builder");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject.Builder");
  
     auto_ptr<QName> schemaType(XMLHelper::getXSIType(domElement));
     const XMLObjectBuilder* xmlObjectBuilder = schemaType.get() ? getBuilder(*(schemaType.get())) : nullptr;

diff --git a/xmltooling/XMLToolingConfig.cpp b/xmltooling/XMLToolingConfig.cpp
index 4a6e873..6925a23 100644 (file)
--- a/xmltooling/XMLToolingConfig.cpp
+++ b/xmltooling/XMLToolingConfig.cpp
@@ -132,7 +132,7 @@ namespace {
     class TXFMOutputLog : public TXFMBase {
            TXFMOutputLog();
     public:
-        TXFMOutputLog(DOMDocument* doc) : TXFMBase(doc), m_log(Category::getInstance(XMLTOOLING_LOGCAT".Signature.Debugger")) {
+        TXFMOutputLog(DOMDocument* doc) : TXFMBase(doc), m_log(Category::getInstance(XMLTOOLING_LOGCAT ".Signature.Debugger")) {
             input = nullptr;
         }
         ~TXFMOutputLog() {
@@ -178,7 +178,7 @@ namespace {
     };
 
     TXFMBase* TXFMOutputLogFactory(DOMDocument* doc) {
-        if (Category::getInstance(XMLTOOLING_LOGCAT".Signature.Debugger").isDebugEnabled())
+        if (Category::getInstance(XMLTOOLING_LOGCAT ".Signature.Debugger").isDebugEnabled())
             return new TXFMOutputLog(doc);
         return nullptr;
     }
@@ -351,12 +351,12 @@ bool XMLToolingInternalConfig::log_config(const char* config)
         }
 
 #ifndef XMLTOOLING_NO_XMLSEC
-        Category::getInstance(XMLTOOLING_LOGCAT".Signature.Debugger").setAdditivity(false);
+        Category::getInstance(XMLTOOLING_LOGCAT ".Signature.Debugger").setAdditivity(false);
 #endif
        }
     catch (const ConfigureFailure& e) {
         string msg = string("error in file permissions or logging configuration: ") + e.what();
-        Category::getInstance(XMLTOOLING_LOGCAT".Logging").crit(msg);
+        Category::getInstance(XMLTOOLING_LOGCAT ".Logging").crit(msg);
 #ifdef WIN32
         LogEvent(nullptr, EVENTLOG_ERROR_TYPE, 2100, nullptr, msg.c_str());
 #endif
@@ -371,7 +371,7 @@ bool XMLToolingInternalConfig::init()
 #ifdef _DEBUG
     xmltooling::NDC ndc("init");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".Config");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".Config");
 
     Lock initLock(m_lock);
 
@@ -502,7 +502,7 @@ void XMLToolingInternalConfig::term()
 
     Lock initLock(m_lock);
     if (m_initCount == 0) {
-        Category::getInstance(XMLTOOLING_LOGCAT".Config").crit("term without corresponding init");
+        Category::getInstance(XMLTOOLING_LOGCAT ".Config").crit("term without corresponding init");
         return;
     }
     else if (--m_initCount > 0) {
@@ -584,7 +584,7 @@ void XMLToolingInternalConfig::term()
 #ifndef XMLTOOLING_NO_XMLSEC
     curl_global_cleanup();
 #endif
-   Category::getInstance(XMLTOOLING_LOGCAT".Config").info("%s library shutdown complete", PACKAGE_STRING);
+   Category::getInstance(XMLTOOLING_LOGCAT ".Config").info("%s library shutdown complete", PACKAGE_STRING);
 }
 
 Lockable* XMLToolingInternalConfig::lock()
@@ -614,7 +614,7 @@ bool XMLToolingInternalConfig::load_library(const char* path, void* context)
 #ifdef _DEBUG
     xmltooling::NDC ndc("LoadLibrary");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".Config");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".Config");
     log.info("loading extension: %s", path);
 
     Locker locker(this);

diff --git a/xmltooling/encryption/impl/Decrypter.cpp b/xmltooling/encryption/impl/Decrypter.cpp
index ce9445f..584aae0 100644 (file)
--- a/xmltooling/encryption/impl/Decrypter.cpp
+++ b/xmltooling/encryption/impl/Decrypter.cpp
@@ -153,7 +153,7 @@ DOMDocumentFragment* Decrypter::decryptData(const EncryptedData& encryptedData,
             return decryptData(encryptedData, key);
         }
         catch(DecryptionException& ex) {
-            logging::Category::getInstance(XMLTOOLING_LOGCAT".Decrypter").warn(ex.what());
+            logging::Category::getInstance(XMLTOOLING_LOGCAT ".Decrypter").warn(ex.what());
         }
     }
 
@@ -258,7 +258,7 @@ void Decrypter::decryptData(ostream& out, const EncryptedData& encryptedData, co
             return decryptData(out, encryptedData, key);
         }
         catch(DecryptionException& ex) {
-            logging::Category::getInstance(XMLTOOLING_LOGCAT".Decrypter").warn(ex.what());
+            logging::Category::getInstance(XMLTOOLING_LOGCAT ".Decrypter").warn(ex.what());
         }
     }
 
@@ -366,13 +366,13 @@ XSECCryptoKey* Decrypter::decryptKey(const EncryptedKey& encryptedKey, const XML
             }
         }
         catch(DecryptionException& ex) {
-            logging::Category::getInstance(XMLTOOLING_LOGCAT".Decrypter").warn(ex.what());
+            logging::Category::getInstance(XMLTOOLING_LOGCAT ".Decrypter").warn(ex.what());
         }
     }
     
     // Some algorithms are vulnerable to chosen ciphertext attacks, so we generate a random key
     // to prevent discovery of the validity of the original candidate.
-    logging::Category::getInstance(XMLTOOLING_LOGCAT".Decrypter").warn(
+    logging::Category::getInstance(XMLTOOLING_LOGCAT ".Decrypter").warn(
         "unable to decrypt key, generating random key for defensive purposes"
         );
     pair<const char*,unsigned int> mapped = XMLToolingConfig::getConfig().mapXMLAlgorithmToKeyAlgorithm(algorithm);

diff --git a/xmltooling/impl/MemoryStorageService.cpp b/xmltooling/impl/MemoryStorageService.cpp
index 6d4688f..785bfc6 100644 (file)
--- a/xmltooling/impl/MemoryStorageService.cpp
+++ b/xmltooling/impl/MemoryStorageService.cpp
@@ -136,7 +136,7 @@ static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,
 MemoryStorageService::MemoryStorageService(const DOMElement* e)
     : m_lock(RWLock::create()), shutdown_wait(CondWait::create()), shutdown(false),
         m_cleanupInterval(XMLHelper::getAttrInt(e, 900, cleanupInterval)),
-        m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))
+        m_log(Category::getInstance(XMLTOOLING_LOGCAT ".StorageService"))
 {
     cleanup_thread.reset(Thread::create(&cleanup_fn, (void*)this));
 }

diff --git a/xmltooling/impl/UnknownElement.cpp b/xmltooling/impl/UnknownElement.cpp
index 2155eb0..270b50f 100644 (file)
--- a/xmltooling/impl/UnknownElement.cpp
+++ b/xmltooling/impl/UnknownElement.cpp
@@ -57,7 +57,7 @@ void UnknownElementImpl::releaseDOM() const
 #ifdef _DEBUG
     xmltooling::NDC ndc("releaseDOM");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject");
     log.debug("releasing DOM for unknown content, preserving current DOM in XML form");
 
     // We're losing our DOM, so assuming we have one, we preserve it.
@@ -118,7 +118,7 @@ DOMElement* UnknownElementImpl::marshall(
     xmltooling::NDC ndc("marshall");
 #endif
     
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject");
     log.debug("marshalling unknown content");
 
     DOMElement* cachedDOM=getDOM();
@@ -203,7 +203,7 @@ DOMElement* UnknownElementImpl::marshall(
     xmltooling::NDC ndc("marshall");
 #endif
     
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject");
     log.debug("marshalling unknown content");
 
     DOMElement* cachedDOM=getDOM();

diff --git a/xmltooling/security/impl/AbstractPKIXTrustEngine.cpp b/xmltooling/security/impl/AbstractPKIXTrustEngine.cpp
index 9a3f95b..5554fb9 100644 (file)
--- a/xmltooling/security/impl/AbstractPKIXTrustEngine.cpp
+++ b/xmltooling/security/impl/AbstractPKIXTrustEngine.cpp
@@ -129,7 +129,7 @@ AbstractPKIXTrustEngine::AbstractPKIXTrustEngine(const xercesc::DOMElement* e)
                m_anyPolicyInhibit(XMLHelper::getAttrBool(e, false, anyPolicyInhibit))
 {
     if (m_fullCRLChain) {
-        Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX").warn(
+        Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX").warn(
             "fullCRLChain option is deprecated, setting checkRevocation to \"fullChain\""
             );
         m_checkRevocation = "fullChain";
@@ -153,7 +153,7 @@ AbstractPKIXTrustEngine::AbstractPKIXTrustEngine(const xercesc::DOMElement* e)
             try {
                 string t = XMLHelper::getAttrString(c, nullptr, type);
                 if (!t.empty()) {
-                    Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX").info(
+                    Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX").info(
                         "building PathValidator of type %s", t.c_str()
                         );
                     PathValidator* pv = XMLToolingConfig::getConfig().PathValidatorManager.newPlugin(t.c_str(), c);
@@ -166,7 +166,7 @@ AbstractPKIXTrustEngine::AbstractPKIXTrustEngine(const xercesc::DOMElement* e)
                 }
             }
             catch (exception& ex) {
-                Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX").error(
+                Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX").error(
                     "error building PathValidator: %s", ex.what()
                     );
             }
@@ -191,7 +191,7 @@ bool AbstractPKIXTrustEngine::checkEntityNames(
     X509* certEE, const CredentialResolver& credResolver, const CredentialCriteria& criteria
     ) const
 {
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX");
 
     // We resolve to a set of trusted credentials.
     vector<const Credential*> creds;
@@ -346,7 +346,7 @@ bool AbstractPKIXTrustEngine::validateWithCRLs(
 #ifdef _DEBUG
     NDC ndc("validateWithCRLs");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX");
 
     if (!certEE) {
         log.error("X.509 credential was NULL, unable to perform validation");
@@ -409,11 +409,11 @@ bool AbstractPKIXTrustEngine::validate(
         NDC ndc("validate");
 #endif
     if (!certEE) {
-        Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX").error("X.509 credential was NULL, unable to perform validation");
+        Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX").error("X.509 credential was NULL, unable to perform validation");
         return false;
     }
     else if (certEE->getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL) {
-        Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX").error("only the OpenSSL XSEC provider is supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX").error("only the OpenSSL XSEC provider is supported");
         return false;
     }
 
@@ -435,7 +435,7 @@ bool AbstractPKIXTrustEngine::validate(
 #ifdef _DEBUG
     NDC ndc("validate");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX");
 
     const KeyInfoResolver* inlineResolver = m_keyInfoResolver;
     if (!inlineResolver)
@@ -508,7 +508,7 @@ bool AbstractPKIXTrustEngine::validate(
 #ifdef _DEBUG
     NDC ndc("validate");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.PKIX");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.PKIX");
 
     if (!keyInfo) {
         log.error("unable to perform PKIX validation, KeyInfo not present");

diff --git a/xmltooling/security/impl/ChainingCredentialResolver.cpp b/xmltooling/security/impl/ChainingCredentialResolver.cpp
index dd3c343..ae3d2ae 100644 (file)
--- a/xmltooling/security/impl/ChainingCredentialResolver.cpp
+++ b/xmltooling/security/impl/ChainingCredentialResolver.cpp
@@ -95,7 +95,7 @@ namespace xmltooling {
 ChainingCredentialResolver::ChainingCredentialResolver(const DOMElement* e)
 {
     XMLToolingConfig& conf = XMLToolingConfig::getConfig();
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".CredentialResolver."CHAINING_CREDENTIAL_RESOLVER);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".CredentialResolver." CHAINING_CREDENTIAL_RESOLVER);
 
     // Load up the chain of resolvers.
     e = e ? XMLHelper::getFirstChildElement(e, _CredentialResolver) : nullptr;

diff --git a/xmltooling/security/impl/ChainingTrustEngine.cpp b/xmltooling/security/impl/ChainingTrustEngine.cpp
index cd9fd87..fbde4a5 100644 (file)
--- a/xmltooling/security/impl/ChainingTrustEngine.cpp
+++ b/xmltooling/security/impl/ChainingTrustEngine.cpp
@@ -56,7 +56,7 @@ static const XMLCh _type[] =                         UNICODE_LITERAL_4(t,y,p,e);
 
 ChainingTrustEngine::ChainingTrustEngine(const DOMElement* e) : TrustEngine(e)
 {
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."CHAINING_TRUSTENGINE);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine." CHAINING_TRUSTENGINE);
     e = e ? XMLHelper::getFirstChildElement(e, _TrustEngine) : nullptr;
     while (e) {
         try {

diff --git a/xmltooling/security/impl/CredentialCriteria.cpp b/xmltooling/security/impl/CredentialCriteria.cpp
index 8853bbf..1b2f0e8 100644 (file)
--- a/xmltooling/security/impl/CredentialCriteria.cpp
+++ b/xmltooling/security/impl/CredentialCriteria.cpp
@@ -217,7 +217,7 @@ void CredentialCriteria::reset()
 
 bool CredentialCriteria::matches(const Credential& credential) const
 {
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".CredentialCriteria");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".CredentialCriteria");
 
     // Usage check, if specified and we have one, compare masks.
     if (getUsage() != Credential::UNSPECIFIED_CREDENTIAL) {

diff --git a/xmltooling/security/impl/ExplicitKeyTrustEngine.cpp b/xmltooling/security/impl/ExplicitKeyTrustEngine.cpp
index 5e9d4ac..14e5f48 100644 (file)
--- a/xmltooling/security/impl/ExplicitKeyTrustEngine.cpp
+++ b/xmltooling/security/impl/ExplicitKeyTrustEngine.cpp
@@ -97,7 +97,7 @@ bool ExplicitKeyTrustEngine::validate(
 #ifdef _DEBUG
     NDC ndc("validate");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."EXPLICIT_KEY_TRUSTENGINE);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine." EXPLICIT_KEY_TRUSTENGINE);
 
     vector<const Credential*> credentials;
     if (criteria) {
@@ -147,7 +147,7 @@ bool ExplicitKeyTrustEngine::validate(
 #ifdef _DEBUG
     NDC ndc("validate");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."EXPLICIT_KEY_TRUSTENGINE);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine."EXPLICIT_KEY_TRUSTENGINE);
     
     vector<const Credential*> credentials;
     if (criteria) {
@@ -200,11 +200,11 @@ bool ExplicitKeyTrustEngine::validate(
         NDC ndc("validate");
 #endif
     if (!certEE) {
-        Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."EXPLICIT_KEY_TRUSTENGINE).error("unable to validate, end-entity certificate was null");
+        Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine."EXPLICIT_KEY_TRUSTENGINE).error("unable to validate, end-entity certificate was null");
         return false;
     }
     else if (certEE->getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL) {
-        Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."EXPLICIT_KEY_TRUSTENGINE).error("only the OpenSSL XSEC provider is supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine."EXPLICIT_KEY_TRUSTENGINE).error("only the OpenSSL XSEC provider is supported");
         return false;
     }
 
@@ -221,7 +221,7 @@ bool ExplicitKeyTrustEngine::validate(
 #ifdef _DEBUG
     NDC ndc("validate");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine."EXPLICIT_KEY_TRUSTENGINE);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine."EXPLICIT_KEY_TRUSTENGINE);
     
     if (!certEE) {
         log.error("unable to validate, end-entity certificate was null");

diff --git a/xmltooling/security/impl/FilesystemCredentialResolver.cpp b/xmltooling/security/impl/FilesystemCredentialResolver.cpp
index 480ef3b..e74eb71 100644 (file)
--- a/xmltooling/security/impl/FilesystemCredentialResolver.cpp
+++ b/xmltooling/security/impl/FilesystemCredentialResolver.cpp
@@ -322,7 +322,7 @@ FilesystemCredentialResolver::FilesystemCredentialResolver(const DOMElement* e)
 #ifdef _DEBUG
     NDC ndc("FilesystemCredentialResolver");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".CredentialResolver."FILESYSTEM_CREDENTIAL_RESOLVER);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".CredentialResolver." FILESYSTEM_CREDENTIAL_RESOLVER);
 
     if (e && (e->hasAttributeNS(nullptr,_certificate) || e->hasAttributeNS(nullptr,_key))) {
         // Dummy up a simple file resolver config using these attributes.
@@ -577,7 +577,7 @@ Lockable* FilesystemCredentialResolver::lock()
 #ifdef _DEBUG
     NDC ndc("lock");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".CredentialResolver."FILESYSTEM_CREDENTIAL_RESOLVER);
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".CredentialResolver."FILESYSTEM_CREDENTIAL_RESOLVER);
 
     m_lock->rdlock();
 

diff --git a/xmltooling/security/impl/InlineKeyResolver.cpp b/xmltooling/security/impl/InlineKeyResolver.cpp
index 4e32025..a4baf85 100644 (file)
--- a/xmltooling/security/impl/InlineKeyResolver.cpp
+++ b/xmltooling/security/impl/InlineKeyResolver.cpp
@@ -255,7 +255,7 @@ void InlineCredential::resolve(const KeyInfo* keyInfo, int types, bool followRef
 
 bool InlineCredential::resolveKey(const KeyInfo* keyInfo, bool followRefs)
 {
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".KeyInfoResolver."INLINE_KEYINFO_RESOLVER);
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".KeyInfoResolver." INLINE_KEYINFO_RESOLVER);
 
     // Check for ds:KeyValue
     const vector<KeyValue*>& keyValues = keyInfo->getKeyValues();
@@ -366,7 +366,7 @@ bool InlineCredential::resolveKey(const KeyInfo* keyInfo, bool followRefs)
 
 bool InlineCredential::resolveCerts(const KeyInfo* keyInfo, bool followRefs)
 {
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".KeyInfoResolver."INLINE_KEYINFO_RESOLVER);
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".KeyInfoResolver."INLINE_KEYINFO_RESOLVER);
 
     // Check for ds:X509Data
     const vector<X509Data*>& x509Datas=keyInfo->getX509Datas();
@@ -430,7 +430,7 @@ bool InlineCredential::resolveCerts(const KeyInfo* keyInfo, bool followRefs)
 
 bool InlineCredential::resolveCRLs(const KeyInfo* keyInfo, bool followRefs)
 {
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".KeyInfoResolver."INLINE_KEYINFO_RESOLVER);
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".KeyInfoResolver."INLINE_KEYINFO_RESOLVER);
 
     // Check for ds:X509Data
     const vector<X509Data*>& x509Datas=keyInfo->getX509Datas();
@@ -506,10 +506,10 @@ void InlineCredential::resolve(DSIGKeyInfoList* keyInfo, int types, bool followR
         }
         catch(XSECException& e) {
             auto_ptr_char temp(e.getMsg());
-            Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading certificate: %s", temp.get());
+            Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading certificate: %s", temp.get());
         }
         catch(XSECCryptoException& e) {
-            Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading certificate: %s", e.getMsg());
+            Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading certificate: %s", e.getMsg());
         }
     }
 
@@ -545,10 +545,10 @@ void InlineCredential::resolve(DSIGKeyInfoList* keyInfo, int types, bool followR
                         }
                         catch(XSECException& e) {
                             auto_ptr_char temp(e.getMsg());
-                            Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", temp.get());
+                            Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", temp.get());
                         }
                         catch(XSECCryptoException& e) {
-                            Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", e.getMsg());
+                            Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", e.getMsg());
                         }
                     }
                 }
@@ -568,10 +568,10 @@ void InlineCredential::resolve(DSIGKeyInfoList* keyInfo, int types, bool followR
                             }
                             catch(XSECException& e) {
                                 auto_ptr_char temp(e.getMsg());
-                                Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", temp.get());
+                                Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", temp.get());
                             }
                             catch(XSECCryptoException& e) {
-                                Category::getInstance(XMLTOOLING_LOGCAT".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", e.getMsg());
+                                Category::getInstance(XMLTOOLING_LOGCAT ".KeyResolver."INLINE_KEYINFO_RESOLVER).error("caught XML-Security exception loading CRL: %s", e.getMsg());
                             }
                         }
                     }

diff --git a/xmltooling/security/impl/PKIXPathValidator.cpp b/xmltooling/security/impl/PKIXPathValidator.cpp
index 138a891..e9037a0 100644 (file)
--- a/xmltooling/security/impl/PKIXPathValidator.cpp
+++ b/xmltooling/security/impl/PKIXPathValidator.cpp
@@ -113,8 +113,8 @@ namespace xmltooling {
     {
     public:
         PKIXPathValidator(const xercesc::DOMElement* e)
-            : m_log(Category::getInstance(XMLTOOLING_LOGCAT".PathValidator.PKIX")),
-              m_lock(XMLToolingConfig::getConfig().getNamedMutex(XMLTOOLING_LOGCAT".PathValidator.PKIX")),
+            : m_log(Category::getInstance(XMLTOOLING_LOGCAT ".PathValidator.PKIX")),
+              m_lock(XMLToolingConfig::getConfig().getNamedMutex(XMLTOOLING_LOGCAT ".PathValidator.PKIX")),
               m_minRefreshDelay(XMLHelper::getAttrInt(e, 60, minRefreshDelay)),
               m_minSecondsRemaining(XMLHelper::getAttrInt(e, 86400, minSecondsRemaining)),
               m_minPercentRemaining(XMLHelper::getAttrInt(e, 10, minPercentRemaining)) {

diff --git a/xmltooling/security/impl/SecurityHelper.cpp b/xmltooling/security/impl/SecurityHelper.cpp
index e85306f..0c15f05 100644 (file)
--- a/xmltooling/security/impl/SecurityHelper.cpp
+++ b/xmltooling/security/impl/SecurityHelper.cpp
@@ -125,7 +125,7 @@ XSECCryptoKey* SecurityHelper::loadKeyFromFile(const char* pathname, const char*
 #ifdef _DEBUG
     NDC ndc("loadKeyFromFile");
 #endif
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper");
     log.info("loading private key from file (%s)", pathname);
 
     // Native objects.
@@ -238,7 +238,7 @@ vector<XSECCryptoX509*>::size_type SecurityHelper::loadCertificatesFromFile(
 #ifdef _DEBUG
     NDC ndc("loadCertificatesFromFile");
 #endif
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper");
     log.info("loading certificate(s) from file (%s)", pathname);
 
     vector<XSECCryptoX509*>::size_type count = certs.size();
@@ -347,7 +347,7 @@ vector<XSECCryptoX509CRL*>::size_type SecurityHelper::loadCRLsFromFile(
 #ifdef _DEBUG
     NDC ndc("loadCRLsFromFile");
 #endif
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper");
     log.info("loading CRL(s) from file (%s)", pathname);
 
     vector<XSECCryptoX509CRL*>::size_type count = crls.size();
@@ -476,7 +476,7 @@ bool SecurityHelper::matches(const XSECCryptoKey& key1, const XSECCryptoKey& key
 {
     if (key1.getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL ||
         key2.getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("comparison of non-OpenSSL keys not supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("comparison of non-OpenSSL keys not supported");
         return false;
     }
 
@@ -540,7 +540,7 @@ bool SecurityHelper::matches(const XSECCryptoKey& key1, const XSECCryptoKey& key
     }
 #endif
 
-    Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("unsupported key type for comparison");
+    Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("unsupported key type for comparison");
     return false;
 }
 
@@ -551,7 +551,7 @@ string SecurityHelper::doHash(const char* hashAlg, const char* buf, unsigned lon
 
     const EVP_MD* md = EVP_get_digestbyname(hashAlg);
     if (!md) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("hash algorithm (%s) not available", hashAlg);
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("hash algorithm (%s) not available", hashAlg);
         return ret;
     }
 
@@ -566,7 +566,7 @@ string SecurityHelper::doHash(const char* hashAlg, const char* buf, unsigned lon
     int len = BIO_gets(chain, digest, EVP_MD_size(md));
     BIO_free_all(chain);
     if (len != EVP_MD_size(md)) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error(
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error(
             "hash result length (%d) did not match expected value (%d)", len, EVP_MD_size(md)
             );
         return ret;
@@ -590,7 +590,7 @@ string SecurityHelper::getDEREncoding(const XSECCryptoKey& key, const char* hash
     string ret;
 
     if (key.getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("encoding of non-OpenSSL keys not supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("encoding of non-OpenSSL keys not supported");
         return ret;
     }
 
@@ -603,14 +603,14 @@ string SecurityHelper::getDEREncoding(const XSECCryptoKey& key, const char* hash
     if (key.getKeyType() == XSECCryptoKey::KEY_RSA_PUBLIC || key.getKeyType() == XSECCryptoKey::KEY_RSA_PAIR) {
         rsa = static_cast<const OpenSSLCryptoKeyRSA&>(key).getOpenSSLRSA();
         if (!rsa) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("key was not populated");
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("key was not populated");
             return ret;
         }
     }
     else if (key.getKeyType() == XSECCryptoKey::KEY_DSA_PUBLIC || key.getKeyType() == XSECCryptoKey::KEY_DSA_PAIR) {
         dsa = static_cast<const OpenSSLCryptoKeyDSA&>(key).getOpenSSLDSA();
         if (!dsa) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("key was not populated");
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("key was not populated");
             return ret;
         }
     }
@@ -618,13 +618,13 @@ string SecurityHelper::getDEREncoding(const XSECCryptoKey& key, const char* hash
     else if (key.getKeyType() == XSECCryptoKey::KEY_EC_PUBLIC || key.getKeyType() == XSECCryptoKey::KEY_EC_PAIR) {
         ec = static_cast<const OpenSSLCryptoKeyEC&>(key).getOpenSSLEC();
         if (!ec) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("key was not populated");
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("key was not populated");
             return ret;
         }
     }
 #endif
     else {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("public key type not supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("public key type not supported");
         return ret;
     }
 
@@ -632,7 +632,7 @@ string SecurityHelper::getDEREncoding(const XSECCryptoKey& key, const char* hash
     if (hash) {
         md = EVP_get_digestbyname(hash);
         if (!md) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("hash algorithm (%s) not available", hash);
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("hash algorithm (%s) not available", hash);
             return ret;
         }
     }
@@ -686,7 +686,7 @@ string SecurityHelper::getDEREncoding(const XSECCryptoX509& cert, const char* ha
     string ret;
 
     if (cert.getProviderName()!=DSIGConstants::s_unicodeStrPROVOpenSSL) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").warn("encoding of non-OpenSSL keys not supported");
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").warn("encoding of non-OpenSSL keys not supported");
         return ret;
     }
 
@@ -694,7 +694,7 @@ string SecurityHelper::getDEREncoding(const XSECCryptoX509& cert, const char* ha
     if (hash) {
         md = EVP_get_digestbyname(hash);
         if (!md) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("hash algorithm (%s) not available", hash);
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("hash algorithm (%s) not available", hash);
             return ret;
         }
     }
@@ -769,7 +769,7 @@ XSECCryptoKey* SecurityHelper::fromDEREncoding(const char* buf, unsigned long bu
     if (base64) {
         decoded = xercesc::Base64::decode(reinterpret_cast<const XMLByte*>(buf), &x);
         if (!decoded) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("base64 decode failed");
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("base64 decode failed");
             return nullptr;
         }
     }
@@ -804,11 +804,11 @@ XSECCryptoKey* SecurityHelper::fromDEREncoding(const char* buf, unsigned long bu
                     break;
 #endif
                 default:
-                    Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("unsupported public key type");
+                    Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("unsupported public key type");
             }
         }
         catch (XSECCryptoException& ex) {
-            Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error(ex.getMsg());
+            Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error(ex.getMsg());
         }
         EVP_PKEY_free(pkey);
         return ret;
@@ -822,7 +822,7 @@ XSECCryptoKey* SecurityHelper::fromDEREncoding(const XMLCh* buf)
     xsecsize_t x;
     XMLByte* decoded = xercesc::Base64::decodeToXMLByte(buf, &x);
     if (!decoded) {
-        Category::getInstance(XMLTOOLING_LOGCAT".SecurityHelper").error("base64 decode failed");
+        Category::getInstance(XMLTOOLING_LOGCAT ".SecurityHelper").error("base64 decode failed");
         return nullptr;
     }
     XSECCryptoKey* ret = fromDEREncoding((const char*)decoded, x, false);

diff --git a/xmltooling/security/impl/StaticPKIXTrustEngine.cpp b/xmltooling/security/impl/StaticPKIXTrustEngine.cpp
index d64aaac..afa7575 100644 (file)
--- a/xmltooling/security/impl/StaticPKIXTrustEngine.cpp
+++ b/xmltooling/security/impl/StaticPKIXTrustEngine.cpp
@@ -93,7 +93,7 @@ namespace xmltooling {
                 }
             }
             catch (exception& ex) {
-                logging::Category::getInstance(XMLTOOLING_LOGCAT".TrustEngine.StaticPKIX").error(ex.what());
+                logging::Category::getInstance(XMLTOOLING_LOGCAT ".TrustEngine.StaticPKIX").error(ex.what());
             }
         }
 

diff --git a/xmltooling/signature/impl/XMLSecSignatureImpl.cpp b/xmltooling/signature/impl/XMLSecSignatureImpl.cpp
index 1d69463..1923e4e 100644 (file)
--- a/xmltooling/signature/impl/XMLSecSignatureImpl.cpp
+++ b/xmltooling/signature/impl/XMLSecSignatureImpl.cpp
@@ -212,7 +212,7 @@ Signature* XMLSecSignatureImpl::cloneSignature() const
 
 void XMLSecSignatureImpl::sign(const Credential* credential)
 {
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".Signature");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".Signature");
     log.debug("applying signature");
 
     if (!m_signature)
@@ -250,7 +250,7 @@ DOMElement* XMLSecSignatureImpl::marshall(DOMDocument* document, const vector<Si
     xmltooling::NDC ndc("marshall");
 #endif
     
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Signature");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject.Signature");
     log.debug("marshalling ds:Signature");
 
     DOMElement* cachedDOM=getDOM();
@@ -363,7 +363,7 @@ DOMElement* XMLSecSignatureImpl::marshall(DOMElement* parentElement, const vecto
     xmltooling::NDC ndc("marshall");
 #endif
     
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Signature");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject.Signature");
     log.debug("marshalling ds:Signature");
 
     DOMElement* cachedDOM=getDOM();
@@ -454,7 +454,7 @@ DOMElement* XMLSecSignatureImpl::marshall(DOMElement* parentElement, const vecto
 
 XMLObject* XMLSecSignatureImpl::unmarshall(DOMElement* element, bool bindDocument)
 {
-    Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Signature").debug("unmarshalling ds:Signature");
+    Category::getInstance(XMLTOOLING_LOGCAT ".XMLObject.Signature").debug("unmarshalling ds:Signature");
 
     try {
         m_signature=XMLToolingInternalConfig::getInternalConfig().m_xsecProvider->newSignatureFromDOM(

diff --git a/xmltooling/soap/impl/CURLSOAPTransport.cpp b/xmltooling/soap/impl/CURLSOAPTransport.cpp
index 26d3bc6..241755e 100644 (file)
--- a/xmltooling/soap/impl/CURLSOAPTransport.cpp
+++ b/xmltooling/soap/impl/CURLSOAPTransport.cpp
@@ -50,7 +50,7 @@ namespace xmltooling {
     {
     public:
         CURLPool() : m_size(0), m_lock(Mutex::create()),
-            m_log(Category::getInstance(XMLTOOLING_LOGCAT".SOAPTransport.CURL")) {}
+            m_log(Category::getInstance(XMLTOOLING_LOGCAT ".SOAPTransport.CURL")) {}
         ~CURLPool();
 
         CURL* get(const SOAPTransport::Address& addr);
@@ -481,8 +481,8 @@ void CURLSOAPTransport::send(istream* in)
 #ifdef _DEBUG
     xmltooling::NDC ndc("send");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".SOAPTransport.CURL");
-    Category& log_curl=Category::getInstance(XMLTOOLING_LOGCAT".libcurl");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".SOAPTransport.CURL");
+    Category& log_curl=Category::getInstance(XMLTOOLING_LOGCAT ".libcurl");
 
     // For this implementation, it's sufficient to check for https as a sign of transport security.
     if (m_mandatory && !isConfidential())
@@ -647,7 +647,7 @@ int xmltooling::curl_debug_hook(CURL* handle, curl_infotype type, char* data, si
 #ifndef XMLTOOLING_NO_XMLSEC
 int xmltooling::verify_callback(X509_STORE_CTX* x509_ctx, void* arg)
 {
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".SOAPTransport.CURL");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".SOAPTransport.CURL");
     log.debug("invoking custom X.509 verify callback");
 #if (OPENSSL_VERSION_NUMBER >= 0x00907000L)
     CURLSOAPTransport* ctx = reinterpret_cast<CURLSOAPTransport*>(arg);

diff --git a/xmltooling/soap/impl/SOAPClient.cpp b/xmltooling/soap/impl/SOAPClient.cpp
index e8c924d..ae85326 100644 (file)
--- a/xmltooling/soap/impl/SOAPClient.cpp
+++ b/xmltooling/soap/impl/SOAPClient.cpp
@@ -151,7 +151,7 @@ void SOAPClient::send(const Envelope& env, const SOAPTransport::Address& addr)
     m_transport = XMLToolingConfig::getConfig().SOAPTransportManager.newPlugin(scheme.c_str(), addr);
     prepareTransport(*m_transport);
     
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".SOAPClient");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".SOAPClient");
     if (log.isDebugEnabled())
         log.debugStream() << "marshalled envelope:\n" << env << logging::eol;
     
@@ -183,7 +183,7 @@ Envelope* SOAPClient::receive()
         : XMLToolingConfig::getConfig().getParser()).parse(out); 
     XercesJanitor<DOMDocument> janitor(doc);
 
-    Category& log = Category::getInstance(XMLTOOLING_LOGCAT".SOAPClient");
+    Category& log = Category::getInstance(XMLTOOLING_LOGCAT ".SOAPClient");
     if (log.isDebugEnabled()) {
         string buf;
         XMLHelper::serialize(doc->getDocumentElement(), buf);
@@ -219,7 +219,7 @@ bool SOAPClient::handleFault(const Fault& fault)
 {
     const xmltooling::QName* code = (fault.getFaultcode() ? fault.getFaultcode()->getCode() : nullptr);
     auto_ptr_char str((fault.getFaultstring() ? fault.getFaultstring()->getString() : nullptr));
-    Category::getInstance(XMLTOOLING_LOGCAT".SOAPClient").error(
+    Category::getInstance(XMLTOOLING_LOGCAT ".SOAPClient").error(
         "SOAP client detected a Fault: (%s) (%s)",
         (code ? code->toString().c_str() : "no code"),
         (str.get() ? str.get() : "no message")

diff --git a/xmltooling/util/CurlURLInputStream.cpp b/xmltooling/util/CurlURLInputStream.cpp
index e5036da..3ee0020 100644 (file)
--- a/xmltooling/util/CurlURLInputStream.cpp
+++ b/xmltooling/util/CurlURLInputStream.cpp
@@ -136,7 +136,7 @@ namespace {
 }
 
 CurlURLInputStream::CurlURLInputStream(const char* url, string* cacheTag)
-    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT".libcurl.InputStream"))
+    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT ".libcurl.InputStream"))
     , fCacheTag(cacheTag)
     , fURL(url ? url : "")
     , fOpenSSLOps(SSL_OP_ALL|SSL_OP_NO_SSLv2)
@@ -161,7 +161,7 @@ CurlURLInputStream::CurlURLInputStream(const char* url, string* cacheTag)
 }
 
 CurlURLInputStream::CurlURLInputStream(const XMLCh* url, string* cacheTag)
-    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT".libcurl.InputStream"))
+    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT ".libcurl.InputStream"))
     , fCacheTag(cacheTag)
     , fOpenSSLOps(SSL_OP_ALL|SSL_OP_NO_SSLv2)
     , fMulti(0)
@@ -189,7 +189,7 @@ CurlURLInputStream::CurlURLInputStream(const XMLCh* url, string* cacheTag)
 }
 
 CurlURLInputStream::CurlURLInputStream(const DOMElement* e, string* cacheTag)
-    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT".libcurl.InputStream"))
+    : fLog(logging::Category::getInstance(XMLTOOLING_LOGCAT ".libcurl.InputStream"))
     , fCacheTag(cacheTag)
     , fOpenSSLOps(SSL_OP_ALL|SSL_OP_NO_SSLv2)
     , fMulti(0)

diff --git a/xmltooling/util/ParserPool.cpp b/xmltooling/util/ParserPool.cpp
index 689815b..71a36f5 100644 (file)
--- a/xmltooling/util/ParserPool.cpp
+++ b/xmltooling/util/ParserPool.cpp
@@ -66,7 +66,7 @@ namespace {
 #ifdef _DEBUG
             xmltooling::NDC ndc("handleError");
 #endif
-            Category& log=Category::getInstance(XMLTOOLING_LOGCAT".ParserPool");
+            Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".ParserPool");
 
             DOMLocator* locator=e.getLocation();
             auto_ptr_char temp(e.getMessage());
@@ -233,7 +233,7 @@ bool ParserPool::loadSchema(const XMLCh* nsURI, const XMLCh* pathname)
 #if _DEBUG
         xmltooling::NDC ndc("loadSchema");
 #endif
-        Category& log=Category::getInstance(XMLTOOLING_LOGCAT".ParserPool");
+        Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".ParserPool");
         auto_ptr_char n(nsURI);
         log.error("failed to load schema for (%s), file not found (%s)",n.get(),p.get());
         return false;
@@ -276,7 +276,7 @@ bool ParserPool::loadCatalog(const XMLCh* pathname)
 #if _DEBUG
     xmltooling::NDC ndc("loadCatalog");
 #endif
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".ParserPool");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".ParserPool");
 
     // XML constants
     static const XMLCh catalog[] =  UNICODE_LITERAL_7(c,a,t,a,l,o,g);
@@ -363,7 +363,7 @@ DOMInputSource* ParserPool::resolveEntity(
         return nullptr;
     xstring sysId(systemId);
 
-    Category& log=Category::getInstance(XMLTOOLING_LOGCAT".ParserPool");
+    Category& log=Category::getInstance(XMLTOOLING_LOGCAT ".ParserPool");
     if (log.isDebugEnabled()) {
         auto_ptr_char sysId(systemId);
         auto_ptr_char base(baseURI);
@@ -534,7 +534,7 @@ xsecsize_t StreamInputSource::StreamBinInputStream::readBytes(XMLByte* const toF
             bytes_read+=m_is.gcount();
         }
         catch(ios_base::failure& e) {
-            Category::getInstance(XMLTOOLING_LOGCAT".StreamInputSource").critStream()
+            Category::getInstance(XMLTOOLING_LOGCAT ".StreamInputSource").critStream()
                 << "XML::StreamInputSource::StreamBinInputStream::readBytes caught an exception: " << e.what()
                 << logging::eol;
             *toFill=0;

diff --git a/xmltooling/util/ReplayCache.cpp b/xmltooling/util/ReplayCache.cpp
index a457cb4..4172cac 100644 (file)
--- a/xmltooling/util/ReplayCache.cpp
+++ b/xmltooling/util/ReplayCache.cpp
@@ -50,7 +50,7 @@ bool ReplayCache::check(const char* context, const char* s, time_t expires)
 {
     if (strlen(context) > m_storageCaps.getContextSize()) {
         // This is a design/coding failure.
-        Category::getInstance(XMLTOOLING_LOGCAT".ReplayCache").error(
+        Category::getInstance(XMLTOOLING_LOGCAT ".ReplayCache").error(
             "context (%s) too long for StorageService (limit %u)", context, m_storageCaps.getContextSize()
             );
         return false;
@@ -65,7 +65,7 @@ bool ReplayCache::check(const char* context, const char* s, time_t expires)
         m_storage->createString(context, h.c_str(), "x", expires);
         return true;
 #else
-        Category::getInstance(XMLTOOLING_LOGCAT".ReplayCache").error(
+        Category::getInstance(XMLTOOLING_LOGCAT ".ReplayCache").error(
             "key (%s) too long for StorageService (limit %u)", s, m_storageCaps.getKeySize()
             );
         return false;

diff --git a/xmltooling/util/Win32Threads.cpp b/xmltooling/util/Win32Threads.cpp
index 3f64975..237c496 100644 (file)
--- a/xmltooling/util/Win32Threads.cpp
+++ b/xmltooling/util/Win32Threads.cpp
@@ -47,7 +47,7 @@ using namespace std;
 static int XMLTOOL_DLLLOCAL map_windows_error_status_to_pthreads(int rc=0) {
     if(rc!=0)  // success?
         return 0;
-    Category::getInstance(XMLTOOLING_LOGCAT".Threads").error("error from thread operation (%d)", GetLastError());
+    Category::getInstance(XMLTOOLING_LOGCAT ".Threads").error("error from thread operation (%d)", GetLastError());
     return THREAD_ERROR;
 }