CheckVersion::CheckStatus CAboutDlg::CheckLatestVersion(std::wstring &latest)
{
CInternetSession session(L"PasswordSafe Version Check");
CStdioFile *fh;
// Put up hourglass...this might take a while
CWaitCursor waitCursor;
try {
// Loading the file as binary since we're treating it as UTF-8
fh = session.OpenURL(L"https://pwsafe.org/latest.xml",
1, (INTERNET_FLAG_TRANSFER_BINARY | INTERNET_FLAG_RELOAD));
} catch (CInternetException *) {
// throw;
return CheckVersion::CANT_CONNECT;
}
ASSERT(fh != NULL);
CString latest_xml;
unsigned char buff[BUFSIZ + 1];
StringX chunk;
UINT nRead;
CUTF8Conv conv;
while ((nRead = fh->Read(buff, BUFSIZ)) != 0) {
buff[nRead] = '\0';
// change to widechar representation
if (!conv.FromUTF8(buff, nRead, chunk)) {
fh->Close();
delete fh;
session.Close();
return CheckVersion::CANT_READ;
} else
latest_xml += chunk.c_str();
}
fh->Close();
delete fh;
session.Close();
waitCursor.Restore(); // restore normal cursor
CheckVersion vh(m_nMajor, m_nMinor, m_nBuild);
return vh.CheckLatestVersion(LPCWSTR(latest_xml), latest);
}
bool parseArgs(int argc, char *argv[], UserArgs &ua)
{
if (argc != 4 && argc != 5)
return false;
CUTF8Conv conv;
if (!conv.FromUTF8((const unsigned char *)argv[1], strlen(argv[1]),
ua.safe)) {
cerr << "Could not convert filename " << argv[1] << " to StringX" << endl;
exit(2);
}
while (1) {
int option_index = 0;
static struct option long_options[] = {
// name, has_arg, flag, val
{"import", optional_argument, 0, 'i'},
{"export", optional_argument, 0, 'e'},
{"text", no_argument, 0, 't'},
{"xml", no_argument, 0, 'x'},
{0, 0, 0, 0}
};
int c = getopt_long(argc-1, argv+1, "i::e::tx",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'i':
if (ua.ImpExp == UserArgs::Unset)
ua.ImpExp = UserArgs::Import;
else
return false;
if (optarg) {
if (!conv.FromUTF8((const unsigned char *)optarg, strlen(optarg),
ua.fname)) {
cerr << "Could not convert filename "
<< optarg << " to StringX" << endl;
exit(2);
}
}
break;
case 'e':
if (ua.ImpExp == UserArgs::Unset)
ua.ImpExp = UserArgs::Export;
else
return false;
if (optarg) {
if (!conv.FromUTF8((const unsigned char *)optarg, strlen(optarg),
ua.fname)) {
cerr << "Could not convert filename "
<< optarg << " to StringX" << endl;
exit(2);
}
}
break;
case 'x':
if (ua.Format == UserArgs::Unknown)
ua.Format = UserArgs::XML;
else
return false;
break;
case 't':
if (ua.Format == UserArgs::Unknown)
ua.Format = UserArgs::Text;
else
return false;
break;
default:
cerr << "Unknown option: " << char(c) << endl;
return false;
}
if (ua.fname.empty())
ua.fname = (ua.Format == UserArgs::XML) ? L"file.xml" : L"file.txt";
}
return true;
}
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;
}
int main(int argc, char *argv[])
{
UserArgs ua;
if (!parseArgs(argc, argv, ua)) {
usage(argv[0]);
return 1;
}
PWScore core;
if (!pws_os::FileExists(ua.safe.c_str())) {
cerr << argv[1] << " - file not found" << endl;
return 2;
}
wstring wpk;
cout << "Enter Password: "******"CheckPasskey returned: " << status_text(status) << endl;
goto done;
}
{
CUTF8Conv conv;
const char *user = getlogin() != NULL ? getlogin() : "unknown";
StringX locker;
if (!conv.FromUTF8((const unsigned char *)user, strlen(user), locker)) {
cerr << "Could not convert user " << user << " to StringX" << endl;
return 2;
}
stringT lk(locker.c_str());
if (!core.LockFile(ua.safe.c_str(), lk)) {
wcout << L"Couldn't lock file " << ua.safe
<< L": locked by " << locker << endl;
status = -1;
goto done;
}
}
// Since we may be writing the same file we're reading,
// it behooves us to set the Current File and use its' related
// functions
core.SetCurFile(ua.safe);
status = core.ReadCurFile(pk);
if (status != PWScore::SUCCESS) {
cout << "ReadFile returned: " << status_text(status) << endl;
goto done;
}
if (ua.ImpExp == UserArgs::Export) {
CItemData::FieldBits all(~0L);
int N;
if (ua.Format == UserArgs::XML) {
status = core.WriteXMLFile(ua.fname, all, L"", 0, 0, L' ', N);
} else { // export text
status = core.WritePlaintextFile(ua.fname, all, L"", 0, 0, L' ', N);
}
} else { // Import
if (ua.Format == UserArgs::XML) {
status = ImportXML(core, ua.fname);
} else { // import text
status = ImportText(core, ua.fname);
}
if (status == PWScore::SUCCESS)
status = core.WriteCurFile();
}
if (status != PWScore::SUCCESS) {
cout << "Operation returned status: " << status_text(status) << endl;
goto done;
}
done:
core.UnlockFile(ua.safe.c_str());
return status;
}
