bool XFilterXMLProcessor::Process(const bool &bvalidation,
const StringX &strXMLData,
const stringT &strXMLFileName,
const stringT &strXSDFileName)
{
USES_XMLCH_STR
bool bErrorOccurred = false;
stringT cs_validation;
LoadAString(cs_validation, IDSC_XMLVALIDATION);
stringT cs_import;
LoadAString(cs_import, IDSC_XMLIMPORT);
stringT strResultText(_T(""));
m_bValidation = bvalidation; // Validate or Import
XSecMemMgr sec_mm;
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, &sec_mm);
}
catch (const XMLException& toCatch)
{
#ifdef UNICODE
m_strXMLErrors = stringT(_X2ST(toCatch.getMessage()));
#else
char *szData = XMLString::transcode(toCatch.getMessage());
strResultText = stringT(szData);
XMLString::release(&szData);
#endif
return false;
}
// Create a SAX2 parser object.
SAX2XMLReader* pSAX2Parser = XMLReaderFactory::createXMLReader(&sec_mm);
// Set non-default features
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, true);
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
pSAX2Parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
pSAX2Parser->setFeature(XMLUni::fgXercesLoadExternalDTD, false);
pSAX2Parser->setFeature(XMLUni::fgXercesSkipDTDValidation, true);
// Set properties
pSAX2Parser->setProperty(XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation,
(void *)strXSDFileName.c_str());
pSAX2Parser->setProperty(XMLUni::fgXercesScannerName,
(void *)XMLUni::fgSGXMLScanner);
pSAX2Parser->setInputBufferSize(4096);
// Create SAX handler object and install it on the pSAX2Parser, as the
// document and error pSAX2Handler.
XFilterSAX2Handlers * pSAX2Handler = new XFilterSAX2Handlers;
pSAX2Parser->setContentHandler(pSAX2Handler);
pSAX2Parser->setErrorHandler(pSAX2Handler);
// Workaround/bypass until Xerces supports retrieving version from the
// <xs:schema ...> statement!
// Set 'dummy' schema version to arbitrary value > 1
pSAX2Handler->SetSchemaVersion(99);
pSAX2Handler->SetVariables(m_pAsker, &m_MapFilters, m_FPool, m_bValidation);
try
{
// Let's begin the parsing now
if (!strXMLFileName.empty()) {
pSAX2Parser->parse(_W2X(strXMLFileName.c_str()));
} else {
const char *szID = "database_filters";
#ifdef UNICODE
const char *buffer = XMLString::transcode(_W2X(strXMLData.c_str()));
#else
const char *buffer = strXMLData.c_str();
#endif
MemBufInputSource* memBufIS = new MemBufInputSource(
(const XMLByte*)buffer,
strXMLData.length(),
szID, false);
pSAX2Parser->parse(*memBufIS);
delete memBufIS;
#ifdef UNICODE
XMLString::release((char **)&buffer);
#endif
}
}
catch (const OutOfMemoryException&)
{
LoadAString(strResultText, IDCS_XERCESOUTOFMEMORY);
bErrorOccurred = true;
}
catch (const XMLException& e)
{
#ifdef UNICODE
strResultText = stringT(_X2ST(e.getMessage()));
#else
char *szData = XMLString::transcode(e.getMessage());
strResultText = stringT(szData);
XMLString::release(&szData);
#endif
bErrorOccurred = true;
}
catch (...)
{
LoadAString(strResultText, IDCS_XERCESEXCEPTION);
bErrorOccurred = true;
}
if (pSAX2Handler->getIfErrors() || bErrorOccurred) {
bErrorOccurred = true;
strResultText = pSAX2Handler->getValidationResult();
Format(m_strXMLErrors, IDSC_XERCESPARSEERROR,
m_bValidation ? cs_validation.c_str() : cs_import.c_str(),
strResultText.c_str());
} else {
m_strXMLErrors = strResultText;
}
// Delete the pSAX2Parser itself. Must be done prior to calling Terminate, below.
delete pSAX2Parser;
delete pSAX2Handler;
USES_XMLCH_STR_END
// And call the termination method
XMLPlatformUtils::Terminate();
return !bErrorOccurred;
}
bool XFilterXMLProcessor::Process(const bool &bvalidation,
const StringX &strXMLData,
const stringT &strXMLFileName,
const stringT &strXSDFileName)
{
USES_XMLCH_STR
bool bErrorOccurred = false;
stringT cs_validation;
LoadAString(cs_validation, IDSC_XMLVALIDATION);
stringT cs_import;
LoadAString(cs_import, IDSC_XMLIMPORT);
stringT strResultText(_T(""));
m_bValidation = bvalidation; // Validate or Import
XSecMemMgr sec_mm;
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, &sec_mm);
}
catch (const XMLException& toCatch)
{
m_strXMLErrors = stringT(_X2ST(toCatch.getMessage()));
return false;
}
// Create a SAX2 parser object.
SAX2XMLReader* pSAX2Parser = XMLReaderFactory::createXMLReader(&sec_mm);
// Set non-default features
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, true);
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
pSAX2Parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
pSAX2Parser->setFeature(XMLUni::fgXercesLoadExternalDTD, false);
pSAX2Parser->setFeature(XMLUni::fgXercesSkipDTDValidation, true);
// Set properties
// we need const_cast here, because _W2X return const wchar_t* when
// WCHAR_INCOMPATIBLE_XMLCH isn't set
pSAX2Parser->setProperty(XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation,
const_cast<XMLCh*>(_W2X(strXSDFileName.c_str())));
pSAX2Parser->setProperty(XMLUni::fgXercesScannerName,
const_cast<XMLCh*>(XMLUni::fgSGXMLScanner));
pSAX2Parser->setInputBufferSize(4096);
// Create SAX handler object and install it on the pSAX2Parser, as the
// document and error pSAX2Handler.
XFilterSAX2Handlers * pSAX2Handler = new XFilterSAX2Handlers;
pSAX2Parser->setContentHandler(pSAX2Handler);
pSAX2Parser->setErrorHandler(pSAX2Handler);
// Workaround/bypass until Xerces supports retrieving version from the
// <xs:schema ...> statement!
// Set 'dummy' schema version to arbitrary value > 1
pSAX2Handler->SetSchemaVersion(99);
pSAX2Handler->SetVariables(m_pAsker, &m_MapFilters, m_FPool, m_bValidation);
// instantiate converter out of if/else to be sure that string will be valid
// till the end of pSAX2Parser, that may capture pointer to string from MemBufInputSource
CUTF8Conv conv;
try
{
// Let's begin the parsing now
if (!strXMLFileName.empty()) {
pSAX2Parser->parse(_W2X(strXMLFileName.c_str()));
} else {
const char *szID = "database_filters";
// Xerces use encoding from XML (we have set it to utf-8), but transcode() on Windows convert to one-byte cpXXXX,
// so we need to manually convert from wchar to UTF-8
const unsigned char* buffer=nullptr;
size_t len;
if (!conv.ToUTF8(strXMLData, buffer, len)) {
throw std::runtime_error("Can't convert data to UTF-8");
}
//2nd parameter must be number of bytes, so we use a length for char* representation
MemBufInputSource* memBufIS = new MemBufInputSource(
reinterpret_cast<const XMLByte *>(buffer),
strlen(reinterpret_cast<const char*>(buffer)),
szID, false);
pSAX2Parser->parse(*memBufIS);
delete memBufIS;
}
}
catch (const OutOfMemoryException&)
{
LoadAString(strResultText, IDCS_XERCESOUTOFMEMORY);
bErrorOccurred = true;
}
catch (const XMLException& e)
{
strResultText = stringT(_X2ST(e.getMessage()));
bErrorOccurred = true;
}
catch (...)
{
LoadAString(strResultText, IDCS_XERCESEXCEPTION);
bErrorOccurred = true;
}
if (pSAX2Handler->getIfErrors() || bErrorOccurred) {
bErrorOccurred = true;
if (pSAX2Handler->getIfErrors())
strResultText = pSAX2Handler->getValidationResult();
Format(m_strXMLErrors, IDSC_XERCESPARSEERROR,
m_bValidation ? cs_validation.c_str() : cs_import.c_str(),
strResultText.c_str());
} else {
m_strXMLErrors = strResultText;
}
// Delete the pSAX2Parser itself. Must be done prior to calling Terminate, below.
delete pSAX2Parser;
delete pSAX2Handler;
USES_XMLCH_STR_END
// And call the termination method
XMLPlatformUtils::Terminate();
return !bErrorOccurred;
}
// ---------------------------------------------------------------------------
bool XFileXMLProcessor::Process(const bool &bvalidation, const stringT &ImportedPrefix,
const stringT &strXMLFileName, const stringT &strXSDFileName,
const bool &bImportPSWDsOnly)
{
USES_XMLCH_STR
bool bErrorOccurred = false;
bool b_into_empty = false;
stringT cs_validation;
LoadAString(cs_validation, IDSC_XMLVALIDATION);
stringT cs_import;
LoadAString(cs_import, IDSC_XMLIMPORT);
stringT strResultText(_T(""));
m_bValidation = bvalidation; // Validate or Import
XSecMemMgr sec_mm;
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, &sec_mm);
}
catch (const XMLException& toCatch)
{
strResultText = stringT(_X2ST(toCatch.getMessage()));
return false;
}
const XMLCh* xmlfilename = _W2X(strXMLFileName.c_str());
const XMLCh* schemafilename = _W2X(strXSDFileName.c_str());
// Create a SAX2 parser object.
SAX2XMLReader* pSAX2Parser = XMLReaderFactory::createXMLReader(&sec_mm);
// Set non-default features
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, true);
pSAX2Parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
pSAX2Parser->setFeature(XMLUni::fgXercesDynamic, false);
pSAX2Parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
pSAX2Parser->setFeature(XMLUni::fgXercesLoadExternalDTD, false);
pSAX2Parser->setFeature(XMLUni::fgXercesSkipDTDValidation, true);
// Set properties
pSAX2Parser->setProperty(XMLUni::fgXercesScannerName,
const_cast<void*>(reinterpret_cast<const void*>(XMLUni::fgSGXMLScanner)));
pSAX2Parser->setInputBufferSize(4096);
// Set schema file name (also via property)
pSAX2Parser->setProperty(XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation,
const_cast<void*>(reinterpret_cast<const void*>(schemafilename)));
// Create SAX handler object and install it on the pSAX2Parser, as the
// document and error pSAX2Handler.
XFileSAX2Handlers * pSAX2Handler = new XFileSAX2Handlers;
pSAX2Parser->setContentHandler(pSAX2Handler);
pSAX2Parser->setErrorHandler(pSAX2Handler);
pSAX2Handler->SetVariables(m_bValidation ? NULL : m_pXMLcore, m_bValidation,
ImportedPrefix, m_delimiter, bImportPSWDsOnly,
m_bValidation ? NULL : m_pPossible_Aliases,
m_bValidation ? NULL : m_pPossible_Shortcuts,
m_pmulticmds, m_prpt);
if (!m_bValidation) {
b_into_empty = m_pXMLcore->GetNumEntries() == 0;
}
try {
// Let's begin the parsing now
pSAX2Parser->parse(xmlfilename);
}
catch (const OutOfMemoryException&) {
LoadAString(strResultText, IDCS_XERCESOUTOFMEMORY);
bErrorOccurred = true;
}
catch (const XMLException& e) {
strResultText = stringT(_X2ST(e.getMessage()));
bErrorOccurred = true;
}
catch (...) {
LoadAString(strResultText, IDCS_XERCESEXCEPTION);
bErrorOccurred = true;
}
if (pSAX2Handler->getIfErrors() || bErrorOccurred) {
bErrorOccurred = true;
strResultText = pSAX2Handler->getValidationResult();
Format(m_strXMLErrors, IDSC_XERCESPARSEERROR,
m_bValidation ? cs_validation.c_str() : cs_import.c_str(),
strResultText.c_str());
} else {
if (m_bValidation) {
m_strXMLErrors = pSAX2Handler->getValidationResult();
m_numEntriesValidated = pSAX2Handler->getNumEntries();
m_delimiter = pSAX2Handler->getDelimiter();
} else {
pSAX2Handler->AddXMLEntries();
// Get numbers (may have been modified by AddXMLEntries
m_numEntriesImported = pSAX2Handler->getNumEntries();
m_numEntriesSkipped = pSAX2Handler->getNumSkipped();
m_numEntriesRenamed = pSAX2Handler->getNumRenamed();
m_numEntriesPWHErrors = pSAX2Handler->getNumPWHErrors();
m_numNoPolicies = pSAX2Handler->getNumNoPolicies();
m_numRenamedPolicies = pSAX2Handler->getNumRenamedPolicies();
m_numShortcutsRemoved = pSAX2Handler->getNumShortcutsRemoved();
// Get lists
m_strXMLErrors = pSAX2Handler->getXMLErrors();
m_strSkippedList = pSAX2Handler->getSkippedList();
m_strPWHErrorList = pSAX2Handler->getPWHErrorList();
m_strRenameList = pSAX2Handler->getRenameList();
if (b_into_empty) {
pSAX2Handler->AddDBPreferences();
}
}
}
// Delete the pSAX2Parser itself. Must be done prior to calling Terminate, below.
delete pSAX2Parser;
delete pSAX2Handler;
USES_XMLCH_STR_END
// And call the termination method
XMLPlatformUtils::Terminate();
return !bErrorOccurred;
}
