You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1345 lines
43 KiB
1345 lines
43 KiB
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
#define MAINWINDOW_CURSOR IDC_ARROW
|
|
#define RESOURCE_STRING_MAX_LENGTH 100
|
|
|
|
TCHAR AU_WINDOW_CLASS_NAME[] = _T("Auto Update Client Window");
|
|
const TCHAR gtszAUW2KPrivacyUrl[]= _T("..\\help\\wuauhelp.chm::/w2k_autoupdate_privacy.htm");
|
|
const TCHAR gtszAUXPPrivacyUrl[]= _T("..\\help\\wuauhelp.chm::/autoupdate_privacy.htm");
|
|
|
|
const ReminderItem ReminderTimes[TIMEOUT_INX_COUNT] =
|
|
{
|
|
{ 1800, IDS_THIRTY_MINUTES },
|
|
{ 3600, IDS_ONE_HOUR },
|
|
{ 7200, IDS_TWO_HOURS },
|
|
{ 14400, IDS_FOUR_HOURS },
|
|
{ 86400, IDS_TOMORROW },
|
|
{ 259200, IDS_THREE_DAYS }
|
|
};
|
|
|
|
const UINT RESOURCESTRINGINDEX[] = {
|
|
IDS_NOTE,
|
|
IDS_WELCOME_CONTINUE,
|
|
IDS_EULA,
|
|
IDS_PRIVACY,
|
|
IDS_LEARNMORE,
|
|
IDS_LEARNMOREAUTO
|
|
};
|
|
|
|
|
|
// Global Data Items
|
|
CAUInternals* gInternals;
|
|
AUClientCatalog *gpClientCatalog ; //= NULL
|
|
TCHAR gResStrings[ARRAYSIZE(RESOURCESTRINGINDEX)][RESOURCE_STRING_MAX_LENGTH];
|
|
// Global UI Items
|
|
CRITICAL_SECTION gcsClient; // guard guard user's tray interaction (showing, not showing) and guard customlb data
|
|
HINSTANCE ghInstance;
|
|
HFONT ghHeaderFont;
|
|
HCURSOR ghCursorHand;
|
|
HCURSOR ghCursorNormal; // cursor of main window
|
|
|
|
HMODULE ghRichEd20;
|
|
HANDLE ghEngineState;
|
|
HWND ghMainWindow;
|
|
HWND ghCurrentDialog;
|
|
HWND ghCurrentMainDlg;
|
|
AUCLTTopWindows gTopWins;
|
|
UINT gNextDialogMsg;
|
|
BOOL gbOnlySession; // = FALSE;
|
|
BOOL gfShowingInstallWarning; // = FALSE;
|
|
|
|
HMENU ghPauseMenu;
|
|
HMENU ghResumeMenu;
|
|
HMENU ghCurrentMenu;
|
|
HICON ghAppIcon;
|
|
HICON ghAppSmIcon;
|
|
HICON ghTrayIcon;
|
|
UINT guExitProcess=CDWWUAUCLT_UNSPECIFY;
|
|
|
|
LPCTSTR gtszAUSchedInstallUrl;
|
|
LPCTSTR gtszAUPrivacyUrl;
|
|
|
|
AU_ENV_VARS gAUEnvVars;
|
|
|
|
|
|
// No critical section used to access the following variables.
|
|
// Should them only in WinMain/MainWndProc thread.
|
|
HANDLE g_hClientNotifyEvt = NULL; //the event Engine use to notify client
|
|
HANDLE g_hRegisterWait = NULL;
|
|
BOOL g_fCoInit = FALSE;
|
|
BOOL g_fcsInit = FALSE;
|
|
BOOL g_fAlreadyUninit = FALSE;
|
|
|
|
|
|
/****
|
|
Helper function to simplify window class registration.
|
|
*****/
|
|
ATOM AURegisterWindowClass(WNDPROC lpWndProc, LPTSTR lpClassName)
|
|
{
|
|
WNDCLASSEX wcex;
|
|
|
|
ZeroMemory(&wcex, sizeof(wcex));
|
|
|
|
wcex.cbSize = sizeof(WNDCLASSEX);
|
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
|
wcex.lpfnWndProc = lpWndProc;
|
|
// wcex.cbClsExtra = 0;
|
|
// wcex.cbWndExtra = 0;
|
|
// wcex.lpszMenuName = NULL;
|
|
// wcex.hIcon = NULL;
|
|
// wcex.hIconSm = NULL;
|
|
wcex.hInstance = ghInstance;
|
|
wcex.hCursor = LoadCursor(NULL, MAINWINDOW_CURSOR);
|
|
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
|
|
wcex.lpszClassName = lpClassName;
|
|
|
|
return RegisterClassEx(&wcex);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// map string id to its storage in the gResStrings
|
|
///////////////////////////////////////////////////////////////////
|
|
LPTSTR ResStrFromId(UINT uStrId)
|
|
{
|
|
for (int i = 0; i < ARRAYSIZE(RESOURCESTRINGINDEX); i++)
|
|
{
|
|
if (RESOURCESTRINGINDEX[i] == uStrId)
|
|
{
|
|
return gResStrings[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Set reminder timeout and state and quit
|
|
////////////////////////////////////////////////////////
|
|
void QuitNRemind(TIMEOUTINDEX enTimeoutIndex)
|
|
{
|
|
AUSTATE auState;
|
|
if (FAILED(gInternals->m_getServiceState(&auState)))
|
|
{
|
|
goto done;
|
|
}
|
|
if (FAILED(gInternals->m_setReminderTimeout(enTimeoutIndex)))
|
|
{
|
|
goto done;
|
|
}
|
|
gInternals->m_setReminderState(auState.dwState);
|
|
done:
|
|
QUITAUClient();
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Helper Function HrQuerySessionConnectState(int iAdminSession, int *piConState)
|
|
// helper function to get the Session Connection State
|
|
//
|
|
// Input: int iAdminSession Session Admin ID
|
|
// Output: int *piConState Conection state
|
|
// Return: HRESULT value. If Failed, *piConState is unspecified
|
|
////////////////////////////////////////////////////////////////////////////
|
|
HRESULT HrQuerySessionConnectState(int iAdminSession, int *piConState)
|
|
{
|
|
LPTSTR pBuffer = NULL;
|
|
HRESULT hr = NO_ERROR;
|
|
DWORD dwBytes;
|
|
|
|
if (AUIsTSRunning())
|
|
{
|
|
|
|
if (WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE, iAdminSession, WTSConnectState,
|
|
&pBuffer, &dwBytes))
|
|
{
|
|
*piConState = (int) *pBuffer; //Because we are asking for WTSConnectState, pBuffer points to an int
|
|
WTSFreeMemory(pBuffer);
|
|
hr = NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("WUAUCLT: WTSQuerySessionInformation failed: %lu", GetLastError());
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwSession = iAdminSession;
|
|
|
|
if (dwSession == WTS_CURRENT_SESSION)
|
|
ProcessIdToSessionId(GetCurrentProcessId(), &dwSession);
|
|
|
|
// if we're launched & TS is not up, we've gotta be an active session.
|
|
if (dwSession == 0)
|
|
{
|
|
DEBUGMSG("WUAUCLT: TS is not running or not installed. Assuming session 0 is active.");
|
|
gbOnlySession = TRUE;
|
|
*piConState = WTSActive;
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("WUAUCLT: TS is not running or not installed, but a non 0 session was asked for (session %d). Failing call.", iAdminSession);
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
BOOL FCurrentSessionInActive()
|
|
{
|
|
BOOL fRet = FALSE;
|
|
HRESULT hr;
|
|
int iConState;
|
|
|
|
if (gbOnlySession)
|
|
{
|
|
DEBUGMSG("FCurrentSessionInActive() Only one session");
|
|
goto Done;
|
|
}
|
|
|
|
//Check if the Current Session is Inactive
|
|
hr = HrQuerySessionConnectState(WTS_CURRENT_SESSION, &iConState);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fRet = (WTSDisconnected == iConState);
|
|
}
|
|
else
|
|
{
|
|
if (RPC_S_INVALID_BINDING == GetLastError()) //Terminal Services are disabled, this is session 0
|
|
{
|
|
DEBUGMSG("FCurrentSessionInActive() TS disabled");
|
|
gbOnlySession = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("FCurrentSessionInActive() HrQuerySessionConnectState failed %#lx =",hr);
|
|
}
|
|
}
|
|
Done:
|
|
// DEBUGMSG("FCurrentSessionInActive() return %s", fRet ? "TRUE" : "FALSE");
|
|
return fRet;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// BuildClientCatalog
|
|
//
|
|
// Do online detection of the catalog and build up the wuv3is.dll detection state
|
|
// inside this process. Validation is done during this process with the catalog file
|
|
// previously written by the engine.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT BuildClientCatalog(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DEBUGMSG("BuildClientCatalog() starts");
|
|
if ( NULL == gpClientCatalog )
|
|
{
|
|
gpClientCatalog = new AUClientCatalog();
|
|
if ( NULL != gpClientCatalog )
|
|
{
|
|
if ( FAILED(hr = gpClientCatalog->Init()) )
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
// change to: hr = gpClientCatalog->LoadInstallXML();
|
|
|
|
done:
|
|
DEBUGMSG("BuildClientCatalog() ends");
|
|
return hr;
|
|
}
|
|
|
|
void DismissUIIfAny()
|
|
{
|
|
gTopWins.Add(ghCurrentMainDlg);
|
|
gTopWins.Dismiss();
|
|
|
|
// Don't leave any popup menu around when dismissing dialogs.
|
|
if (SendMessage(ghMainWindow, WM_CANCELMODE, 0, 0))
|
|
{
|
|
DEBUGMSG("WUAUCLT WM_CANCELMODE was not handled");
|
|
}
|
|
}
|
|
|
|
|
|
void ResetAUClient(void)
|
|
{
|
|
DismissUIIfAny();
|
|
RemoveTrayIcon();
|
|
gfShowingInstallWarning = FALSE;
|
|
gNextDialogMsg = NULL;
|
|
ghCurrentMenu = NULL;
|
|
}
|
|
|
|
|
|
void ShowInstallWarning()
|
|
{ //dismiss current dialog if any
|
|
DEBUGMSG("ShowInstallWarning() starts");
|
|
gfShowingInstallWarning = TRUE;
|
|
gNextDialogMsg = NULL;
|
|
ghCurrentMenu = NULL;
|
|
CPromptUserDlg PromptUserDlg(IDD_START_INSTALL);
|
|
PromptUserDlg.SetInstanceHandle(ghInstance);
|
|
INT iRet = PromptUserDlg.DoModal(NULL);
|
|
DEBUGMSG("WUAUCLT ShowInstallWarning dlg return code is %d", iRet);
|
|
if (IDYES == iRet || AU_IDTIMEOUT == iRet)
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_INSTALLNOW);
|
|
QUITAUClient();
|
|
}
|
|
else //if (retVal == IDNO)
|
|
{
|
|
gNextDialogMsg = AUMSG_SHOW_INSTALL;
|
|
}
|
|
gfShowingInstallWarning = FALSE;
|
|
DEBUGMSG("ShowInstallWarning() ends");
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// fEnableYes: IN whether yes button should be enabled
|
|
// fEnableNo: IN whether no button should be enabled
|
|
// fManualReboot: IN show countdown progress bar if NOT manual
|
|
// dwElapsedTime: IN how many secs passed since count down starts, only used when fManualReboot is set false
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void ShowRebootWarning(BOOL fEnableYes, BOOL fEnableNo, BOOL fManualReboot, DWORD dwElapsedTime)
|
|
{
|
|
DEBUGMSG("ShowRebootWarning() starts");
|
|
INT iRet;
|
|
CPromptUserDlg PromptUserDlg(IDD_PROMPT_RESTART, fEnableYes, fEnableNo, fManualReboot, dwElapsedTime);
|
|
|
|
PromptUserDlg.SetInstanceHandle(ghInstance);
|
|
iRet = PromptUserDlg.DoModal(NULL);
|
|
if (IDYES == iRet)
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_REBOOTNOW);
|
|
}
|
|
else if (IDNO == iRet)
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_REBOOTLATER);
|
|
}
|
|
else //if (IDTIMEOUT == iRet)
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_REBOOTTIMEOUT);
|
|
}
|
|
|
|
QUITAUClient();
|
|
DEBUGMSG("ShowRebootWarning() ends with return code %d", iRet);
|
|
DEBUGMSG("ShowRebootWarning() set client exit code to be %d", GetClientExitCode());
|
|
}
|
|
|
|
VOID CALLBACK WaitCallback(PVOID lpParameter, BOOLEAN /*fTimerOrWaitFired*/ )
|
|
{
|
|
// fTimerOrWaitFired is always false - We can't time out with INFINATE wait
|
|
|
|
BOOL fRebootWarningMode = (BOOL) PtrToInt(lpParameter);
|
|
if (fRebootWarningMode)
|
|
{
|
|
DEBUGMSG("WUAUCLT got exit signal from engine");
|
|
QUITAUClient();
|
|
return ;
|
|
}
|
|
|
|
// ClientNotify event was fired
|
|
CLIENT_NOTIFY_DATA notifyData;
|
|
BOOL fCoInit = SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
|
|
|
|
if ( !fCoInit )
|
|
{
|
|
DEBUGMSG("WUAUCLT WaitCallback CoInitialize failed");
|
|
goto Done;
|
|
}
|
|
|
|
IUpdates * pUpdates = NULL;
|
|
HRESULT hr = CoCreateInstance(__uuidof(Updates),
|
|
NULL,
|
|
CLSCTX_LOCAL_SERVER,
|
|
IID_IUpdates,
|
|
(LPVOID*)&pUpdates);
|
|
if (FAILED(hr))
|
|
{
|
|
DEBUGMSG("WaitCallback failed to get Updates object");
|
|
goto Done;
|
|
}
|
|
if (FAILED(hr = pUpdates->GetNotifyData(¬ifyData)))
|
|
{
|
|
DEBUGMSG("WaitCallback fail to get NotifyData %#lx", hr);
|
|
goto Done;
|
|
}
|
|
switch (notifyData.actionCode)
|
|
{
|
|
case NOTIFY_STOP_CLIENT:
|
|
case NOTIFY_RELAUNCH_CLIENT:
|
|
if (NOTIFY_RELAUNCH_CLIENT == notifyData.actionCode)
|
|
{
|
|
DEBUGMSG("WaitCallback() notify client to relaunch");
|
|
SetClientExitCode(CDWWUAUCLT_RELAUNCHNOW);
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("WaitCallback() notify client to stop");
|
|
SetClientExitCode(CDWWUAUCLT_OK);
|
|
}
|
|
if (NULL != ghMutex)
|
|
{
|
|
WaitForSingleObject(ghMutex, INFINITE);
|
|
if (NULL != gpClientCatalog)
|
|
{
|
|
gpClientCatalog->CancelNQuit();
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("No need to cancel catalag");
|
|
}
|
|
ReleaseMutex(ghMutex);
|
|
}
|
|
QUITAUClient();
|
|
break;
|
|
case NOTIFY_RESET: //reprocess state and option and show UI accordingly
|
|
ResetAUClient();
|
|
SetEvent(ghEngineState);
|
|
break;
|
|
case NOTIFY_ADD_TRAYICON:
|
|
DEBUGMSG("WaitCallback() notify client to show tray icon");
|
|
ShowTrayIcon();
|
|
ghCurrentMenu = ghPauseMenu; //the job is now downloading
|
|
break;
|
|
case NOTIFY_REMOVE_TRAYICON:
|
|
DEBUGMSG("WaitCallback() notify client to remove tray icon");
|
|
RemoveTrayIcon();
|
|
break;
|
|
case NOTIFY_STATE_CHANGE:
|
|
DEBUGMSG("WaitCallback() notify client of state change");
|
|
SetEvent(ghEngineState);
|
|
break;
|
|
case NOTIFY_SHOW_INSTALLWARNING:
|
|
DEBUGMSG("WaitCallback() notify client to show install warning");
|
|
if (!gfShowingInstallWarning)
|
|
{ //install warning dialog is not up, prevent install warning dialog torn down before it expires when secsinaday low
|
|
DismissUIIfAny();
|
|
PostMessage(ghMainWindow, AUMSG_SHOW_INSTALLWARNING, 0, 0);
|
|
}
|
|
break;
|
|
}
|
|
Done:
|
|
SafeRelease(pUpdates);
|
|
if (fCoInit)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
}
|
|
|
|
BOOL ProcessEngineState()
|
|
{
|
|
AUSTATE AuState;
|
|
BOOL fResult = TRUE;
|
|
|
|
DEBUGMSG("WUAUCLT starts ProcessEngineState()");
|
|
ghCurrentMenu = NULL;
|
|
|
|
if (FAILED(gInternals->m_getServiceState(&AuState)))
|
|
{
|
|
DEBUGMSG("WUAUCLT : quit because m_getServiceState failed");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
fResult = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
DEBUGMSG("WUAUCLT process Engine state %lu",AuState.dwState);
|
|
switch(AuState.dwState)
|
|
{
|
|
case AUSTATE_NOT_CONFIGURED:
|
|
if(gNextDialogMsg != AUMSG_SHOW_WELCOME && ghCurrentMainDlg == NULL )
|
|
{
|
|
if (ShowTrayIcon())
|
|
{
|
|
ShowTrayBalloon(IDS_WELCOMETITLE, IDS_WELCOMECAPTION, IDS_WELCOMETITLE);
|
|
gNextDialogMsg = AUMSG_SHOW_WELCOME;
|
|
}
|
|
}
|
|
break;
|
|
case AUSTATE_DETECT_COMPLETE:
|
|
if ( FAILED(gInternals->m_getServiceUpdatesList()) )
|
|
{
|
|
DEBUGMSG("WUAUCLT : quit because m_getServiceUpdatesList failed");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
|
|
{
|
|
AUOPTION auopt;
|
|
|
|
if (SUCCEEDED(gInternals->m_getServiceOption(&auopt)) &&
|
|
(AUOPTION_INSTALLONLY_NOTIFY == auopt.dwOption || AUOPTION_SCHEDULED == auopt.dwOption))
|
|
{
|
|
// user option is auto download, start download
|
|
//ShowTrayIcon();
|
|
|
|
// do download right away without dialogs if user options set to notify for just install
|
|
if (FAILED(gInternals->m_startDownload()))
|
|
{
|
|
QUITAUClient();
|
|
}
|
|
else
|
|
{
|
|
// ghCurrentMenu = ghPauseMenu;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(gNextDialogMsg != AUMSG_SHOW_DOWNLOAD && ghCurrentMainDlg == NULL)
|
|
{
|
|
if (ShowTrayIcon())
|
|
{
|
|
ShowTrayBalloon(IDS_DOWNLOADTITLE, IDS_DOWNLOADCAPTION, IDS_DOWNLOADTITLE);
|
|
gNextDialogMsg = AUMSG_SHOW_DOWNLOAD;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case AUSTATE_DOWNLOAD_COMPLETE:
|
|
if (AUCLT_ACTION_AUTOINSTALL == AuState.dwCltAction)
|
|
{ // engine initiated install: auto install
|
|
HRESULT hr;
|
|
DEBUGMSG("Auto install ...");
|
|
if ( S_OK !=(hr = BuildClientCatalog()))
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to build client catalog with error %#lx, exiting, hr");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
if (FAILED(hr = gInternals->m_startInstall(TRUE)))
|
|
{
|
|
DEBUGMSG("Fail to post install message with error %#lx", hr);
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
gpClientCatalog->m_WrkThread.WaitUntilDone();
|
|
if (gpClientCatalog->m_fReboot)
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_REBOOTNEEDED);
|
|
}
|
|
else
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_OK);
|
|
}
|
|
QUITAUClient();
|
|
break;
|
|
}
|
|
else
|
|
{ //show preinstall dialog and let user initiate install
|
|
HRESULT hr;
|
|
DEBUGMSG("Prompt for manual install");
|
|
if ( FAILED(gInternals->m_getServiceUpdatesList()))
|
|
{
|
|
DEBUGMSG("WUAUCLT : quit because m_getServiceUpdatesList failed");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
|
|
|
|
if ( S_OK !=(hr = BuildClientCatalog()) )
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to build client catalog with error %#lx, exiting", hr);
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
fResult = FALSE;
|
|
}
|
|
else if(gNextDialogMsg != AUMSG_SHOW_INSTALL && ghCurrentMainDlg == NULL)
|
|
{
|
|
if (ShowTrayIcon())
|
|
{
|
|
ShowTrayBalloon(IDS_INSTALLTITLE, IDS_INSTALLCAPTION, IDS_INSTALLTITLE);
|
|
gNextDialogMsg = AUMSG_SHOW_INSTALL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case AUSTATE_DOWNLOAD_PENDING:
|
|
{
|
|
UINT nPercentComplete = 0;
|
|
DWORD dwStatus;
|
|
|
|
//if drizzle got transient error, quit client
|
|
//fixcode: why quit if transient error?
|
|
if (AuState.fDisconnected)
|
|
{
|
|
DEBUGMSG("WUAUCLT : quit because of lost of connection, fDisconnected = %d",AuState.fDisconnected);
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
if (FAILED(gInternals->m_getDownloadStatus(&nPercentComplete, &dwStatus)))
|
|
{
|
|
DEBUGMSG("WUAUCLT : quit because m_getDownloadStatus failed");
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (DWNLDSTATUS_CHECKING_CONNECTION == dwStatus)
|
|
{
|
|
//hide tray icon
|
|
DEBUGMSG("WUAUCLT Waiting for engine to find connection first");
|
|
// RemoveTrayIcon();
|
|
// ghCurrentMenu = NULL;
|
|
}
|
|
else if(dwStatus == DWNLDSTATUS_DOWNLOADING)
|
|
{
|
|
ghCurrentMenu = ghPauseMenu;
|
|
DEBUGMSG("WUAUCLT in active downloading state");
|
|
ShowTrayIcon();
|
|
}
|
|
else if(dwStatus == DWNLDSTATUS_PAUSED)
|
|
{
|
|
ghCurrentMenu = ghResumeMenu;
|
|
DEBUGMSG("WUAUCLT in download paused state");
|
|
if (fDisableSelection() &&
|
|
FAILED(gInternals->m_setDownloadPaused(FALSE)))
|
|
{
|
|
// QUITAUClient(); //let wuaueng to figure out problem and recover
|
|
}
|
|
ShowTrayIcon();
|
|
}
|
|
else //not downloading
|
|
{
|
|
DEBUGMSG("WUAUCLT WARNING: not downloading while in download pending state");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AUSTATE_DETECT_PENDING:
|
|
//Quit only if the Install UI has been accepted or there is no InstallUI
|
|
if (NULL == ghCurrentMainDlg)
|
|
{
|
|
QUITAUClient();
|
|
}
|
|
break;
|
|
|
|
case AUSTATE_DISABLED:
|
|
QUITAUClient();
|
|
break;
|
|
|
|
case AUSTATE_INSTALL_PENDING:
|
|
default:
|
|
// outofbox and waiting_for_reboot are here. WUAUCLT should not be launched in these states
|
|
DEBUGMSG("WUAUCLT AUSTATE = %lu", AuState.dwState);
|
|
break;
|
|
}
|
|
Done:
|
|
DEBUGMSG("WUAUCLT exits ProcessEngineState()");
|
|
return fResult;
|
|
}
|
|
|
|
BOOL InitUIComponents(HINSTANCE hInstance)
|
|
{
|
|
INITCOMMONCONTROLSEX icex;
|
|
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
icex.dwICC = 0; //We dont need to register any control classes
|
|
if (!InitCommonControlsEx(&icex)) //needed for theming
|
|
{
|
|
DEBUGMSG("InitUIComponents :InitCommonControlsEx failed");
|
|
return FALSE;
|
|
}
|
|
|
|
//we need to load riched20.dll to register the class
|
|
ghRichEd20 = LoadLibraryFromSystemDir(_T("RICHED20.dll"));
|
|
if (NULL == ghRichEd20)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
ghCursorHand = LoadCursor(NULL, IDC_HAND);
|
|
ghCursorNormal = LoadCursor(NULL, MAINWINDOW_CURSOR); //change if main window's cursor does
|
|
if (NULL == ghCursorHand)
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to load hand cursor");
|
|
ghCursorHand = ghCursorNormal;
|
|
}
|
|
|
|
ghAppIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_AUICON), IMAGE_ICON, NULL, NULL, LR_DEFAULTSIZE | LR_CREATEDIBSECTION);
|
|
ghAppSmIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_AUICON), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_CREATEDIBSECTION);
|
|
|
|
if (IsWin2K())
|
|
{
|
|
//Win2k
|
|
ghTrayIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_AUSYSTRAYICON), IMAGE_ICON, 16, 16, 0);
|
|
}
|
|
else
|
|
{
|
|
//WindowsXP
|
|
ghTrayIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_AUICON), IMAGE_ICON, 16, 16, LR_CREATEDIBSECTION);
|
|
}
|
|
|
|
for (int i = 0; i < ARRAYSIZE(RESOURCESTRINGINDEX); i++)
|
|
{
|
|
LoadString(hInstance, RESOURCESTRINGINDEX[i], ResStrFromId(RESOURCESTRINGINDEX[i]), RESOURCE_STRING_MAX_LENGTH);
|
|
}
|
|
|
|
ghCurrentAccel = LoadAccelerators(ghInstance, MAKEINTRESOURCE(IDA_BASE));
|
|
gtszAUSchedInstallUrl = IsWin2K() ? gtszAUW2kSchedInstallUrl : gtszAUXPSchedInstallUrl;
|
|
gtszAUPrivacyUrl = IsWin2K() ? gtszAUW2KPrivacyUrl : gtszAUXPPrivacyUrl;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL InitializeAUClientForRebootWarning(HINSTANCE hInstance,
|
|
OUT HANDLE *phRegisterWait,
|
|
OUT HANDLE *phClientNotifyEvt,
|
|
OUT BOOL *pfCoInit)
|
|
{
|
|
TCHAR buf[100];
|
|
|
|
SetClientExitCode(CDWWUAUCLT_UNSPECIFY);
|
|
*phRegisterWait = NULL;
|
|
*pfCoInit = FALSE;
|
|
*phClientNotifyEvt = OpenEvent(SYNCHRONIZE, FALSE, gAUEnvVars.m_szClientExitEvtName);
|
|
if (NULL == *phClientNotifyEvt)
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to open client exit event %S with error %d", gAUEnvVars.m_szClientExitEvtName, GetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
INITCOMMONCONTROLSEX icex;
|
|
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
icex.dwICC = 0; //We dont need to register any control classes
|
|
if (!InitCommonControlsEx(&icex)) //needed for theming
|
|
{
|
|
DEBUGMSG("InitCommonControlsEx failed");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!RegisterWaitForSingleObject(phRegisterWait, // wait handle
|
|
*phClientNotifyEvt, // handle to object
|
|
WaitCallback, // timer callback function
|
|
(PVOID)1, // callback function parameter
|
|
INFINITE, // time-out interval
|
|
WT_EXECUTEONLYONCE // options
|
|
))
|
|
{
|
|
DEBUGMSG("WUAUCLT RegisterWaitForSingleObject failed %lu",GetLastError());
|
|
*phRegisterWait = NULL;
|
|
return FALSE;
|
|
}
|
|
ghInstance = hInstance;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL InitializeAUClient(HINSTANCE hInstance,
|
|
OUT HANDLE * phRegisterWait,
|
|
OUT HANDLE * phClientNotifyEvt,
|
|
OUT BOOL *pfCoInit,
|
|
OUT BOOL *pfcsInit)
|
|
{
|
|
HRESULT hr;
|
|
*pfcsInit = FALSE;
|
|
*phClientNotifyEvt = NULL;
|
|
*phRegisterWait = NULL;
|
|
SetClientExitCode(CDWWUAUCLT_UNSPECIFY);
|
|
*pfCoInit = SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
|
|
|
|
if ( !*pfCoInit )
|
|
{
|
|
DEBUGMSG("WUAUCLT WinMain CoInitialize failed");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!InitUIComponents(hInstance))
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to initialize UI components");
|
|
return FALSE;
|
|
}
|
|
|
|
if (NULL == (ghMutex = CreateMutex(NULL, FALSE, NULL)))
|
|
{
|
|
DEBUGMSG("WUAUCLT fail to create global mutex");
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
gInternals = NULL;
|
|
|
|
if ( (NULL == (ghEngineState = CreateEvent(NULL, FALSE, FALSE, NULL))) )
|
|
{
|
|
DEBUGMSG("WUAUCLT fails to create event");
|
|
return FALSE;
|
|
}
|
|
|
|
ghInstance = hInstance;
|
|
|
|
if (!(*pfcsInit = SafeInitializeCriticalSection(&gcsClient)))
|
|
{
|
|
DEBUGMSG("WUAUCLT fails to initialize critical section");
|
|
return FALSE;
|
|
}
|
|
|
|
#ifndef TESTUI
|
|
|
|
if (! (gInternals = new CAUInternals()))
|
|
{
|
|
DEBUGMSG("WUAUCLT fails to create auinternals object");
|
|
return FALSE;
|
|
}
|
|
|
|
if (FAILED(hr = gInternals->m_Init()))
|
|
{
|
|
DEBUGMSG("WUAUCLT failed in CoCreateInstance of service with error %#lx, exiting", hr);
|
|
return FALSE;
|
|
}
|
|
|
|
AUEVTHANDLES AuEvtHandles;
|
|
ZeroMemory(&AuEvtHandles, sizeof(AuEvtHandles));
|
|
if (FAILED(hr = gInternals->m_getEvtHandles(GetCurrentProcessId(), &AuEvtHandles)))
|
|
{
|
|
DEBUGMSG("WUAUCLT failed in m_getEvtHandles with error %#lx, exiting", hr);
|
|
return FALSE;
|
|
}
|
|
*phClientNotifyEvt = (HANDLE)AuEvtHandles.ulNotifyClient;
|
|
|
|
if (!RegisterWaitForSingleObject( phRegisterWait, // wait handle
|
|
*phClientNotifyEvt, // handle to object
|
|
WaitCallback, // timer callback function
|
|
0, // callback function parameter
|
|
INFINITE, // time-out interval
|
|
WT_EXECUTEDEFAULT // options
|
|
))
|
|
{
|
|
DEBUGMSG("WUAUCLT RegisterWaitForSingleObject failed %lu",GetLastError());
|
|
*phRegisterWait = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void UninitializeAUClient(HANDLE hRegisterWait, HANDLE hClientNotifyEvt, BOOL fCoInit, BOOL fcsInit)
|
|
{
|
|
|
|
if (g_fAlreadyUninit)
|
|
{
|
|
return;
|
|
}
|
|
g_fAlreadyUninit = TRUE;
|
|
|
|
|
|
RemoveTrayIcon();
|
|
if (NULL != hRegisterWait)
|
|
{
|
|
if ( !UnregisterWaitEx(hRegisterWait, INVALID_HANDLE_VALUE) )
|
|
{
|
|
DEBUGMSG("WUAUCLT: UnregisterWaitEx() failed, dw = %lu", GetLastError());
|
|
}
|
|
}
|
|
if (NULL != ghRichEd20)
|
|
{
|
|
FreeLibrary(ghRichEd20);
|
|
ghRichEd20 = NULL;
|
|
}
|
|
SafeCloseHandleNULL(hClientNotifyEvt);
|
|
|
|
if (!gAUEnvVars.m_fRebootWarningMode)
|
|
{
|
|
//fixcode: is ghMainWindow a valid window here?
|
|
KillTimer(ghMainWindow, 1);
|
|
if (fcsInit)
|
|
{
|
|
DeleteCriticalSection(&gcsClient);
|
|
}
|
|
SafeDeleteNULL(gInternals);
|
|
SafeDeleteNULL(gpClientCatalog);
|
|
SafeCloseHandleNULL(ghEngineState);
|
|
SafeCloseHandleNULL(ghMutex);
|
|
}
|
|
|
|
if ( fCoInit)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
}
|
|
|
|
|
|
int APIENTRY WinMain(HINSTANCE hInstance,
|
|
HINSTANCE /*hPrevInstance*/,
|
|
LPSTR /*lpCmdLine*/,
|
|
int /*nCmdShow*/)
|
|
{
|
|
HANDLE rhEvents[CNUM_EVENTS];
|
|
|
|
//Initialize the global pointing to WU Directory. (the directory should already exist)
|
|
if(!CreateWUDirectory(TRUE))
|
|
{
|
|
//If we can not create WU directory, no point in continuing
|
|
DEBUGMSG("WUAUCLT Fail to create WU directory");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
goto exit;
|
|
}
|
|
|
|
if (!gAUEnvVars.ReadIn())
|
|
{
|
|
DEBUGMSG("WUAUCLT fails to read in environment variables");
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
goto exit;
|
|
}
|
|
|
|
if (gAUEnvVars.m_fRebootWarningMode)
|
|
{
|
|
DEBUGMSG("WUAUCLT starts in reboot warning mode");
|
|
if (!InitializeAUClientForRebootWarning(hInstance, &g_hRegisterWait, &g_hClientNotifyEvt, &g_fCoInit))
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
goto exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("WUAUCLT starts in regular mode");
|
|
if (!InitializeAUClient(hInstance, &g_hRegisterWait, &g_hClientNotifyEvt, &g_fCoInit, &g_fcsInit))
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_FATAL_ERROR);
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
DEBUGMSG("WUAUCLT initialization done");
|
|
// Create the main window hidden
|
|
if (!AURegisterWindowClass(MainWndProc, AU_WINDOW_CLASS_NAME))
|
|
{
|
|
goto exit;
|
|
}
|
|
if (!AURegisterWindowClass(CustomLBWndProc, _T("MYLB")))
|
|
{
|
|
goto exit;
|
|
}
|
|
if (!CreateWindow(AU_WINDOW_CLASS_NAME, AU_WINDOW_CLASS_NAME, WS_CAPTION,
|
|
0, 0, 0, 0, NULL, NULL, hInstance, NULL))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
ShowWindow(ghMainWindow, SW_HIDE);
|
|
|
|
#ifdef TESTUI
|
|
{
|
|
MSG msg;
|
|
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (WM_QUIT == msg.message )
|
|
{
|
|
// Set this event so the service does what every appropriate
|
|
// If we don't do this, we might leave the service waiting for this event for
|
|
// some cases - for example, when the session in which the client leaves is deactivated or
|
|
// when there is a log off
|
|
//SetEvent(ghEngineState);
|
|
goto exit;
|
|
}
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
#else
|
|
{
|
|
// Run the main message loop
|
|
MSG msg;
|
|
|
|
if (gAUEnvVars.m_fRebootWarningMode)
|
|
{
|
|
DWORD dwElapsedTime = (GetTickCount() - gAUEnvVars.m_dwStartTickCount) / 1000;
|
|
ShowRebootWarning(gAUEnvVars.m_fEnableYes, gAUEnvVars.m_fEnableNo, gAUEnvVars.m_fManualReboot, dwElapsedTime);
|
|
}
|
|
else
|
|
{
|
|
SetTimer(ghMainWindow, 1, dwTimeToWait(ReminderTimes[TIMEOUT_INX_FOUR_HOURS].timeout), NULL); //every 4 hours
|
|
|
|
DEBUGMSG("WUAUCLT Processing messages and being alert for Engine state change event");
|
|
|
|
rhEvents[ISTATE_CHANGE] = ghEngineState;
|
|
|
|
while (1)
|
|
{
|
|
DWORD dwRet = MsgWaitForMultipleObjectsEx(CNUM_EVENTS, rhEvents, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE);
|
|
|
|
if (WAIT_OBJECT_0 + ISTATE_CHANGE == dwRet) //ghEngineState (ISTATE_CHANGE)
|
|
{
|
|
DEBUGMSG("WUAUCLT Engine changed state");
|
|
if (!ProcessEngineState())
|
|
{
|
|
QUITAUClient();
|
|
}
|
|
}
|
|
else if (WAIT_OBJECT_0 + IMESSAGE == dwRet) // There is a message to process
|
|
{
|
|
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (g_fAlreadyUninit || WM_QUIT == msg.message)
|
|
{
|
|
goto exit;
|
|
}
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
if (g_fAlreadyUninit)
|
|
{
|
|
goto exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (WAIT_ABANDONED_0 == dwRet) //ghEngineState abandoned
|
|
{
|
|
DEBUGMSG("WUAUCLT quitting because engine state event was abandoned");
|
|
}
|
|
else if (WAIT_FAILED == dwRet) //MsgWaitForMultipleObjectsEx failed
|
|
{
|
|
DEBUGMSG("WUAUCLT quitting because MsgWaitForMultipleObjectsEx() failed with last error = %lu", GetLastError());
|
|
}
|
|
QUITAUClient();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
exit:
|
|
DEBUGMSG("WUAUCLT Exiting");
|
|
|
|
//if installation thread is live, wait until it finishes
|
|
if (NULL != gpClientCatalog)
|
|
{
|
|
gpClientCatalog->m_WrkThread.m_Terminate();
|
|
}
|
|
UninitializeAUClient(g_hRegisterWait, g_hClientNotifyEvt, g_fCoInit, g_fcsInit);
|
|
|
|
if (CDWWUAUCLT_UNSPECIFY == GetClientExitCode())
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_OK);
|
|
}
|
|
DEBUGMSG("WUAUCLT exit code %d", GetClientExitCode());
|
|
ExitProcess(GetClientExitCode());
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
AUSTATE AuState;
|
|
|
|
switch(message)
|
|
{
|
|
case WM_CREATE:
|
|
{
|
|
LOGFONT lFont;
|
|
|
|
// initialize global ui variables
|
|
ghMainWindow = hWnd;
|
|
ghCurrentMainDlg = NULL;
|
|
gNextDialogMsg = NULL;
|
|
ghHeaderFont = NULL;
|
|
|
|
InitTrayIcon();
|
|
|
|
HFONT hDefUIFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
|
|
//create header font
|
|
ZeroMemory(&lFont, sizeof(lFont));
|
|
lFont.lfWeight = FW_BOLD;
|
|
lFont.lfCharSet = DEFAULT_CHARSET;
|
|
lFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
lFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
lFont.lfQuality = DEFAULT_QUALITY;
|
|
lFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
|
|
LoadString(ghInstance, IDS_HEADERFONT, lFont.lfFaceName, ARRAYSIZE(lFont.lfFaceName));
|
|
ghHeaderFont = CreateFontIndirect(&lFont);
|
|
if(ghHeaderFont == NULL) {
|
|
DEBUGMSG("WUAUCLT fail to create Header Font, use default GUI font instead");
|
|
ghHeaderFont = hDefUIFont;
|
|
}
|
|
//create underline font
|
|
ZeroMemory(&lFont, sizeof(lFont));
|
|
GetObject(hDefUIFont, sizeof(lFont), &lFont);
|
|
lFont.lfUnderline = TRUE;
|
|
|
|
ghHook = SetWindowsHookEx(WH_MSGFILTER, AUTranslatorProc, ghInstance, GetCurrentThreadId());
|
|
#ifdef TESTUI
|
|
PostMessage(ghMainWindow, AUMSG_SHOW_WELCOME, 0, 0);
|
|
#else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
case AUMSG_SHOW_WELCOME:
|
|
DEBUGMSG("WUAUCLT Displaying Welcome");
|
|
DialogBox(ghInstance, MAKEINTRESOURCE(IDD_UPDATEFRAME),
|
|
NULL, WizardFrameProc);
|
|
return 0;
|
|
|
|
case AUMSG_SHOW_DOWNLOAD:
|
|
#ifdef TESTUI
|
|
{
|
|
DEBUGMSG("WUAUCLT Displaying Predownload");
|
|
DialogBox(ghInstance, MAKEINTRESOURCE(IDD_DOWNLOAD),
|
|
NULL, DownloadDlgProc);
|
|
return 0;
|
|
}
|
|
#else
|
|
{
|
|
DEBUGMSG("WUAUCLT Displaying Predownload");
|
|
DialogBox(ghInstance, MAKEINTRESOURCE(IDD_DOWNLOAD),
|
|
NULL, DownloadDlgProc);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
case AUMSG_SHOW_INSTALL:
|
|
DEBUGMSG("WUAUCLT Displaying Install");
|
|
DismissUIIfAny();
|
|
DialogBox(ghInstance, MAKEINTRESOURCE(IDD_INSTALLFRAME),
|
|
NULL, InstallDlgProc);
|
|
return 0;
|
|
|
|
case AUMSG_SHOW_INSTALLWARNING:
|
|
DEBUGMSG("WUAUCLT Displaying install warning dialog");
|
|
ShowInstallWarning();
|
|
return 0;
|
|
|
|
case WM_CLOSE:
|
|
DestroyWindow(ghMainWindow);
|
|
return 0;
|
|
|
|
case WM_ENDSESSION:
|
|
DEBUGMSG("WUAUCLT received WM_ENDSESSION (wParam = %#x)", wParam);
|
|
if (wParam)
|
|
{
|
|
//if installation thread is live, wait until it finishes
|
|
if (NULL != gpClientCatalog)
|
|
{
|
|
gpClientCatalog->m_WrkThread.m_Terminate();
|
|
}
|
|
DismissUIIfAny();
|
|
UninitPopupMenus();
|
|
if (NULL != ghHeaderFont)
|
|
{
|
|
DeleteObject(ghHeaderFont);
|
|
}
|
|
UninitializeAUClient(g_hRegisterWait, g_hClientNotifyEvt, g_fCoInit, g_fcsInit);
|
|
|
|
// Even we try to set the client exit code here, but there are cases
|
|
// based on observation (e.g. logging off during reboot warning) that
|
|
// we don't get back to WinMain for clean up after so the exit code gets
|
|
// ignored.
|
|
if (CDWWUAUCLT_UNSPECIFY == GetClientExitCode())
|
|
{
|
|
SetClientExitCode(CDWWUAUCLT_ENDSESSION);
|
|
}
|
|
DEBUGMSG("WUAUCLT exit code %d", GetClientExitCode());
|
|
}
|
|
return 0;
|
|
|
|
case WM_DESTROY:
|
|
if (NULL != ghHeaderFont)
|
|
{
|
|
DeleteObject(ghHeaderFont);
|
|
}
|
|
if(ghCurrentMainDlg != NULL)
|
|
{
|
|
DestroyWindow(ghCurrentMainDlg);
|
|
}
|
|
UninitPopupMenus();
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
|
|
case WM_TIMER:
|
|
#ifdef TESTUI
|
|
return 0;
|
|
#else
|
|
{
|
|
UINT nPercentComplete = 0;
|
|
DWORD dwStatus;
|
|
|
|
if (FAILED(gInternals->m_getServiceState(&AuState)))
|
|
{
|
|
DEBUGMSG("WUAUCLT m_getServiceState failed when WM_TIMER or AuState.fDisconnected, quitting");
|
|
QUITAUClient();
|
|
}
|
|
else
|
|
{
|
|
if (AUSTATE_DETECT_COMPLETE != AuState.dwState
|
|
&& AUSTATE_DOWNLOAD_PENDING != AuState.dwState
|
|
&& AUSTATE_DOWNLOAD_COMPLETE != AuState.dwState
|
|
&& AUSTATE_NOT_CONFIGURED != AuState.dwState)
|
|
{
|
|
return 0;
|
|
}
|
|
if (AUSTATE_DOWNLOAD_PENDING != AuState.dwState ||
|
|
SUCCEEDED(gInternals->m_getDownloadStatus(&nPercentComplete, &dwStatus)) && (DWNLDSTATUS_PAUSED == dwStatus))
|
|
{
|
|
UINT cSess;
|
|
|
|
if ((SUCCEEDED(gInternals->m_AvailableSessions(&cSess)) && cSess > 1) || FCurrentSessionInActive())
|
|
{
|
|
DEBUGMSG("WUAUCLT : After 4 hours, exit client and relaunch it in next available admin session");
|
|
SetClientExitCode(CDWWUAUCLT_RELAUNCHNOW);
|
|
QUITAUClient();
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
case AUMSG_TRAYCALLBACK:
|
|
#ifdef TESTUI
|
|
return 0;
|
|
#else
|
|
switch(lParam)
|
|
{
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_CONTEXTMENU:
|
|
case NIN_BALLOONUSERCLICK:
|
|
DEBUGMSG("TrayIcon Message got %d", lParam);
|
|
if (ghCurrentMenu != NULL)
|
|
{
|
|
// bug 499697
|
|
// Don't show Pause/Resume menu for download if domain policy specifies schedule install
|
|
if (//SUCCEEDED(gInternals->m_getServiceState(&AuState)) &&
|
|
//AUSTATE_DOWNLOAD_PENDING == AuState.dwState &&
|
|
fDisableSelection())
|
|
{
|
|
break;
|
|
}
|
|
|
|
POINT mousePos;
|
|
GetCursorPos(&mousePos);
|
|
SetForegroundWindow(ghMainWindow);
|
|
/*BOOL result =*/ TrackPopupMenu(ghCurrentMenu, 0, mousePos.x, mousePos.y, 0, ghMainWindow, NULL);
|
|
PostMessage(ghMainWindow, WM_NULL, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
EnterCriticalSection(&gcsClient);
|
|
|
|
if(gNextDialogMsg != 0)
|
|
{
|
|
PostMessage(hWnd, gNextDialogMsg, 0, 0);
|
|
gNextDialogMsg = 0;
|
|
// we need to make use of the permission to set foregroundwindow ASAP because
|
|
// SetForegroundWindow() will fail if called later
|
|
if (!SetForegroundWindow(ghMainWindow))
|
|
{
|
|
DEBUGMSG("WUAUCLT: Set main window to foreground FAILED");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetActiveWindow(ghCurrentMainDlg);
|
|
SetForegroundWindow(ghCurrentMainDlg);
|
|
if(ghCurrentDialog != NULL) SetFocus(ghCurrentDialog);
|
|
}
|
|
LeaveCriticalSection(&gcsClient);
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
if (FAILED(gInternals->m_getServiceState(&AuState)))
|
|
{
|
|
//fixcode: shall we quit AU here?
|
|
RemoveTrayIcon();
|
|
break;
|
|
}
|
|
if (AUSTATE_DOWNLOAD_PENDING == AuState.dwState)
|
|
{
|
|
ShowProgress();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
#endif
|
|
|
|
case WM_COMMAND:
|
|
|
|
#ifdef TESTUI
|
|
return 0;
|
|
#else
|
|
// bug 499697
|
|
// Don't process Pause/Resume menu commands
|
|
// if domain policy specifies scheduled install
|
|
// in case the message was generated before
|
|
// current domain policy kicked in.
|
|
if (fDisableSelection())
|
|
{
|
|
return 0;
|
|
}
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_PAUSE:
|
|
DEBUGMSG("WUAUCLT User pausing download");
|
|
if (FAILED(gInternals->m_setDownloadPaused(TRUE)))
|
|
{
|
|
// QUITAUClient(); //let wuaueng to figure out problem and recover
|
|
}
|
|
else
|
|
{
|
|
ghCurrentMenu = ghResumeMenu;
|
|
DEBUGMSG("current menu = resume");
|
|
}
|
|
break;
|
|
|
|
case IDC_RESUME:
|
|
DEBUGMSG("WUAUCLT User resuming download");
|
|
if (FAILED(gInternals->m_setDownloadPaused(FALSE)))
|
|
{
|
|
// QUITAUClient();
|
|
}
|
|
else
|
|
{
|
|
ghCurrentMenu = ghPauseMenu;
|
|
DEBUGMSG("current menu = pause");
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
#endif
|
|
default:
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//client exit code should only be set once with a meaningful value
|
|
void SetClientExitCode(UINT uExitCode)
|
|
{
|
|
if (guExitProcess != CDWWUAUCLT_UNSPECIFY)
|
|
{
|
|
DEBUGMSG("ERROR: WUAUCLT Client exit code should only be set once");
|
|
}
|
|
else
|
|
{
|
|
guExitProcess = uExitCode;
|
|
}
|
|
}
|