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.
428 lines
13 KiB
428 lines
13 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SYSTEM: Windows Update Critical Fix Notification
|
|
//
|
|
// CLASS: N/A
|
|
// MODULE: Connection Detection
|
|
// FILE: cfreg.CPP
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DESC: This class implements all functions needed to access
|
|
// machine registry to get information related to
|
|
// Windows Update Critical Fix Notification feature.
|
|
//
|
|
// AUTHOR: Charles Ma, Windows Update Team
|
|
// DATE: 7/6/1998
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Date Author Description
|
|
// ~~~~ ~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// 7/6/98 Charles Ma Created
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyrights: ©1998 Microsoft ® Corporation
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// No portion of this source code may be reproduced
|
|
// without express written permission of Microsoft Corporation.
|
|
//
|
|
// This source code is proprietary and confidential.
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CriticalFixReg.cpp: implementation of the functions used to
|
|
// handle registry related operations
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
const TCHAR AUREGKEY_HKLM_DOMAIN_POLICY[] = _T("Software\\Policies\\Microsoft\\Windows\\WindowsUpdate\\AU");
|
|
const TCHAR AUREGKEY_HKLM_WINDOWSUPDATE_POLICY[] = _T("Software\\Policies\\Microsoft\\Windows\\WindowsUpdate");
|
|
const TCHAR AUREGKEY_HKLM_IUCONTROL_POLICY[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\IUControl");
|
|
const TCHAR AUREGKEY_HKLM_SYSTEM_WAS_RESTORED[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\Auto Update\\SystemWasRestored");
|
|
const TCHAR AUREGKEY_HKCU_USER_POLICY[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\WindowsUpdate");
|
|
const TCHAR AUREGKEY_HKLM_ADMIN_POLICY[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\Auto Update");
|
|
const TCHAR AUREGVALUE_DISABLE_WINDOWS_UPDATE_ACCESS[] = _T("DisableWindowsUpdateAccess");
|
|
const TCHAR AUREGKEY_REBOOT_REQUIRED[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\Auto Update\\RebootRequired");
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Public Function GetRegStringValue()
|
|
// Read the registry value for a REG_SZ key
|
|
// Input: Name of value
|
|
// Output: Buffer containing the registry value if successful
|
|
// Return: HRESULT flag indicating the success of this function
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetRegStringValue(LPCTSTR lpszValueName, LPTSTR lpszBuffer, int nCharCount, LPCTSTR lpszSubKeyName)
|
|
{
|
|
HKEY hKey;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (lpszValueName == NULL || lpszBuffer == NULL)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
lpszSubKeyName,
|
|
0,
|
|
KEY_READ,
|
|
&hKey) )
|
|
{
|
|
hr = SafeRegQueryStringValueCch(
|
|
hKey,
|
|
lpszValueName,
|
|
lpszBuffer,
|
|
nCharCount,
|
|
NULL,
|
|
NULL);
|
|
RegCloseKey(hKey);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Public Function SetRegStringValue()
|
|
// Set the registry value of timestamp as current system local time
|
|
// Input: name of the value to set. pointer to the time structure to set time. if null,
|
|
// we use current system time.
|
|
// Output: None
|
|
// Return: HRESULT flag indicating the success of this function
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
HRESULT SetRegStringValue(LPCTSTR lpszValueName, LPCTSTR lpszNewValue, LPCTSTR lpszSubKeyName)
|
|
{
|
|
HKEY hKey;
|
|
HRESULT hRet = E_FAIL;
|
|
DWORD dwResult;
|
|
|
|
if (lpszValueName == NULL || lpszNewValue == NULL)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// open the key
|
|
//
|
|
if (RegCreateKeyEx(
|
|
HKEY_LOCAL_MACHINE, // root key
|
|
lpszSubKeyName, // subkey
|
|
0, // reserved
|
|
NULL, // class name
|
|
REG_OPTION_NON_VOLATILE, // option
|
|
KEY_SET_VALUE, // security
|
|
NULL, // security attribute
|
|
&hKey,
|
|
&dwResult) == ERROR_SUCCESS)
|
|
{
|
|
|
|
//
|
|
// set the time to the lasttimestamp value
|
|
//
|
|
hRet = (RegSetValueEx(
|
|
hKey,
|
|
lpszValueName,
|
|
0,
|
|
REG_SZ,
|
|
(const unsigned char *)lpszNewValue,
|
|
(lstrlen(lpszNewValue) + 1) * sizeof(*lpszNewValue)
|
|
) == ERROR_SUCCESS) ? S_OK : E_FAIL;
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return hRet;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Public Function DeleteRegValue()
|
|
// Delete the registry value entry
|
|
// Input: name of the value to entry,
|
|
// Output: None
|
|
// Return: HRESULT flag indicating the success of this function
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
HRESULT DeleteRegValue(LPCTSTR lpszValueName)
|
|
{
|
|
HKEY hKey;
|
|
HRESULT hRet = E_FAIL;
|
|
|
|
if (lpszValueName == NULL)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// open the key
|
|
//
|
|
if (RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE, // root key
|
|
AUREGKEY_HKLM_ADMIN_POLICY, // subkey
|
|
0, // reserved
|
|
KEY_WRITE, // security
|
|
&hKey) == ERROR_SUCCESS)
|
|
{
|
|
|
|
//
|
|
// set the time to the lasttimestamp value
|
|
//
|
|
hRet = (RegDeleteValue(
|
|
hKey,
|
|
lpszValueName
|
|
) == ERROR_SUCCESS) ? S_OK : E_FAIL;
|
|
RegCloseKey(hKey);
|
|
}
|
|
else
|
|
{
|
|
DEBUGMSG("Fail to reg open key with error %d", GetLastError());
|
|
}
|
|
|
|
return hRet;
|
|
|
|
}
|
|
|
|
//=======================================================================
|
|
// GetRegDWordValue
|
|
//=======================================================================
|
|
HRESULT GetRegDWordValue(LPCTSTR lpszValueName, LPDWORD pdwValue, LPCTSTR lpszSubKeyName)
|
|
{
|
|
HKEY hKey;
|
|
int iRet;
|
|
DWORD dwType = REG_DWORD, dwSize = sizeof(DWORD);
|
|
|
|
if (lpszValueName == NULL)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// open critical fix key
|
|
//
|
|
if (RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
lpszSubKeyName,
|
|
0,
|
|
KEY_READ,
|
|
&hKey) == ERROR_SUCCESS)
|
|
{
|
|
|
|
//
|
|
// query the last timestamp value
|
|
//
|
|
iRet = RegQueryValueEx(
|
|
hKey,
|
|
lpszValueName,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)pdwValue,
|
|
&dwSize);
|
|
RegCloseKey(hKey);
|
|
|
|
if (iRet == ERROR_SUCCESS && dwType == REG_DWORD && dwSize == sizeof(DWORD))
|
|
{
|
|
return S_OK;
|
|
}
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Public Function SetRegDWordValue()
|
|
// Set the registry value as a DWORD
|
|
// Input: name of the value to set. value to set
|
|
// Output: None
|
|
// Return: HRESULT flag indicating the success of this function
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
HRESULT SetRegDWordValue(LPCTSTR lpszValueName, DWORD dwValue, DWORD options, LPCTSTR lpszSubKeyName)
|
|
{
|
|
HKEY hKey;
|
|
HRESULT hRet = E_FAIL;
|
|
DWORD dwResult;
|
|
|
|
if (lpszValueName == NULL)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
//
|
|
// open the key
|
|
//
|
|
if (RegCreateKeyEx(
|
|
HKEY_LOCAL_MACHINE, // root key
|
|
lpszSubKeyName, // subkey
|
|
0, // reserved
|
|
NULL, // class name
|
|
options, // option
|
|
KEY_SET_VALUE, // security
|
|
NULL, // security attribute
|
|
&hKey,
|
|
&dwResult) == ERROR_SUCCESS)
|
|
{
|
|
|
|
//
|
|
// set the time to the lasttimestamp value
|
|
//
|
|
hRet = (RegSetValueEx(
|
|
hKey,
|
|
lpszValueName,
|
|
0,
|
|
REG_DWORD,
|
|
(LPBYTE)&dwValue,
|
|
sizeof(DWORD)
|
|
) == ERROR_SUCCESS) ? S_OK : E_FAIL;
|
|
RegCloseKey(hKey);
|
|
}
|
|
return hRet;
|
|
}
|
|
|
|
BOOL fRegKeyCreate(LPCTSTR tszKey, DWORD dwOptions)
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwResult;
|
|
|
|
//
|
|
// open the key
|
|
//
|
|
if ( RegCreateKeyEx(
|
|
HKEY_LOCAL_MACHINE, // root key
|
|
tszKey, // subkey
|
|
0, // reserved
|
|
NULL, // class name
|
|
dwOptions, // option
|
|
KEY_WRITE, // security
|
|
NULL, // security attribute
|
|
&hKey,
|
|
&dwResult) == ERROR_SUCCESS )
|
|
{
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL fRegKeyExists(LPCTSTR tszSubKey, HKEY hRootKey)
|
|
{
|
|
HKEY hKey;
|
|
BOOL fRet = FALSE;
|
|
|
|
if (RegOpenKeyEx(
|
|
// HKEY_LOCAL_MACHINE,
|
|
hRootKey,
|
|
tszSubKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey) == ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hKey);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
DWORD getTimeOut()
|
|
{
|
|
DWORD dwValue = 0;
|
|
GetRegDWordValue(_T("TimeOut"), &dwValue);
|
|
return dwValue;
|
|
}
|
|
|
|
HRESULT setAddedTimeout(DWORD timeout, LPCTSTR strkey)
|
|
{
|
|
HKEY hAUKey;
|
|
SYSTEMTIME tmCurr;
|
|
SYSTEMTIME tmTimeOut;
|
|
TCHAR szCurr[50];
|
|
HRESULT hr = E_FAIL;
|
|
|
|
GetSystemTime(&tmCurr);
|
|
|
|
if (FAILED(TimeAddSeconds(tmCurr, timeout, &tmTimeOut)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE ,
|
|
AUTOUPDATEKEY,
|
|
0, TEXT(""),
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_SET_VALUE,
|
|
NULL,
|
|
&hAUKey,
|
|
NULL) != ERROR_SUCCESS)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (SUCCEEDED(SystemTime2String(tmTimeOut, szCurr, ARRAYSIZE(szCurr))) &&
|
|
RegSetValueEx(hAUKey,
|
|
strkey,
|
|
0, REG_SZ,
|
|
(BYTE *)szCurr,
|
|
sizeof(TCHAR)*(lstrlen(szCurr)+1)) == ERROR_SUCCESS)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
RegCloseKey(hAUKey);
|
|
|
|
return hr;
|
|
}
|
|
HRESULT getAddedTimeout(DWORD *pdwTimeDiff, LPCTSTR strkey)
|
|
{
|
|
HKEY hAUKey;
|
|
LONG lRet;
|
|
TCHAR szTimeBuf[50];
|
|
DWORD dwType = REG_SZ, dwSize = sizeof(szTimeBuf);
|
|
SYSTEMTIME tmCurr, tmReminder;
|
|
|
|
*pdwTimeDiff = 0;
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE ,
|
|
AUTOUPDATEKEY,
|
|
0,
|
|
KEY_READ,
|
|
&hAUKey) != ERROR_SUCCESS)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
lRet = RegQueryValueEx(
|
|
hAUKey,
|
|
strkey,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)szTimeBuf,
|
|
&dwSize);
|
|
|
|
RegCloseKey(hAUKey);
|
|
|
|
if (lRet != ERROR_SUCCESS || dwType != REG_SZ ||
|
|
FAILED(String2SystemTime(szTimeBuf, &tmReminder)))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
GetSystemTime(&tmCurr);
|
|
|
|
*pdwTimeDiff = max (TimeDiff(tmCurr, tmReminder),0);
|
|
return S_OK;
|
|
}
|
|
|
|
|