/*************************************************************************
* PathUnquoteSpaces [SHELL32.56]
*/
VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
{
if(SHELL_OsIsUnicode())
PathUnquoteSpacesW(str);
else
PathUnquoteSpacesA(str);
}
/**
* Determines if the MozillaMaintenance service path needs to be updated
* and fixes it if it is wrong.
*
* @param service A handle to the service to fix.
* @param currentServicePath The current (possibly wrong) path that is used.
* @param servicePathWasWrong Out parameter set to TRUE if a fix was needed.
* @return TRUE if the service path is now correct.
*/
BOOL
FixServicePath(SC_HANDLE service,
LPCWSTR currentServicePath,
BOOL &servicePathWasWrong)
{
// When we originally upgraded the MozillaMaintenance service we
// would uninstall the service on each upgrade. This had an
// intermittent error which could cause the service to use the file
// maintenanceservice_tmp.exe as the install path. Only a small number
// of Nightly users would be affected by this, but we check for this
// state here and fix the user if they are affected.
//
// We also fix the path in the case of the path not being quoted.
size_t currentServicePathLen = wcslen(currentServicePath);
bool doesServiceHaveCorrectPath =
currentServicePathLen > 2 &&
!wcsstr(currentServicePath, L"maintenanceservice_tmp.exe") &&
currentServicePath[0] == L'\"' &&
currentServicePath[currentServicePathLen - 1] == L'\"';
if (doesServiceHaveCorrectPath) {
LOG(("The MozillaMaintenance service path is correct."));
servicePathWasWrong = FALSE;
return TRUE;
}
// This is a recoverable situation so not logging as a warning
LOG(("The MozillaMaintenance path is NOT correct. It was: %ls",
currentServicePath));
servicePathWasWrong = TRUE;
WCHAR fixedPath[MAX_PATH + 1] = { L'\0' };
wcsncpy(fixedPath, currentServicePath, MAX_PATH);
PathUnquoteSpacesW(fixedPath);
if (!PathRemoveFileSpecW(fixedPath)) {
LOG_WARN(("Couldn't remove file spec. (%d)", GetLastError()));
return FALSE;
}
if (!PathAppendSafe(fixedPath, L"maintenanceservice.exe")) {
LOG_WARN(("Couldn't append file spec. (%d)", GetLastError()));
return FALSE;
}
PathQuoteSpacesW(fixedPath);
if (!ChangeServiceConfigW(service, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
SERVICE_NO_CHANGE, fixedPath, nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr)) {
LOG_WARN(("Could not fix service path. (%d)", GetLastError()));
return FALSE;
}
LOG(("Fixed service path to: %ls.", fixedPath));
return TRUE;
}
/**
* Determines if the MozillaMaintenance service path needs to be updated
* and fixes it if it is wrong.
*
* @param service A handle to the service to fix.
* @param currentServicePath The current (possibly wrong) path that is used.
* @param servicePathWasWrong Out parameter set to TRUE if a fix was needed.
* @return TRUE if the service path is now correct.
*/
BOOL
FixServicePath(SC_HANDLE service,
LPCWSTR currentServicePath,
BOOL &servicePathWasWrong)
{
// When we originally upgraded the MozillaMaintenance service we
// would uninstall the service on each upgrade. This had an
// intermittent error which could cause the service to use the file
// maintenanceservice_tmp.exe as the install path. Only a small number
// of Nightly users would be affected by this, but we check for this
// state here and fix the user if they are affected.
bool doesServiceHaveCorrectPath =
!wcsstr(currentServicePath, L"maintenanceservice_tmp.exe");
if (doesServiceHaveCorrectPath) {
LOG(("The MozillaMaintenance service path is correct.\n"));
servicePathWasWrong = FALSE;
return TRUE;
}
LOG(("The MozillaMaintenance path is NOT correct.\n"));
servicePathWasWrong = TRUE;
WCHAR fixedPath[MAX_PATH + 1] = { L'\0' };
wcsncpy(fixedPath, currentServicePath, MAX_PATH);
PathUnquoteSpacesW(fixedPath);
if (!PathRemoveFileSpecW(fixedPath)) {
LOG(("Couldn't remove file spec. (%d)\n", GetLastError()));
return FALSE;
}
if (!PathAppendSafe(fixedPath, L"maintenanceservice.exe")) {
LOG(("Couldn't append file spec. (%d)\n", GetLastError()));
return FALSE;
}
PathQuoteSpacesW(fixedPath);
if (!ChangeServiceConfigW(service, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
SERVICE_NO_CHANGE, fixedPath, NULL, NULL, NULL,
NULL, NULL, NULL)) {
LOG(("Could not fix service path. (%d)\n", GetLastError()));
return FALSE;
}
LOG(("Fixed service path to: %ls.\n", fixedPath));
return TRUE;
}
HRESULT GetShellItemFromCommandLine(REFIID riid, void **ppv)
{
*ppv = NULL;
HRESULT hr = E_FAIL;
int cArgs;
PWSTR *ppszCmd = CommandLineToArgvW(GetCommandLineW(), &cArgs);
if (ppszCmd && cArgs > 1)
{
WCHAR szSpec[MAX_PATH];
szSpec[0] = 0;
// skip all parameters that begin with "-" or "/" to try to find the
// file name. this enables parameters to be present on the cmd line
// and not get in the way of this function
for (int i = 1; (szSpec[0] == 0) && (i < cArgs); i++)
{
if ((*ppszCmd[i] != L'-') && (*ppszCmd[i] != L'/'))
{
StringCchCopyW(szSpec, ARRAYSIZE(szSpec), ppszCmd[i]);
PathUnquoteSpacesW(szSpec);
}
}
hr = szSpec[0] ? S_OK : E_FAIL; // protect against empty
if (SUCCEEDED(hr))
{
hr = SHCreateItemFromParsingName(szSpec, NULL, riid, ppv);
if (FAILED(hr))
{
WCHAR szFolder[MAX_PATH];
GetCurrentDirectoryW(ARRAYSIZE(szFolder), szFolder);
hr = PathAppendW(szFolder, szSpec) ? S_OK : E_FAIL;
if (SUCCEEDED(hr))
{
hr = SHCreateItemFromParsingName(szFolder, NULL, riid, ppv);
}
}
}
}
return hr;
}
static BOOL HCR_RegGetIconW(HKEY hkey, LPWSTR szDest, LPCWSTR szName, DWORD len, int* picon_idx)
{
DWORD dwType;
WCHAR sTemp[MAX_PATH];
WCHAR sNum[7];
if (!RegQueryValueExW(hkey, szName, 0, &dwType, (LPBYTE)szDest, &len))
{
if (dwType == REG_EXPAND_SZ)
{
ExpandEnvironmentStringsW(szDest, sTemp, MAX_PATH);
lstrcpynW(szDest, sTemp, len);
}
if (ParseFieldW (szDest, 2, sNum, _countof(sNum)))
*picon_idx = atoiW(sNum);
else
*picon_idx=0; /* sometimes the icon number is missing */
ParseFieldW (szDest, 1, szDest, len);
PathUnquoteSpacesW(szDest);
return TRUE;
}
return FALSE;
}
LONG WINAPI
ImageView_CreateWindow(HWND hwnd, LPWSTR szFileName)
{
struct GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
WNDCLASS WndClass = {0};
TCHAR szBuf[512];
WCHAR szInitialFile[MAX_PATH];
HWND hMainWnd;
MSG msg;
if (!ImageView_LoadSettings())
{
shiSettings.Maximized = FALSE;
shiSettings.Left = 0;
shiSettings.Top = 0;
shiSettings.Right = 520;
shiSettings.Bottom = 400;
}
// Initialize GDI+
gdiplusStartupInput.GdiplusVersion = 1;
gdiplusStartupInput.DebugEventCallback = NULL;
gdiplusStartupInput.SuppressBackgroundThread = FALSE;
gdiplusStartupInput.SuppressExternalCodecs = FALSE;
GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
pLoadImage(szFileName);
// Create the window
WndClass.lpszClassName = _T("shimgvw_window");
WndClass.lpfnWndProc = ImageView_WndProc;
WndClass.hInstance = hInstance;
WndClass.style = CS_HREDRAW | CS_VREDRAW;
WndClass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
WndClass.hCursor = LoadCursor(hInstance, IDC_ARROW);
WndClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
if (!RegisterClass(&WndClass)) return -1;
LoadString(hInstance, IDS_APPTITLE, szBuf, sizeof(szBuf) / sizeof(TCHAR));
hMainWnd = CreateWindow(_T("shimgvw_window"), szBuf,
WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CAPTION,
CW_USEDEFAULT, CW_USEDEFAULT,
0, 0, NULL, NULL, hInstance, NULL);
// make sure the path has no quotes on it
wcscpy(szInitialFile, szFileName);
PathUnquoteSpacesW(szInitialFile);
currentFile = pBuildFileList(szInitialFile);
if (currentFile)
{
pLoadImageFromNode(currentFile, hMainWnd);
}
// Show it
ShowWindow(hMainWnd, SW_SHOW);
UpdateWindow(hMainWnd);
// Message Loop
while(GetMessage(&msg,NULL,0,0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
pFreeFileList(currentFile);
if (image)
GdipDisposeImage(image);
GdiplusShutdown(gdiplusToken);
return -1;
}
/**
* Starts the upgrade process for update of the service if it is
* already installed.
*
* @param installDir the installation directory where
* maintenanceservice_installer.exe is located.
* @return TRUE if successful
*/
BOOL
StartServiceUpdate(LPCWSTR installDir)
{
// Get a handle to the local computer SCM database
SC_HANDLE manager = OpenSCManager(nullptr, nullptr,
SC_MANAGER_ALL_ACCESS);
if (!manager) {
return FALSE;
}
// Open the service
SC_HANDLE svc = OpenServiceW(manager, SVC_NAME,
SERVICE_ALL_ACCESS);
if (!svc) {
CloseServiceHandle(manager);
return FALSE;
}
// If we reach here, then the service is installed, so
// proceed with upgrading it.
CloseServiceHandle(manager);
// The service exists and we opened it, get the config bytes needed
DWORD bytesNeeded;
if (!QueryServiceConfigW(svc, nullptr, 0, &bytesNeeded) &&
GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
CloseServiceHandle(svc);
return FALSE;
}
// Get the service config information, in particular we want the binary
// path of the service.
mozilla::ScopedDeleteArray<char> serviceConfigBuffer(new char[bytesNeeded]);
if (!QueryServiceConfigW(svc,
reinterpret_cast<QUERY_SERVICE_CONFIGW*>(serviceConfigBuffer.get()),
bytesNeeded, &bytesNeeded)) {
CloseServiceHandle(svc);
return FALSE;
}
CloseServiceHandle(svc);
QUERY_SERVICE_CONFIGW &serviceConfig =
*reinterpret_cast<QUERY_SERVICE_CONFIGW*>(serviceConfigBuffer.get());
PathUnquoteSpacesW(serviceConfig.lpBinaryPathName);
// Obtain the temp path of the maintenance service binary
WCHAR tmpService[MAX_PATH + 1] = { L'\0' };
if (!PathGetSiblingFilePath(tmpService, serviceConfig.lpBinaryPathName,
L"maintenanceservice_tmp.exe")) {
return FALSE;
}
// Get the new maintenance service path from the install dir
WCHAR newMaintServicePath[MAX_PATH + 1] = { L'\0' };
wcsncpy(newMaintServicePath, installDir, MAX_PATH);
PathAppendSafe(newMaintServicePath,
L"maintenanceservice.exe");
// Copy the temp file in alongside the maintenace service.
// This is a requirement for maintenance service upgrades.
if (!CopyFileW(newMaintServicePath, tmpService, FALSE)) {
return FALSE;
}
// Start the upgrade comparison process
STARTUPINFOW si = {0};
si.cb = sizeof(STARTUPINFOW);
// No particular desktop because no UI
si.lpDesktop = L"";
PROCESS_INFORMATION pi = {0};
WCHAR cmdLine[64] = { '\0' };
wcsncpy(cmdLine, L"dummyparam.exe upgrade",
sizeof(cmdLine) / sizeof(cmdLine[0]) - 1);
BOOL svcUpdateProcessStarted = CreateProcessW(tmpService,
cmdLine,
nullptr, nullptr, FALSE,
0,
nullptr, installDir, &si, &pi);
if (svcUpdateProcessStarted) {
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
return svcUpdateProcessStarted;
}
/**
* Installs or upgrades the SVC_NAME service.
* If an existing service is already installed, we replace it with the
* currently running process.
*
* @param action The action to perform.
* @return TRUE if the service was installed/upgraded
*/
BOOL
SvcInstall(SvcInstallAction action)
{
// Get a handle to the local computer SCM database with full access rights.
nsAutoServiceHandle schSCManager(OpenSCManager(NULL, NULL,
SC_MANAGER_ALL_ACCESS));
if (!schSCManager) {
LOG(("Could not open service manager. (%d)\n", GetLastError()));
return FALSE;
}
WCHAR newServiceBinaryPath[MAX_PATH + 1];
if (!GetModuleFileNameW(NULL, newServiceBinaryPath,
sizeof(newServiceBinaryPath) /
sizeof(newServiceBinaryPath[0]))) {
LOG(("Could not obtain module filename when attempting to "
"install service. (%d)\n",
GetLastError()));
return FALSE;
}
// Check if we already have the service installed.
nsAutoServiceHandle schService(OpenServiceW(schSCManager,
SVC_NAME,
SERVICE_ALL_ACCESS));
DWORD lastError = GetLastError();
if (!schService && ERROR_SERVICE_DOES_NOT_EXIST != lastError) {
// The service exists but we couldn't open it
LOG(("Could not open service. (%d)\n", GetLastError()));
return FALSE;
}
if (schService) {
// The service exists but it may not have the correct permissions.
// This could happen if the permissions were not set correctly originally
// or have been changed after the installation. This will reset the
// permissions back to allow limited user accounts.
if (!SetUserAccessServiceDACL(schService)) {
LOG(("Could not reset security ACE on service handle. It might not be "
"possible to start the service. This error should never "
"happen. (%d)\n", GetLastError()));
}
// The service exists and we opened it
DWORD bytesNeeded;
if (!QueryServiceConfigW(schService, NULL, 0, &bytesNeeded) &&
GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
LOG(("Could not determine buffer size for query service config. (%d)\n",
GetLastError()));
return FALSE;
}
// Get the service config information, in particular we want the binary
// path of the service.
nsAutoArrayPtr<char> serviceConfigBuffer = new char[bytesNeeded];
if (!QueryServiceConfigW(schService,
reinterpret_cast<QUERY_SERVICE_CONFIGW*>(serviceConfigBuffer.get()),
bytesNeeded, &bytesNeeded)) {
LOG(("Could open service but could not query service config. (%d)\n",
GetLastError()));
return FALSE;
}
QUERY_SERVICE_CONFIGW &serviceConfig =
*reinterpret_cast<QUERY_SERVICE_CONFIGW*>(serviceConfigBuffer.get());
// Check if we need to fix the service path
BOOL servicePathWasWrong;
static BOOL alreadyCheckedFixServicePath = FALSE;
if (!alreadyCheckedFixServicePath) {
if (!FixServicePath(schService, serviceConfig.lpBinaryPathName,
servicePathWasWrong)) {
LOG(("Could not fix service path. This should never happen. (%d)\n",
GetLastError()));
// True is returned because the service is pointing to
// maintenanceservice_tmp.exe so it actually was upgraded to the
// newest installed service.
return TRUE;
} else if (servicePathWasWrong) {
// Now that the path is fixed we should re-attempt the install.
// This current process' image path is maintenanceservice_tmp.exe.
// The service used to point to maintenanceservice_tmp.exe.
// The service was just fixed to point to maintenanceservice.exe.
// Re-attempting an install from scratch will work as normal.
alreadyCheckedFixServicePath = TRUE;
LOG(("Restarting install action: %d\n", action));
return SvcInstall(action);
}
}
// Ensure the service path is not quoted. We own this memory and know it to
// be large enough for the quoted path, so it is large enough for the
// unquoted path. This function cannot fail.
PathUnquoteSpacesW(serviceConfig.lpBinaryPathName);
// Obtain the existing maintenanceservice file's version number and
// the new file's version number. Versions are in the format of
// A.B.C.D.
DWORD existingA, existingB, existingC, existingD;
DWORD newA, newB, newC, newD;
BOOL obtainedExistingVersionInfo =
GetVersionNumberFromPath(serviceConfig.lpBinaryPathName,
existingA, existingB,
existingC, existingD);
if (!GetVersionNumberFromPath(newServiceBinaryPath, newA,
newB, newC, newD)) {
LOG(("Could not obtain version number from new path\n"));
return FALSE;
}
// Check if we need to replace the old binary with the new one
// If we couldn't get the old version info then we assume we should
// replace it.
if (ForceInstallSvc == action ||
!obtainedExistingVersionInfo ||
(existingA < newA) ||
(existingA == newA && existingB < newB) ||
(existingA == newA && existingB == newB &&
existingC < newC) ||
(existingA == newA && existingB == newB &&
existingC == newC && existingD < newD)) {
// We have a newer updater, so update the description from the INI file.
UpdateServiceDescription(schService);
schService.reset();
if (!StopService()) {
return FALSE;
}
if (!wcscmp(newServiceBinaryPath, serviceConfig.lpBinaryPathName)) {
LOG(("File is already in the correct location, no action needed for "
"upgrade. The path is: \"%ls\"\n", newServiceBinaryPath));
return TRUE;
}
BOOL result = TRUE;
// Attempt to copy the new binary over top the existing binary.
// If there is an error we try to move it out of the way and then
// copy it in. First try the safest / easiest way to overwrite the file.
if (!CopyFileW(newServiceBinaryPath,
serviceConfig.lpBinaryPathName, FALSE)) {
LOG(("Could not overwrite old service binary file. "
"This should never happen, but if it does the next upgrade will "
"fix it, the service is not a critical component that needs to be "
"installed for upgrades to work. (%d)\n", GetLastError()));
// We rename the last 3 filename chars in an unsafe way. Manually
// verify there are more than 3 chars for safe failure in MoveFileExW.
const size_t len = wcslen(serviceConfig.lpBinaryPathName);
if (len > 3) {
// Calculate the temp file path that we're moving the file to. This
// is the same as the proper service path but with a .old extension.
LPWSTR oldServiceBinaryTempPath =
new WCHAR[len + 1];
memset(oldServiceBinaryTempPath, 0, (len + 1) * sizeof (WCHAR));
wcsncpy(oldServiceBinaryTempPath, serviceConfig.lpBinaryPathName, len);
// Rename the last 3 chars to 'old'
wcsncpy(oldServiceBinaryTempPath + len - 3, L"old", 3);
// Move the current (old) service file to the temp path.
if (MoveFileExW(serviceConfig.lpBinaryPathName,
oldServiceBinaryTempPath,
MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
// The old binary is moved out of the way, copy in the new one.
if (!CopyFileW(newServiceBinaryPath,
serviceConfig.lpBinaryPathName, FALSE)) {
// It is best to leave the old service binary in this condition.
LOG(("ERROR: The new service binary could not be copied in."
" The service will not be upgraded.\n"));
result = FALSE;
} else {
LOG(("The new service binary was copied in by first moving the"
" old one out of the way.\n"));
}
// Attempt to get rid of the old service temp path.
if (DeleteFileW(oldServiceBinaryTempPath)) {
LOG(("The old temp service path was deleted: %ls.\n",
oldServiceBinaryTempPath));
} else {
// The old temp path could not be removed. It will be removed
// the next time the user can't copy the binary in or on uninstall.
LOG(("WARNING: The old temp service path was not deleted.\n"));
}
} else {
// It is best to leave the old service binary in this condition.
LOG(("ERROR: Could not move old service file out of the way from:"
" \"%ls\" to \"%ls\". Service will not be upgraded. (%d)\n",
serviceConfig.lpBinaryPathName,
oldServiceBinaryTempPath, GetLastError()));
result = FALSE;
}
delete[] oldServiceBinaryTempPath;
} else {
// It is best to leave the old service binary in this condition.
LOG(("ERROR: Service binary path was less than 3, service will"
" not be updated. This should never happen.\n"));
result = FALSE;
}
} else {
LOG(("The new service binary was copied in.\n"));
}
// We made a copy of ourselves to the existing location.
// The tmp file (the process of which we are executing right now) will be
// left over. Attempt to delete the file on the next reboot.
if (MoveFileExW(newServiceBinaryPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT)) {
LOG(("Deleting the old file path on the next reboot: %ls.\n",
newServiceBinaryPath));
} else {
LOG(("Call to delete the old file path failed: %ls.\n",
newServiceBinaryPath));
}
return result;
}
// We don't need to copy ourselves to the existing location.
// The tmp file (the process of which we are executing right now) will be
// left over. Attempt to delete the file on the next reboot.
MoveFileExW(newServiceBinaryPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
// nothing to do, we already have a newer service installed
return TRUE;
}
// If the service does not exist and we are upgrading, don't install it.
if (UpgradeSvc == action) {
// The service does not exist and we are upgrading, so don't install it
return TRUE;
}
// Quote the path only if it contains spaces.
PathQuoteSpacesW(newServiceBinaryPath);
// The service does not already exist so create the service as on demand
schService.own(CreateServiceW(schSCManager, SVC_NAME, SVC_DISPLAY_NAME,
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
newServiceBinaryPath, NULL, NULL, NULL,
NULL, NULL));
if (!schService) {
LOG(("Could not create Windows service. "
"This error should never happen since a service install "
"should only be called when elevated. (%d)\n", GetLastError()));
return FALSE;
}
if (!SetUserAccessServiceDACL(schService)) {
LOG(("Could not set security ACE on service handle, the service will not "
"be able to be started from unelevated processes. "
"This error should never happen. (%d)\n",
GetLastError()));
}
UpdateServiceDescription(schService);
return TRUE;
}
/** \brief 主函数
*
* 主启动函数。负责调用启动DLL的启动函数
*/
INT WINAPI WinMain(HINSTANCE currentInstance, HINSTANCE previousInstance, LPSTR pCommandLine, INT showType)
{
INT exitCode = -1;
/* 获得几个要加到Path的文件夹路径 */
wchar_t binaryPath[MAX_PATH];
wchar_t pathEnvironmentVariable[32767 /* http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188.aspx */ ];
std::wstring newPathEnvironmentVariable;
// 当前exe路径
GetModuleFileNameW(currentInstance, binaryPath, sizeof(binaryPath) / sizeof(binaryPath[0]));
PathRemoveBlanksW(binaryPath);
PathUnquoteSpacesW(binaryPath);
PathRemoveBackslashW(binaryPath);
// bin文件夹路径
PathRemoveFileSpecW(binaryPath);
PathAppendW(binaryPath, L"bin");
// 拷贝到待增加路径字符串
newPathEnvironmentVariable.append(binaryPath);
// plugin文件夹路径
PathRemoveFileSpecW(binaryPath);
PathAppendW(binaryPath, L"plugin");
// 拷贝到待增加路径字符串
newPathEnvironmentVariable.append(L";");
newPathEnvironmentVariable.append(binaryPath);
/* 设置PATH环境变量 */
// 获取环境变量
pathEnvironmentVariable[0] = L'\0';
DWORD length = GetEnvironmentVariableW(L"PATH", pathEnvironmentVariable, sizeof(pathEnvironmentVariable) / sizeof(pathEnvironmentVariable[0]));
// 组合新环境变量
if (length > 0)
newPathEnvironmentVariable.append(L";");
newPathEnvironmentVariable.append(pathEnvironmentVariable);
// 拷贝回去
wcscpy_s(pathEnvironmentVariable, newPathEnvironmentVariable.c_str());
// 设置环境变量
SetEnvironmentVariableW(L"PATH", pathEnvironmentVariable);
/* 载入CRT的Dll，防止Dll冲突 */
// 再次得到bin文件夹路径
PathRemoveFileSpecW(binaryPath);
PathAppendW(binaryPath, L"bin");
#ifdef _DEBUG
PathAppendW(binaryPath, L"msvcr100d.dll");
HMODULE msvcr100 = LoadLibraryW(binaryPath);
PathRemoveFileSpecW(binaryPath);
PathAppendW(binaryPath, L"msvcp100d.dll");
HMODULE msvcp100 = LoadLibraryW(binaryPath);
#else
PathAppendW(binaryPath, L"msvcr100.dll");
HMODULE msvcr100 = LoadLibraryW(binaryPath);
PathRemoveFileSpecW(binaryPath);
PathAppendW(binaryPath, L"msvcp100.dll");
HMODULE msvcp100 = LoadLibraryW(binaryPath);
#endif
// 尝试载入YDWEStartup.dll
HMODULE startupModule = LoadLibraryW(L"YDWEStartup.dll");
if (startupModule)
{
TPFStartup pfStartup = (TPFStartup)GetProcAddress(startupModule, "YDWEStartup");
if (pfStartup)
exitCode = pfStartup(currentInstance, previousInstance, pCommandLine, showType);
FreeLibrary(startupModule);
}
if (msvcp100)
FreeLibrary(msvcp100);
if (msvcr100)
FreeLibrary(msvcr100);
return exitCode;
}
VOID
CFileDefExt::InitOpensWithField(HWND hwndDlg)
{
WCHAR wszBuf[MAX_PATH] = L"";
WCHAR wszPath[MAX_PATH] = L"";
DWORD dwSize = sizeof(wszBuf);
BOOL bUnknownApp = TRUE;
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &dwSize) == ERROR_SUCCESS)
{
bUnknownApp = FALSE;
StringCbCatW(wszBuf, sizeof(wszBuf), L"\\shell\\open\\command");
dwSize = sizeof(wszPath);
if (RegGetValueW(HKEY_CLASSES_ROOT, wszBuf, L"", RRF_RT_REG_SZ, NULL, wszPath, &dwSize) == ERROR_SUCCESS)
{
/* Get path from command line */
ExpandEnvironmentStringsW(wszPath, wszBuf, _countof(wszBuf));
PathRemoveArgs(wszBuf);
PathUnquoteSpacesW(wszBuf);
PathSearchAndQualify(wszBuf, wszPath, _countof(wszPath));
HICON hIcon;
if (ExtractIconExW(wszPath, 0, NULL, &hIcon, 1))
{
HWND hIconCtrl = GetDlgItem(hwndDlg, 14025);
HWND hDescrCtrl = GetDlgItem(hwndDlg, 14007);
ShowWindow(hIconCtrl, SW_SHOW);
RECT rcIcon, rcDescr;
GetWindowRect(hIconCtrl, &rcIcon);
if (rcIcon.left == rcIcon.right)
ERR("Icon control has invalid width: %d-%d\n", rcIcon.left, rcIcon.right);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcIcon, 2);
GetWindowRect(hDescrCtrl, &rcDescr);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&rcDescr, 2);
INT cxOffset = rcIcon.right + 2 - rcDescr.left;
SetWindowPos(hDescrCtrl, NULL,
rcDescr.left + cxOffset, rcDescr.top,
rcDescr.right - rcDescr.left - cxOffset, rcDescr.bottom - rcDescr.top,
SWP_NOZORDER);
SendMessageW(hIconCtrl, STM_SETICON, (WPARAM)hIcon, 0);
} else
ERR("Failed to extract icon\n");
if (PathFileExistsW(wszPath))
{
/* Get file description */
CFileVersionInfo VerInfo;
VerInfo.Load(wszPath);
LPCWSTR pwszDescr = VerInfo.GetString(L"FileDescription");
if (pwszDescr)
SetDlgItemTextW(hwndDlg, 14007, pwszDescr);
else
{
/* File has no description - display filename */
LPWSTR pwszFilename = PathFindFileNameW(wszPath);
PathRemoveExtension(pwszFilename);
pwszFilename[0] = towupper(pwszFilename[0]);
SetDlgItemTextW(hwndDlg, 14007, pwszFilename);
}
}
else
bUnknownApp = TRUE;
} else
WARN("RegGetValueW %ls failed\n", wszBuf);
} else
WARN("RegGetValueW %ls failed\n", pwszExt);
if (bUnknownApp)
{
/* Unknown application */
LoadStringW(shell32_hInstance, IDS_UNKNOWN_APP, wszBuf, _countof(wszBuf));
SetDlgItemTextW(hwndDlg, 14007, wszBuf);
}
}
