BOOL CompareVariantPath(
__in VARIANT* pVariant1,
__in VARIANT* pVariant2
)
{
HRESULT hr = S_OK;
BOOL fEqual = FALSE;
LPWSTR wzValue1 = NULL;
LPWSTR wzValue2 = NULL;
if (ISSTRINGVARIANT(pVariant1->vt))
{
hr = PathExpand(&wzValue1, pVariant1->bstrVal, PATH_EXPAND_ENVIRONMENT | PATH_EXPAND_FULLPATH);
ExitOnFailure1(hr, "Failed to expand path %ls", pVariant1->bstrVal);
}
if (ISSTRINGVARIANT(pVariant2->vt))
{
hr = PathExpand(&wzValue2, pVariant2->bstrVal, PATH_EXPAND_ENVIRONMENT | PATH_EXPAND_FULLPATH);
ExitOnFailure1(hr, "Failed to expand path %ls", pVariant2->bstrVal);
}
fEqual = CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, wzValue1, -1, wzValue2, -1);
LExit:
ReleaseNullStr(wzValue1);
ReleaseNullStr(wzValue2);
return fEqual;
}
void ImagesVideo::PopulateFilenames(const std::string& wildcard_path)
{
const std::vector<std::string> wildcards = Expand(wildcard_path, '[', ']', ',');
num_channels = wildcards.size();
filenames.resize(num_channels);
for(size_t i = 0; i < wildcards.size(); ++i) {
const std::string channel_wildcard = PathExpand(wildcards[i]);
FilesMatchingWildcard(channel_wildcard, filenames[i]);
if(num_files < 0) {
num_files = (int)filenames[i].size();
}else{
if( num_files != (int)filenames[i].size() ) {
std::cerr << "Warning: Video Channels have unequal number of files" << std::endl;
}
num_files = std::min(num_files, (int)filenames[i].size());
}
if(num_files == 0) {
throw VideoException("No files found for wildcard '" + channel_wildcard + "'");
}
}
// Resize empty frames vector to hold future images.
loaded.resize(num_files);
}
ImagesVideoOutput::ImagesVideoOutput(const std::string& image_folder, const std::string& json_file_out)
: json_frames(picojson::array_type,true),
image_index(0), image_folder( PathExpand(image_folder) )
{
if(!json_file_out.empty()) {
file.open(json_file_out);
if(!file.is_open()) {
throw std::runtime_error("Unable to open json file for writing, " + json_file_out);
}
}
}
void CfgTest::RedirectDatabases()
{
HRESULT hr = S_OK;
LPWSTR sczPathUser = NULL;
LPWSTR sczPathLegacy = NULL;
LPWSTR sczPathAdmin = NULL;
// Override user DB directory
hr = PathExpand(&sczPathUser, L"%TEMP%\\TestUserDb\\", PATH_EXPAND_ENVIRONMENT);
ExitOnFailure(hr, "Failed to expand path");
hr = DirEnsureDelete(sczPathUser, TRUE, TRUE);
if (E_PATHNOTFOUND == hr)
{
hr = S_OK;
}
ExitOnFailure1(hr, "Failed to ensure directory %ls is deleted", sczPathUser);
TestHookOverrideUserDatabasePath(L"%TEMP%\\TestUserDb\\");
// Override legacy DB directory
hr = PathExpand(&sczPathAdmin, L"%TEMP%\\TestAdminDb\\", PATH_EXPAND_ENVIRONMENT);
ExitOnFailure(hr, "Failed to expand path");
hr = DirEnsureDelete(sczPathAdmin, TRUE, TRUE);
if (E_PATHNOTFOUND == hr)
{
hr = S_OK;
}
ExitOnFailure1(hr, "Failed to ensure directory %ls is deleted", sczPathAdmin);
TestHookOverrideAdminDatabasePath(L"%TEMP%\\TestAdminDb\\");
LExit:
ReleaseStr(sczPathUser);
ReleaseStr(sczPathLegacy);
ReleaseStr(sczPathAdmin);
}
wxString GetSystemOpenCommand(wxString file, bool &program_exists)
{
wxFileName fn(file);
const wxString& ext = fn.GetExt();
if (ext == _T(""))
return _T("");
for (;;)
{
wxFileType* pType = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
if (!pType)
return _T("");
wxString cmd;
if (!pType->GetOpenCommand(&cmd, wxFileType::MessageParameters(file)))
{
delete pType;
return _T("");
}
delete pType;
if (cmd.empty())
return wxEmptyString;
program_exists = false;
wxString editor;
bool is_dde = false;
#ifdef __WXMSW__
if (cmd.Left(7) == _T("WX_DDE#"))
{
// See wxWidget's wxExecute in src/msw/utilsexc.cpp
// WX_DDE#<command>#DDE_SERVER#DDE_TOPIC#DDE_COMMAND
editor = cmd.Mid(7);
int pos = editor.Find('#');
if (pos < 1)
return cmd;
editor = editor.Left(pos);
is_dde = true;
}
else
#endif
{
editor = cmd;
}
wxString args;
if (!UnquoteCommand(editor, args, is_dde) || editor.empty())
return cmd;
if (!PathExpand(editor))
return cmd;
if (ProgramExists(editor))
program_exists = true;
#ifdef __WXGTK__
int pos = args.Find(file);
if (pos != -1 && file.Find(' ') != -1 && file[0] != '\'' && file[0] != '"')
{
// Might need to quote filename, wxWidgets doesn't do it
if ((!pos || (args[pos - 1] != '\'' && args[pos - 1] != '"')) &&
args[pos + file.Length()] != '\'' && args[pos + file.Length()] != '"')
{
// Filename in command arguments isn't quoted. Repeat with quoted filename
file = _T("\"") + file + _T("\"");
continue;
}
}
#endif
return cmd;
}
return wxEmptyString;
}
extern "C" UINT WINAPI WixRemoveFoldersEx(
__in MSIHANDLE hInstall
)
{
//AssertSz(FALSE, "debug WixRemoveFoldersEx");
HRESULT hr = S_OK;
PMSIHANDLE hView;
PMSIHANDLE hRec;
LPWSTR sczId = NULL;
LPWSTR sczComponent = NULL;
LPWSTR sczProperty = NULL;
LPWSTR sczPath = NULL;
LPWSTR sczExpandedPath = NULL;
int iMode = 0;
DWORD dwCounter = 0;
DWORD_PTR cchLen = 0;
MSIHANDLE hTable = NULL;
MSIHANDLE hColumns = NULL;
hr = WcaInitialize(hInstall, "WixRemoveFoldersEx");
ExitOnFailure(hr, "Failed to initialize WixRemoveFoldersEx.");
// anything to do?
if (S_OK != WcaTableExists(L"WixRemoveFolderEx"))
{
WcaLog(LOGMSG_STANDARD, "WixRemoveFolderEx table doesn't exist, so there are no folders to remove.");
ExitFunction();
}
// query and loop through all the remove folders exceptions
hr = WcaOpenExecuteView(vcsRemoveFolderExQuery, &hView);
ExitOnFailure(hr, "Failed to open view on WixRemoveFolderEx table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
hr = WcaGetRecordString(hRec, rfqId, &sczId);
ExitOnFailure(hr, "Failed to get remove folder identity.");
hr = WcaGetRecordString(hRec, rfqComponent, &sczComponent);
ExitOnFailure(hr, "Failed to get remove folder component.");
hr = WcaGetRecordString(hRec, rfqProperty, &sczProperty);
ExitOnFailure(hr, "Failed to get remove folder property.");
hr = WcaGetRecordInteger(hRec, feqMode, &iMode);
ExitOnFailure(hr, "Failed to get remove folder mode");
hr = WcaGetProperty(sczProperty, &sczPath);
ExitOnFailure2(hr, "Failed to resolve remove folder property: %S for row: %S", sczProperty, sczId);
// fail early if the property isn't set as you probably don't want your installers trying to delete SystemFolder
// StringCchLengthW succeeds only if the string is zero characters plus 1 for the terminating null
hr = ::StringCchLengthW(sczPath, 1, reinterpret_cast<UINT_PTR*>(&cchLen));
if (SUCCEEDED(hr))
{
ExitOnFailure2(hr = E_INVALIDARG, "Missing folder property: %S for row: %S", sczProperty, sczId);
}
hr = PathExpand(&sczExpandedPath, sczPath, PATH_EXPAND_ENVIRONMENT);
ExitOnFailure2(hr, "Failed to expand path: %S for row: %S", sczPath, sczId);
hr = PathBackslashTerminate(&sczExpandedPath);
ExitOnFailure1(hr, "Failed to backslash-terminate path: %S", sczExpandedPath);
WcaLog(LOGMSG_STANDARD, "Recursing path: %S for row: %S.", sczExpandedPath, sczId);
hr = RecursePath(sczExpandedPath, sczId, sczComponent, sczProperty, iMode, &dwCounter, &hTable, &hColumns);
ExitOnFailure2(hr, "Failed while navigating path: %S for row: %S", sczPath, sczId);
}
// reaching the end of the list is actually a good thing, not an error
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "Failure occured while processing WixRemoveFolderEx table");
LExit:
if (hColumns)
{
::MsiCloseHandle(hColumns);
}
if (hTable)
{
::MsiCloseHandle(hTable);
}
ReleaseStr(sczExpandedPath);
ReleaseStr(sczPath);
ReleaseStr(sczProperty);
ReleaseStr(sczComponent);
ReleaseStr(sczId);
DWORD er = SUCCEEDED(hr) ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;
return WcaFinalize(er);
}
int __cdecl wmain(
__in int argc,
__in WCHAR * argv[]
)
{
HRESULT hr = S_OK;
LPWSTR pwzCommandLine = NULL;
LPWSTR wzAppId = NULL;
GUID guidApp;
DWORD64 dw64Version;
LPWSTR pwzFeedUri = NULL;
LPWSTR pwzApplicationPath = NULL;
LPWSTR pwzApplicationDirectory = NULL;
DWORD64 dw64NextUpdateTime = 0;
BOOL fUpdateReady = FALSE;
DWORD64 dw64UpdateVersion = 0;
LPWSTR pwzFeedPath = NULL;
LPWSTR pwzSetupPath = NULL;
DWORD dwTimeToLive = 0;
LPWSTR pwzApplicationId = NULL;
LPWSTR pwzApplicationSource = NULL;
BOOL bDeleteUpdateInfoPath = FALSE;
BOOL bDeleteUpdateBinaryPath = FALSE;
HANDLE hProcess = INVALID_HANDLE_VALUE;
HANDLE hUpdateMutex = INVALID_HANDLE_VALUE;
//
// Process command-line arguments.
//
for (int i=1; i<argc; i++)
{
if (argv[i][0] == L'-' || argv[i][0] == L'/')
{
if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, &argv[i][1], -1, L"ac", -1))
{
if (wzAppId)
{
ExitOnFailure(hr = E_INVALIDARG, "May only specify one -ac switch.");
}
wzAppId = argv[++i];
hr = ::CLSIDFromString(wzAppId, &guidApp);
ExitOnFailure(hr, "Failed to parse the -ac argument.");
}
}
else
{
ExitOnFailure1(hr = E_INVALIDARG, "Bad commandline argument: %S", argv[i]);
}
}
ExitOnNull(wzAppId, hr, E_INVALIDARG, "Must specify a -ac switch.");
hr = GetUpdateMutex(&guidApp, &hUpdateMutex);
if (FAILED(hr))
{
TraceError(hr, "Failed to query the update mutex. Proceeding as if this process didn't acquire the mutex.");
}
hr = RssUpdateGetAppInfo(wzAppId, &dw64Version, &pwzFeedUri, &pwzApplicationPath);
ExitOnFailure(hr, "Failed to get app info.");
// If we acquired the update lock and there is already an update downloaded, install that now.
if (INVALID_HANDLE_VALUE != hUpdateMutex)
{
Trace(REPORT_DEBUG, "Got the update mutex. Will check for updates on local machine before launching app.");
// If an update is available and higher version that the application currently on the local
// machine, launch the install and bail.
hr = RssUpdateTryLaunchUpdate(wzAppId, dw64Version, &hProcess, &dw64NextUpdateTime);
if (SUCCEEDED(hr))
{
if (hProcess)
{
::CloseHandle(hProcess);
ExitFunction(); // bail since we're doing an update
}
}
}
else
{
Trace(REPORT_DEBUG, "Didn't get the update mutex. Won't check for updates.");
}
hr = PathExpand(&pwzCommandLine, pwzApplicationPath, PATH_EXPAND_FULLPATH);
ExitOnFailure(hr, "Failed to expand application path.");
if (pwzCommandLine && L'\"' != pwzCommandLine[0])
{
// Get the working directory.
hr = PathGetDirectory(pwzCommandLine, &pwzApplicationDirectory);
ExitOnFailure(hr, "Failed to get application directory from command-line.");
// Put quotes around the command line.
hr = StrAllocPrefix(&pwzCommandLine, L"\"", 0);
ExitOnFailure(hr, "Failed to prefix command-line with quote.");
hr = StrAllocConcat(&pwzCommandLine, L"\"", 0);
ExitOnFailure(hr, "Failed to concat command-line with quote.");
}
Trace1(REPORT_DEBUG, "Launching the target app with commandline: %ls.", pwzCommandLine);
hr = LaunchTarget(pwzCommandLine, pwzApplicationDirectory, &hProcess);
ExitOnFailure1(hr, "Failed to launch %ls", pwzCommandLine);
// If we acquired the update lock then check to see if enough time has passed such that we look for more updates.
if (INVALID_HANDLE_VALUE != hUpdateMutex)
{
hr = RssUpdateCheckFeed(wzAppId, dw64Version, pwzFeedUri, dw64NextUpdateTime);
hr = S_OK;
}
LExit:
if (INVALID_HANDLE_VALUE != hUpdateMutex)
{
::CloseHandle(hUpdateMutex);
}
if (INVALID_HANDLE_VALUE != hProcess)
{
::CloseHandle(hProcess);
}
if (bDeleteUpdateInfoPath)
{
::DeleteFileW(pwzFeedPath);
}
if (bDeleteUpdateBinaryPath)
{
::DeleteFileW(pwzSetupPath);
}
ReleaseStr(pwzApplicationSource);
ReleaseStr(pwzApplicationId);
ReleaseStr(pwzSetupPath);
ReleaseStr(pwzFeedPath);
ReleaseStr(pwzApplicationPath);
ReleaseStr(pwzFeedUri);
ReleaseStr(pwzCommandLine);
ReleaseStr(pwzApplicationDirectory);
return SCODE_CODE(hr);
}
