able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/mobile/syncmgr/dll/invoke.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1432 lines
41 KiB
C++
Raw Blame History

//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1998.
//
// File: Invoke.cpp
//
// Contents: IOfflineSynchronizeInvoke interface
//
// Classes: CSyncMgrSynchronize
//
// Notes:
//
// History: 05-Nov-97 rogerg Created.
//
//--------------------------------------------------------------------------
#include "precomp.h"
int CALLBACK SchedWizardPropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam);
DWORD StartScheduler();
IsFriendlyNameInUse(LPTSTR ptszScheduleGUIDName, LPCTSTR ptstrFriendlyName);
IsScheduleNameInUse(LPTSTR ptszScheduleGUIDName);
extern HINSTANCE g_hmodThisDll;
extern UINT g_cRefThisDll;
extern DWORD g_dwPlatformId;
extern OSVERSIONINFOA g_OSVersionInfo; // osVersionInfo, setup by DLLMain.
//+--------------------------------------------------------------
//
// Class: CSyncMgrSynchronize
//
// FUNCTION: CSyncMgrSynchronize::CSyncMgrSynchronize()
//
// PURPOSE: Constructor
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
CSyncMgrSynchronize::CSyncMgrSynchronize()
{
TRACE("CSyncMgrSynchronize::CSyncMgrSynchronize()\r\n");
m_cRef = 1;
g_cRefThisDll++;
m_pITaskScheduler = NULL;
}
//+--------------------------------------------------------------
//
// Class: CSyncMgrSynchronize
//
// FUNCTION: CSyncMgrSynchronize::~CSyncMgrSynchronize()
//
// PURPOSE: Destructor
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
CSyncMgrSynchronize::~CSyncMgrSynchronize()
{
if (m_pITaskScheduler)
{
m_pITaskScheduler->Release();
}
g_cRefThisDll--;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::QueryInterface(REFIID riid, LPVOID FAR *ppv)
//
// PURPOSE: QI for the CSyncMgrSynchronize
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::QueryInterface(REFIID riid, LPVOID FAR *ppv)
{
*ppv = NULL;
if (IsEqualIID(riid, IID_IUnknown))
{
TRACE("CSyncMgrDllObject::QueryInterface()==>IID_IUknown\r\n");
*ppv = (LPSYNCMGRSYNCHRONIZEINVOKE) this;
}
else if (IsEqualIID(riid, IID_ISyncMgrSynchronizeInvoke))
{
TRACE("CSyncMgrDllObject::QueryInterface()==>IID_IOfflineSynchronizeInvoke\r\n");
*ppv = (LPSYNCMGRSYNCHRONIZEINVOKE) this;
}
else if (IsEqualIID(riid, IID_ISyncMgrRegister))
{
TRACE("CSyncMgrDllObject::QueryInterface()==>IID_ISyncmgrSynchronizeRegister\r\n");
*ppv = (LPSYNCMGRREGISTER) this;
}
else if (IsEqualIID(riid, IID_ISyncMgrRegisterCSC))
{
TRACE("CSyncMgrDllObject::QueryInterface()==>IID_ISyncmgrSynchronizeRegisterCSC\r\n");
*ppv = (LPSYNCMGRREGISTERCSC) this;
}
else if (IsEqualIID(riid, IID_ISyncScheduleMgr))
{
TRACE("CSyncMgrDllObject::QueryInterface()==>IID_ISyncScheduleMgr\r\n");
if (SUCCEEDED(InitializeScheduler()))
{
*ppv = (LPSYNCSCHEDULEMGR) this;
}
}
if (*ppv)
{
AddRef();
return NOERROR;
}
TRACE("CSyncMgrDllObject::QueryInterface()==>Unknown Interface!\r\n");
return E_NOINTERFACE;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::AddRef()
//
// PURPOSE: Addref the CSyncMgrSynchronize
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CSyncMgrSynchronize::AddRef()
{
TRACE("CSyncMgrSynchronize::AddRef()\r\n");
return ++m_cRef;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::Release()
//
// PURPOSE: Release the CSyncMgrSynchronize
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CSyncMgrSynchronize::Release()
{
TRACE("CSyncMgrSynchronize::Release()\r\n");
if (--m_cRef)
return m_cRef;
delete this;
return 0L;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::UpdateItems(DWORD dwInvokeFlags,
// REFCLSID rclsid,DWORD cbCookie,const BYTE *lpCookie)
//
// PURPOSE:
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
#define SYNCMGRINVOKEFLAGS_MASK (SYNCMGRINVOKE_STARTSYNC | SYNCMGRINVOKE_MINIMIZED)
STDMETHODIMP CSyncMgrSynchronize::UpdateItems(DWORD dwInvokeFlags,
REFCLSID rclsid,DWORD cbCookie,const BYTE *lpCookie)
{
HRESULT hr = E_UNEXPECTED;
LPUNKNOWN lpUnk;
// verify invoke flags are valid
if (0 != (dwInvokeFlags & ~(SYNCMGRINVOKEFLAGS_MASK)) )
{
AssertSz(0,"Invalid InvokeFlags passed to UpdateItems");
return E_INVALIDARG;
}
hr = CoCreateInstance(CLSID_SyncMgrp,NULL,CLSCTX_ALL,IID_IUnknown,(void **) &lpUnk);
if (NOERROR == hr)
{
LPPRIVSYNCMGRSYNCHRONIZEINVOKE pSynchInvoke = NULL;
hr = lpUnk->QueryInterface(IID_IPrivSyncMgrSynchronizeInvoke,
(void **) &pSynchInvoke);
if (NOERROR == hr)
{
AllowSetForegroundWindow(ASFW_ANY); // let mobsync.exe come to front if necessary
hr = pSynchInvoke->UpdateItems(dwInvokeFlags,rclsid,cbCookie,lpCookie);
pSynchInvoke->Release();
}
lpUnk->Release();
}
return hr; // review error code
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::UpdateAll()
//
// PURPOSE:
//
// History: 27-Feb-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::UpdateAll()
{
HRESULT hr;
LPUNKNOWN lpUnk;
// programmatically pull up the choice dialog.
hr = CoCreateInstance(CLSID_SyncMgrp,NULL,CLSCTX_ALL,IID_IUnknown,(void **) &lpUnk);
if (NOERROR == hr)
{
LPPRIVSYNCMGRSYNCHRONIZEINVOKE pSynchInvoke = NULL;
hr = lpUnk->QueryInterface(IID_IPrivSyncMgrSynchronizeInvoke,
(void **) &pSynchInvoke);
if (NOERROR == hr)
{
AllowSetForegroundWindow(ASFW_ANY); // let mobsync.exe come to front if necessary
pSynchInvoke->UpdateAll();
pSynchInvoke->Release();
}
lpUnk->Release();
}
return NOERROR; // review error code
}
// Registration implementation
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::RegisterSyncMgrHandler(REFCLSID rclsidHandler,DWORD dwReserved)
//
// PURPOSE: Programmatic way of registering handlers
//
// History: 17-Mar-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::RegisterSyncMgrHandler(REFCLSID rclsidHandler,
WCHAR const * pwszDescription,
DWORD dwSyncMgrRegisterFlags)
{
if (0 != (dwSyncMgrRegisterFlags & ~(SYNCMGRREGISTERFLAGS_MASK)) )
{
AssertSz(0,"Invalid Registration Flags");
return E_INVALIDARG;
}
if (pwszDescription)
{
if (IsBadStringPtr(pwszDescription,-1))
{
AssertSz(0,"Invalid Registration Description");
return E_INVALIDARG;
}
}
BOOL fFirstRegistration = FALSE;
HRESULT hr = E_FAIL;
// on Win9x and NT 4.0 Logoff is not supported so get rid of this flag
// so don't have to worry about the upgrade case or if flag manages
// to get set but doesn't showup in UI
//!!! warning, if you change platform logic must also change
// logic for showing logoff checbox in settings dialog
if ( (VER_PLATFORM_WIN32_WINDOWS == g_OSVersionInfo.dwPlatformId)
|| (VER_PLATFORM_WIN32_NT == g_OSVersionInfo.dwPlatformId
&& g_OSVersionInfo.dwMajorVersion < 5) )
{
dwSyncMgrRegisterFlags &= ~(SYNCMGRREGISTERFLAG_PENDINGDISCONNECT);
}
// Add the Handler to the the list
if ( RegRegisterHandler(rclsidHandler, pwszDescription,dwSyncMgrRegisterFlags, &fFirstRegistration) )
{
hr = S_OK;
}
return hr;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::RegisterSyncMgrHandler(REFCLSID rclsidHandler,DWORD dwReserved)
//
// PURPOSE: Programmatic way of registering handlers
//
// History: 17-Mar-98 rogerg Created.
//
//--------------------------------------------------------------------------------
// methods here to support the old IDL since it is no
// longer called it could be removed.
STDMETHODIMP CSyncMgrSynchronize::RegisterSyncMgrHandler(REFCLSID rclsidHandler,
DWORD dwReserved)
{
HRESULT hr = RegisterSyncMgrHandler( rclsidHandler, 0, dwReserved );
return hr;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::UnregisterSyncMgrHandler(REFCLSID rclsidHandler)
//
// PURPOSE: Programmatic way of unregistering handlers
//
// History: 17-Mar-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::UnregisterSyncMgrHandler(REFCLSID rclsidHandler,DWORD dwReserved)
{
if (dwReserved)
{
Assert(0 == dwReserved);
return E_INVALIDARG;
}
HRESULT hr = E_FAIL;
if (RegRegRemoveHandler(rclsidHandler))
{
hr = NOERROR;
}
return hr;
}
//--------------------------------------------------------------------------------
//
// member: CSyncMgrSynchronize::GetHandlerRegistrationInfo(REFCLSID rclsidHandler)
//
// PURPOSE: Allows Handler to query its registration Status.
//
// History: 17-Mar-98 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::GetHandlerRegistrationInfo(REFCLSID rclsidHandler,LPDWORD pdwSyncMgrRegisterFlags)
{
HRESULT hr = S_FALSE; // review what should be returned if handler not registered
if (NULL == pdwSyncMgrRegisterFlags)
{
Assert(pdwSyncMgrRegisterFlags);
return E_INVALIDARG;
}
*pdwSyncMgrRegisterFlags = 0;
if (RegGetHandlerRegistrationInfo(rclsidHandler,pdwSyncMgrRegisterFlags))
{
hr = S_OK;
}
return hr;
}
//--------------------------------------------------------------------------------
//
// member: CSyncMgrSynchronize::GetUserRegisterFlags
//
// PURPOSE: Returns current Registry Flags for the User.
//
// History: 17-Mar-99 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize:: GetUserRegisterFlags(LPDWORD pdwSyncMgrRegisterFlags)
{
if (NULL == pdwSyncMgrRegisterFlags)
{
Assert(pdwSyncMgrRegisterFlags);
return E_INVALIDARG;
}
return RegGetUserRegisterFlags(pdwSyncMgrRegisterFlags);
}
//--------------------------------------------------------------------------------
//
// member: CSyncMgrSynchronize::SetUserRegisterFlags
//
// PURPOSE: Sets registry flags for the User.
//
// History: 17-Mar-99 rogerg Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize:: SetUserRegisterFlags(DWORD dwSyncMgrRegisterMask,
DWORD dwSyncMgrRegisterFlags)
{
if (0 != (dwSyncMgrRegisterMask & ~(SYNCMGRREGISTERFLAGS_MASK)) )
{
AssertSz(0,"Invalid Registration Mask");
return E_INVALIDARG;
}
RegSetUserAutoSyncDefaults(dwSyncMgrRegisterMask,dwSyncMgrRegisterFlags);
RegSetUserIdleSyncDefaults(dwSyncMgrRegisterMask,dwSyncMgrRegisterFlags);
return NOERROR;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::CreateSchedule(
// LPCWSTR pwszScheduleName,
// DWORD dwFlags,
// SYNCSCHEDULECOOKIE *pSyncSchedCookie,
// ISyncSchedule **ppSyncSchedule)
//
// PURPOSE: Create a new Sync Schedule
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::CreateSchedule(
LPCWSTR pwszScheduleName,
DWORD dwFlags,
SYNCSCHEDULECOOKIE *pSyncSchedCookie,
ISyncSchedule **ppSyncSchedule)
{
SCODE sc;
TCHAR ptszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
TCHAR ptstrFriendlyName[MAX_PATH + 1];
WCHAR pwszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
ITask *pITask;
Assert(m_pITaskScheduler);
if ((!pSyncSchedCookie) || (!ppSyncSchedule) || (!pwszScheduleName))
{
return E_INVALIDARG;
}
*ppSyncSchedule = NULL;
if (*pSyncSchedCookie == GUID_NULL)
{
sc = CoCreateGuid(pSyncSchedCookie);
if (FAILED(sc))
{
return sc;
}
}
if (FAILED (sc = MakeScheduleName(ptszScheduleGUIDName, pSyncSchedCookie)))
{
return sc;
}
ConvertString(pwszScheduleGUIDName,ptszScheduleGUIDName,MAX_SCHEDULENAMESIZE);
//if the schedule name is empty, generate a new unique one
if (!lstrcmp(pwszScheduleName,L""))
{
//this function is the energizer bunny, going and going until success....
GenerateUniqueName(ptszScheduleGUIDName, ptstrFriendlyName);
}
else
{
ConvertString(ptstrFriendlyName,(WCHAR *)pwszScheduleName, MAX_PATH);
}
HRESULT hrFiendlyNameInUse = NOERROR;
HRESULT hrActivate = NOERROR;
//see if this friendly name is already in use by one of this user's schedules
//if it is, ptszScheduleGUIDName will be filled in with the offending Schedules GUID
if (IsFriendlyNameInUse(ptszScheduleGUIDName, ptstrFriendlyName))
{
// update the scheduleguidName with the one we found.d
ConvertString(pwszScheduleGUIDName,ptszScheduleGUIDName,MAX_SCHEDULENAMESIZE);
hrFiendlyNameInUse = SYNCMGR_E_NAME_IN_USE;
}
// if we think it is in use try to activate to make sure.
if (SUCCEEDED(hrActivate = m_pITaskScheduler->Activate(pwszScheduleGUIDName,
IID_ITask,
(IUnknown **)&pITask)))
{
pITask->Release();
//ok, we have the .job but not the reg entry.
//delete the turd job file.
if (!IsScheduleNameInUse(ptszScheduleGUIDName))
{
if (ERROR_SUCCESS != m_pITaskScheduler->Delete(pwszScheduleGUIDName))
{
//Try to force delete of the .job file
wcscat(ptszScheduleGUIDName, L".job");
RemoveScheduledJobFile(ptszScheduleGUIDName);
//trunctate off the .job we just added
pwszScheduleGUIDName[wcslen(ptszScheduleGUIDName) -4] = L'\0';
}
hrActivate = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}
}
// if activate failed but we think there is a friendly name in use
// then update the regkey and return the appropriate info
// if already one or our schedules return SYNCMGR_E_NAME_IN_USE, if
// schedule name is being used by someone else return ERROR_ALREADY_EXISTS
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hrActivate)
{
// file not found update regValues and continue to create
RegRemoveScheduledTask(pwszScheduleGUIDName);
sc = NOERROR;
}
else if (NOERROR != hrFiendlyNameInUse)
{
// fill in the out param with the cookie of schedule
// that already exists.
// !!!! warning, alters pwszScheduleGUIDName so
// if don't just return here would have to make a tempvar.
pwszScheduleGUIDName[GUIDSTR_MAX] = NULL;
GUIDFromString(pwszScheduleGUIDName, pSyncSchedCookie);
return SYNCMGR_E_NAME_IN_USE;
}
else if (SUCCEEDED(hrActivate))
{
return HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
}
// Create an in-memory task object.
if (FAILED(sc = m_pITaskScheduler->NewWorkItem(
pwszScheduleGUIDName,
CLSID_CTask,
IID_ITask,
(IUnknown **)&pITask)))
{
return sc;
}
// Make sure the task scheduler service is started
if (FAILED(sc = StartScheduler()))
{
return sc;
}
*ppSyncSchedule = new CSyncSchedule(pITask,ptszScheduleGUIDName,ptstrFriendlyName);
if (NULL == *ppSyncSchedule)
{
return E_OUTOFMEMORY;
}
if (FAILED(sc = ((LPSYNCSCHEDULE)(*ppSyncSchedule))->Initialize()))
{
(*ppSyncSchedule)->Release();
pITask->Release();
*ppSyncSchedule = NULL;
return sc;
}
//NT Only, on win9x, don't set credentials
if (g_dwPlatformId == VER_PLATFORM_WIN32_NT)
{
if (FAILED(sc = ((LPSYNCSCHEDULE)(*ppSyncSchedule))->SetDefaultCredentials()))
{
(*ppSyncSchedule)->Release();
pITask->Release();
*ppSyncSchedule = NULL;
return sc;
}
}
if (FAILED(sc = (*ppSyncSchedule)->SetFlags(dwFlags & SYNCSCHEDINFO_FLAGS_MASK)))
{
(*ppSyncSchedule)->Release();
pITask->Release();
*ppSyncSchedule = NULL;
return sc;
}
pITask->Release();
return sc;
}
//+-------------------------------------------------------------------------------
//
// FUNCTION: CALLBACK SchedWizardPropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam);
//
// PURPOSE: Callback dialog init procedure the settings property dialog
//
// PARAMETERS:
// hwndDlg - Dialog box window handle
// uMsg - current message
// lParam - depends on message
//
//--------------------------------------------------------------------------------
int CALLBACK SchedWizardPropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam)
{
switch(uMsg)
{
case PSCB_INITIALIZED:
{
// Load the bitmap depends on color mode
Load256ColorBitmap();
}
break;
default:
return FALSE;
}
return TRUE;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::LaunchScheduleWizard(
// HWND hParent,
// DWORD dwFlags,
// SYNCSCHEDULECOOKIE *pSyncSchedCookie,
// ISyncSchedule ** ppSyncSchedule)
//
// PURPOSE: Launch the SyncSchedule Creation wizard
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::LaunchScheduleWizard(
HWND hParent,
DWORD dwFlags,
SYNCSCHEDULECOOKIE *pSyncSchedCookie,
ISyncSchedule ** ppSyncSchedule)
{
SCODE sc;
BOOL fSaved;
DWORD dwSize = MAX_PATH;
ISyncSchedule *pNewSyncSchedule;
DWORD cRefs;
if (!ppSyncSchedule)
{
Assert(ppSyncSchedule);
return E_INVALIDARG;
}
*ppSyncSchedule = NULL;
if (*pSyncSchedCookie == GUID_NULL)
{
if (FAILED(sc = CreateSchedule(L"", dwFlags, pSyncSchedCookie,
&pNewSyncSchedule)))
{
return sc;
}
}
else
{
//Open the schedule passed in
if (FAILED(sc = OpenSchedule(pSyncSchedCookie,
0,
&pNewSyncSchedule)))
{
return sc;
}
}
#ifdef _WIZ97FONTS
//
// Create the bold fonts.
//
SetupFonts( g_hmodThisDll, NULL);
#endif // _WIZ97FONTS
HPROPSHEETPAGE psp [NUM_TASK_WIZARD_PAGES];
PROPSHEETHEADERA psh;
memset(psp,0,sizeof(psp));
#ifdef _WIZ97FONTS
//Welcome Page needs the bold font from this object
m_apWizPages[0] = new CWelcomePage(g_hmodThisDll, m_hBoldFont,pNewSyncSchedule, &psp[0]);
#else
m_apWizPages[0] = new CWelcomePage(g_hmodThisDll,pNewSyncSchedule, &psp[0]);
#endif // _WIZ97FONTS
m_apWizPages[1] = new CSelectItemsPage(g_hmodThisDll, &fSaved, pNewSyncSchedule, &psp[1],
IDD_SCHEDWIZ_CONNECTION);
m_apWizPages[2] = new CSelectDailyPage(g_hmodThisDll, pNewSyncSchedule, &psp[2]);
m_apWizPages[3] = new CNameItPage(g_hmodThisDll, pNewSyncSchedule, &psp[3]);
m_apWizPages[4] = new CFinishPage(g_hmodThisDll, pNewSyncSchedule, &psp[4]);
// Check that all objects and pages could be created
int i;
for (i = 0; i < NUM_TASK_WIZARD_PAGES; i++)
{
if (!m_apWizPages[i] || !psp[i])
{
sc = E_OUTOFMEMORY;
}
}
// Manually destroy the pages if one could not be created, then exit
if (FAILED(sc))
{
for (i = 0; i < NUM_TASK_WIZARD_PAGES; i++)
{
if (psp[i])
{
DestroyPropertySheetPage(psp[i]);
}
else if (m_apWizPages[i])
{
delete m_apWizPages[i];
}
}
pNewSyncSchedule->Release();
return sc;
}
// All pages created, display the wizard
ZeroMemory(&psh, sizeof(PROPSHEETHEADERA));
psh.dwSize = sizeof (PROPSHEETHEADERA);
psh.dwFlags = PSH_WIZARD;
psh.hwndParent = hParent;
psh.hInstance = g_hmodThisDll;
psh.pszIcon = NULL;
psh.phpage = psp;
psh.nPages = NUM_TASK_WIZARD_PAGES;
psh.pfnCallback = SchedWizardPropSheetProc;
psh.nStartPage = 0;
if (-1 == PropertySheetA(&psh))
{
sc = E_UNEXPECTED;
}
for (i = 0; i < NUM_TASK_WIZARD_PAGES; i++)
{
delete m_apWizPages[i];
}
#ifdef _WIZ97FONTS
//
// Destroy the fonts that were created.
//
DestroyFonts();
#endif // _WIZ97FONTS
if (SUCCEEDED(sc))
{
if (fSaved)
{
*ppSyncSchedule = pNewSyncSchedule;
(*ppSyncSchedule)->AddRef();
sc = NOERROR;
}
else
{
sc = S_FALSE;
}
}
cRefs = pNewSyncSchedule->Release();
Assert( (NOERROR == sc) || (0 == cRefs && NULL == *ppSyncSchedule));
return sc;
}
//+-------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::SetupFonts(HINSTANCE hInstance, HWND hwnd)
//
// PURPOSE: Setup the bold fonts
//
//--------------------------------------------------------------------------------
#ifdef _WIZ97FONTS
VOID CSyncMgrSynchronize::SetupFonts(HINSTANCE hInstance, HWND hwnd )
{
//
// Create the fonts we need based on the dialog font
//
NONCLIENTMETRICS ncm = {0};
ncm.cbSize = sizeof(ncm);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
LOGFONT BigBoldLogFont = ncm.lfMessageFont;
LOGFONT BoldLogFont = ncm.lfMessageFont;
//
// Create Big Bold Font and Bold Font
//
BigBoldLogFont.lfWeight = FW_BOLD;
BoldLogFont.lfWeight = FW_BOLD;
TCHAR FontSizeString[MAX_PATH];
INT FontSize;
//
// Load size and name from resources, since these may change
// from locale to locale based on the size of the system font, etc.
//
if(!LoadString(hInstance,IDS_LARGEFONTNAME,BigBoldLogFont.lfFaceName,LF_FACESIZE))
{
text to cause a complile error so you read the following comment when this code
is turned on.
// on FE Win9x Shell Dialog doesn't map properly, need to
// use GUI_FONT. Should also review why loading a different font from the
// resource and/or wizard97 predefines some fonts in the system
lstrcpy(BigBoldLogFont.lfFaceName,TEXT("MS Shell Dlg"));
}
if(LoadString(hInstance,IDS_LARGEFONTSIZE,FontSizeString,sizeof(FontSizeString)/sizeof(TCHAR)))
{
FontSize = _tcstoul( FontSizeString, NULL, 10 );
}
else
{
FontSize = 12;
}
HDC hdc = GetDC( hwnd );
if( hdc )
{
BigBoldLogFont.lfHeight = 0 - (GetDeviceCaps(hdc,LOGPIXELSY) * FontSize / 72);
m_hBigBoldFont = CreateFontIndirect(&BigBoldLogFont);
m_hBoldFont = CreateFontIndirect(&BoldLogFont);
ReleaseDC(hwnd,hdc);
}
}
#endif // _WIZ97FONTS
//+-------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::DestroyFonts()
//
// PURPOSE: Destroy the bold fonts
//
//--------------------------------------------------------------------------------
#ifdef _WIZ97FONTS
VOID CSyncMgrSynchronize::DestroyFonts()
{
if( m_hBigBoldFont )
{
DeleteObject( m_hBigBoldFont );
}
if( m_hBoldFont )
{
DeleteObject( m_hBoldFont );
}
}
#endif // _WIZ97FONTS
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::OpenSchedule(
// SYNCSCHEDULECOOKIE *pSyncSchedCookie,
// DWORD dwFlags,
// ISyncSchedule **ppSyncSchedule)
//
// PURPOSE: Open an existing sync schedule
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::OpenSchedule(
SYNCSCHEDULECOOKIE *pSyncSchedCookie,
DWORD dwFlags,
ISyncSchedule **ppSyncSchedule)
{
SCODE sc;
TCHAR ptszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
#ifndef _UNICODE
WCHAR pwszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
#else
WCHAR *pwszScheduleGUIDName;
#endif // _UNICODE
TCHAR ptstrFriendlyName[MAX_PATH + 1];
ITask *pITask;
Assert(m_pITaskScheduler);
if ((!pSyncSchedCookie) || (!ppSyncSchedule) )
{
return E_INVALIDARG;
}
*ppSyncSchedule = NULL;
if (FAILED (sc = MakeScheduleName(ptszScheduleGUIDName, pSyncSchedCookie)))
{
return sc;
}
#ifndef _UNICODE
ConvertString(pwszScheduleGUIDName,ptszScheduleGUIDName,MAX_SCHEDULENAMESIZE);
#else
pwszScheduleGUIDName = ptszScheduleGUIDName;
#endif // _UNICODE
//See if we can find the friendly name in the registry
if (!RegGetSchedFriendlyName(ptszScheduleGUIDName,ptstrFriendlyName))
{
//if we can't find the registry entry,
//try to remove any possible turd .job file.
if (FAILED(sc = m_pITaskScheduler->Delete(pwszScheduleGUIDName)))
{
wcscat(pwszScheduleGUIDName, L".job");
RemoveScheduledJobFile(pwszScheduleGUIDName);
}
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}
//Try to activate the schedule
if (FAILED(sc = m_pITaskScheduler->Activate(pwszScheduleGUIDName,
IID_ITask,
(IUnknown **)&pITask)))
{
// if file not found then update reg info
if (sc == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
{
RegRemoveScheduledTask(pwszScheduleGUIDName);
}
return sc;
}
// Make sure the task scheduler service is started
if (FAILED(sc = StartScheduler()))
{
return sc;
}
*ppSyncSchedule = new CSyncSchedule(pITask,ptszScheduleGUIDName, ptstrFriendlyName);
if (!(*ppSyncSchedule) ||
FAILED(sc = ((LPSYNCSCHEDULE)(*ppSyncSchedule))->Initialize()))
{
if (*ppSyncSchedule)
{
(*ppSyncSchedule)->Release();
}
else
{
sc = E_OUTOFMEMORY;
}
pITask->Release();
*ppSyncSchedule = NULL;
return sc;
}
pITask->Release();
return sc;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::RemoveSchedule(
// SYNCSCHEDULECOOKIE *pSyncSchedCookie)
//
// PURPOSE: Remove a sync schedule
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::RemoveSchedule(
SYNCSCHEDULECOOKIE *pSyncSchedCookie)
{
SCODE sc = S_OK,
sc2 = S_OK;
//add 4 to ensure we have room for the .job if necessary
TCHAR ptszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
#ifndef _UNICODE
WCHAR pwszScheduleGUIDName[MAX_SCHEDULENAMESIZE + 4];
#else
WCHAR *pwszScheduleGUIDName = NULL;
#endif // _UNICODE
Assert(m_pITaskScheduler);
if (!pSyncSchedCookie)
{
return E_INVALIDARG;
}
if (FAILED (sc = MakeScheduleName(ptszScheduleGUIDName, pSyncSchedCookie)))
{
return sc;
}
#ifndef _UNICODE
ConvertString(pwszScheduleGUIDName,ptszScheduleGUIDName,MAX_SCHEDULENAMESIZE);
#else
pwszScheduleGUIDName = ptszScheduleGUIDName;
#endif // _UNICODE
//Try to remove the schedule
if (ERROR_SUCCESS != (sc2 = m_pITaskScheduler->Delete(pwszScheduleGUIDName)))
{
//Try to force delete of the .job file
wcscat(pwszScheduleGUIDName, L".job");
RemoveScheduledJobFile(pwszScheduleGUIDName);
//trunctate off the .job we just added
pwszScheduleGUIDName[wcslen(pwszScheduleGUIDName) -4] = L'\0';
}
//Remove our Registry settings for this schedule
//Garbage collection, don't propogate error here
RegRemoveScheduledTask(ptszScheduleGUIDName);
//If We just transitioned from one schedule to none, unregister now.
HKEY hkeySchedSync,
hKeyUser;
DWORD cb = MAX_PATH;
TCHAR pszDomainAndUser[MAX_DOMANDANDMACHINENAMESIZE];
TCHAR pszSchedName[MAX_PATH + 1];
hkeySchedSync = RegGetSyncTypeKey(SYNCTYPE_SCHEDULED,KEY_WRITE | KEY_READ,FALSE);
if (hkeySchedSync)
{
hKeyUser = RegOpenUserKey(hkeySchedSync,KEY_WRITE | KEY_READ,FALSE,FALSE);
if (hKeyUser)
{
BOOL fRemove = FALSE;
//if there are no more scedules for this user, remove the user key.
//Garbage collection, propogate ITaskScheduler->Delete error code in favor of this error.
if (ERROR_NO_MORE_ITEMS == RegEnumKeyEx(hKeyUser,0,
pszSchedName,&cb,NULL,NULL,NULL,NULL))
{
fRemove = TRUE;
}
RegCloseKey(hKeyUser);
if (fRemove)
{
GetDefaultDomainAndUserName(pszDomainAndUser,TEXT("_"),MAX_DOMANDANDMACHINENAMESIZE);
RegDeleteKey(hkeySchedSync, pszDomainAndUser);
}
}
cb = MAX_DOMANDANDMACHINENAMESIZE;
//if there are no more user schedule keys, then no schedules, and unregister
//Garbage collection, propogate ITaskScheduler->Delete error code in favor of this error.
if ( ERROR_SUCCESS != (sc = RegEnumKeyEx(hkeySchedSync,0,
pszDomainAndUser,&cb,NULL,NULL,NULL,NULL)) )
{
RegRegisterForScheduledTasks(FALSE);
}
RegCloseKey(hkeySchedSync);
}
//propogate the error code from the
//task scheduler->Delete if no other errors occurred
return sc2;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CSyncMgrSynchronize::EnumSyncSchedules(
// IEnumSyncSchedules **ppEnumSyncSchedules)
//
// PURPOSE: Enumerate the sync schedules
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
STDMETHODIMP CSyncMgrSynchronize::EnumSyncSchedules(
IEnumSyncSchedules **ppEnumSyncSchedules)
{
SCODE sc;
IEnumWorkItems *pEnumWorkItems;
Assert(m_pITaskScheduler);
if (!ppEnumSyncSchedules)
{
return E_INVALIDARG;
}
if (FAILED(sc = m_pITaskScheduler->Enum(&pEnumWorkItems)))
{
return sc;
}
*ppEnumSyncSchedules = new CEnumSyncSchedules(pEnumWorkItems, m_pITaskScheduler);
pEnumWorkItems->Release();
if (*ppEnumSyncSchedules)
{
return sc;
}
return E_OUTOFMEMORY;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CCSyncMgrSynchronize::InitializeScheduler()
//
// PURPOSE: Initialize the schedule service
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
SCODE CSyncMgrSynchronize::InitializeScheduler()
{
SCODE sc;
if (m_pITaskScheduler)
{
return S_OK;
}
// Obtain a task scheduler class instance.
//
sc = CoCreateInstance(
CLSID_CTaskScheduler,
NULL,
CLSCTX_INPROC_SERVER,
IID_ITaskScheduler,
(VOID **)&m_pITaskScheduler);
if(FAILED(sc))
{
m_pITaskScheduler = NULL;
}
return sc;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CCSyncMgrSynchronize::MakeScheduleName(LPTSTR ptstrName, GUID *pCookie)
//
// PURPOSE: Create the schedule name from the user, domain and GUID
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
SCODE CSyncMgrSynchronize::MakeScheduleName(LPTSTR ptstrName, GUID *pCookie)
{
SCODE sc = E_UNEXPECTED;
WCHAR wszCookie[GUID_SIZE+1];
if (*pCookie == GUID_NULL)
{
if (FAILED(sc = CoCreateGuid(pCookie)))
{
return sc;
}
}
if (StringFromGUID2(*pCookie, wszCookie, GUID_SIZE))
{
lstrcpy(ptstrName, wszCookie);
lstrcat(ptstrName, TEXT("_"));
GetDefaultDomainAndUserName(ptstrName + GUIDSTR_MAX+1,TEXT("_"),MAX_DOMANDANDMACHINENAMESIZE);
sc = S_OK;
}
return sc;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: IsFriendlyNameInUse(LPCTSTR ptszScheduleGUIDName, LPCTSTR ptstrFriendlyName)
//
// PURPOSE: See if the friendly name is already in use by this user.
//
// History: 27-Feb-98 susia Created.
//
//--------------------------------------------------------------------------------
BOOL IsFriendlyNameInUse(LPTSTR ptszScheduleGUIDName,
LPCTSTR ptstrFriendlyName)
{
SCODE sc;
HKEY hKeyUser;
HKEY hkeySchedName;
DWORD dwType = REG_SZ;
DWORD dwDataSize = MAX_PATH * sizeof(TCHAR);
int i = 0;
TCHAR ptstrName[MAX_PATH + 1];
TCHAR ptstrNewName[MAX_PATH + 1];
hKeyUser = RegGetCurrentUserKey(SYNCTYPE_SCHEDULED,KEY_READ,FALSE);
if (NULL == hKeyUser)
{
return FALSE;
}
while (S_OK == (sc = RegEnumKey( hKeyUser, i++, ptstrName,MAX_PATH)))
{
dwDataSize = MAX_PATH * sizeof(TCHAR);
if (ERROR_SUCCESS != (sc = RegOpenKeyEx (hKeyUser, ptstrName, 0,KEY_READ,
&hkeySchedName)))
{
RegCloseKey(hKeyUser);
return FALSE;
}
sc = RegQueryValueEx(hkeySchedName,TEXT("FriendlyName"),NULL, &dwType,
(LPBYTE) ptstrNewName, &dwDataSize);
if (0 == lstrcmp(ptstrNewName,ptstrFriendlyName))
{
lstrcpy(ptszScheduleGUIDName,ptstrName);
RegCloseKey(hkeySchedName);
RegCloseKey(hKeyUser);
return TRUE;
}
RegCloseKey(hkeySchedName);
}
RegCloseKey(hKeyUser);
return FALSE;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: IsScheduleNameInUse(LPCTSTR ptszScheduleGUIDName)
//
// PURPOSE: See if the schedule name is already in use by this user.
//
// History: 12-Dec-98 susia Created.
//
//--------------------------------------------------------------------------------
BOOL IsScheduleNameInUse(LPTSTR ptszScheduleGUIDName)
{
HKEY hKeyUser;
HKEY hkeySchedName;
hKeyUser = RegGetCurrentUserKey(SYNCTYPE_SCHEDULED,KEY_READ,FALSE);
if (NULL == hKeyUser)
{
return FALSE;
}
if (ERROR_SUCCESS == RegOpenKeyEx(hKeyUser,ptszScheduleGUIDName,0,KEY_READ,
&hkeySchedName))
{
RegCloseKey(hKeyUser);
RegCloseKey(hkeySchedName);
return TRUE;
}
RegCloseKey(hKeyUser);
return FALSE;
}
//--------------------------------------------------------------------------------
//
// FUNCTION: CCSyncMgrSynchronize::GenerateUniqueName(LPCTSTR ptszScheduleGUIDName,
// LPWSTR pwszFriendlyName)
//
// PURPOSE: Generate a default schedule name.
//
// History: 14-Mar-98 susia Created.
//
//--------------------------------------------------------------------------------
#define MAX_APPEND_STRING_LEN 32
BOOL CSyncMgrSynchronize::GenerateUniqueName(LPTSTR ptszScheduleGUIDName,
LPTSTR ptszFriendlyName)
{
TCHAR *ptszBuf;
TCHAR *ptszBufConvert = NULL;
TCHAR ptszGUIDName[MAX_PATH + 1];
#define MAX_NAMEID 0xffff
//copy this over because we don't want the check to overwrite the GUID name
lstrcpy(ptszGUIDName,ptszScheduleGUIDName);
if (0 == LoadString(g_hmodThisDll,IDS_SYNCMGRSCHED_DEFAULTNAME,ptszFriendlyName,MAX_PATH))
{
*ptszFriendlyName = NULL;
ptszBuf = ptszFriendlyName;
}
else
{
// set up buf to point to proper strings.
ptszBuf = ptszFriendlyName + lstrlen(ptszFriendlyName);
}
BOOL fMatchFound = FALSE;
int i=0;
do
{
if (IsFriendlyNameInUse(ptszGUIDName,ptszFriendlyName))
{
// if don't find match adjust buf and setup convert pointer
ptszBuf[0] = TEXT(' ');
ptszBufConvert = ptszBuf + 1;
fMatchFound = TRUE;
++i;
#ifndef _UNICODE
_itoa( i, ptszBufConvert, 10 );
#else
_itow( i, ptszBufConvert, 10 );
#endif // _UNICODE
Assert(i < 100);
}
else
{
fMatchFound = FALSE;
}
}while (fMatchFound && (i < MAX_NAMEID));
if (MAX_NAMEID <= i)
{
AssertSz(0,"Ran out of NameIds");
return FALSE;
}
return TRUE;
}
Reference in a new issue View git blame Copy permalink