//____________________________________________________________________________
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995 - 1996.
//
// File: jobidl.cxx
//
// Contents:
//
// Classes:
//
// Functions:
//
// Notes: For the first release of the scheduling agent, all security
// operations are disabled under Win95, even Win95 to NT.
//
// History: 1/24/1996 RaviR Created
//
//____________________________________________________________________________
#include "..\pch\headers.hxx"
#pragma hdrstop
#include "dbg.h"
#include "macros.h"
#include "..\inc\resource.h"
#include "resource.h"
#include "..\wizard\resource.h"
#include "..\inc\common.hxx"
#include "jobidl.hxx"
#include "sch_cls.hxx" // sched\inc
#include "job_cls.hxx" // sched\inc
#include "misc.hxx" // sched\inc
#include "util.hxx"
#include "..\schedui\schedui.hxx"
#if !defined(_CHICAGO_)
void
SecurityErrorDialog(
HWND hWndOwner,
HRESULT hr);
#endif // !defined(_CHICAGO_)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
////////
//////// CJobID class implementation
////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//+--------------------------------------------------------------------------
//
// Member: CJobID::InitToTemplate
//
// Synopsis: Inititialize this to represent a template object in the
// folder.
//
// History: 05-15-1997 DavidMun Created
//
//---------------------------------------------------------------------------
void
CJobID::InitToTemplate()
{
_id = ID_TEMPLATE;
//
// Name offset is at 1 so the first char can serve to make empty app
// name, creator, and path strings.
//
_oCreator = 0;
_oPath = 0;
_oName = 1;
LoadString(g_hInstance,
IDS_TEMPLATE_NAME,
&_cBuf[_oName],
IDJOB_BUFFER_SIZE - 3);
_cb = offsetof(CJobID, _cBuf) +
(_oName + lstrlen(&_cBuf[_oName]) + 1) * sizeof(TCHAR);
// ^^^ pidl size has to include offset into _cBuf
_NullTerminate();
}
//____________________________________________________________________________
//
// Member: CJobID::Load
//
// Arguments: [pszFolderPath] -- IN
// [pszJob] -- IN
//
// Returns: HRESULT.
//____________________________________________________________________________
HRESULT
CJobID::Load(
LPCTSTR pszFolderPath,
LPTSTR pszJob) // job path relative to Jobs folder with .job extension
{
DEBUG_OUT((DEB_USER12,
"[CJobID::Load] <%ws, %ws>\n",
pszFolderPath ? (LPWSTR)pszFolderPath : L"NULL FolderPath",
pszJob));
#if DBG==1
TCHAR * pExt = PathFindExtension(pszJob);
Win4Assert(lstrcmpi(pExt, TSZ_DOTJOB) == 0);
#endif
HRESULT hr = S_OK;
CJob *pJob = NULL;
ZeroMemory(this, sizeof(CJobID));
do
{
//
// Set creation & last write times
//
TCHAR tcFile[MAX_PATH+1];
LPTSTR pFile = tcFile;
if (pszFolderPath != NULL)
{
lstrcpy(tcFile, pszFolderPath);
lstrcat(tcFile, TEXT("\\"));
lstrcat(tcFile, pszJob);
}
else
{
pFile = pszJob;
}
//
// Skip hidden jobs.
//
if (GetFileAttributes(pFile) & FILE_ATTRIBUTE_HIDDEN)
{
return S_FALSE;
}
HANDLE hFile = CreateFile(pFile, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
DEBUG_OUT_LASTERROR;
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
if (GetFileTime(hFile, &_ftCreation, NULL, &_ftLastWrite) == FALSE)
{
CloseHandle(hFile);
DEBUG_OUT_LASTERROR;
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
CloseHandle(hFile);
//
// Create & load the job
//
hr = ::JFCreateAndLoadCJob(pszFolderPath, pszJob, &pJob);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
_id = ID_JOB;
////////////////////////////////////////////////////////////
//
// Extract the properties
//
//
// Get last exit code
//
// The return value from this call is the task's last start error.
//
HRESULT hrLastStart = pJob->GetExitCode(&_dwExitCode);
//
// Get a code to tell what to display in the "Status" column.
// For the purposes of this column the job can be:
// a. missed
// b. failed to start
// c. running
// d. other
//
ULONG ulAllFlags;
pJob->GetAllFlags(&ulAllFlags);
if (ulAllFlags & JOB_I_FLAG_MISSED)
{
_status = ejsMissed;
}
else if (FAILED(hrLastStart))
{
switch(hrLastStart)
{
case HRESULT_FROM_WIN32(ERROR_LOGON_FAILURE):
_status = ejsBadAcct;
break;
case HRESULT_FROM_WIN32(ERROR_ACCOUNT_RESTRICTION):
_status = ejsResAcct;
break;
default:
_status = ejsWouldNotStart;
}
}
else
{
HRESULT hrStatus = 0;
hr = pJob->GetStatus(&hrStatus);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
switch (hrStatus)
{
case SCHED_S_TASK_RUNNING:
_status = ejsRunning;
break;
case SCHED_S_TASK_NOT_SCHEDULED:
_status = ejsNotScheduled;
break;
}
}
//
// Get last run time
//
hr = pJob->GetMostRecentRunTime(&_stLastRunTime);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
// ensure wDayOfWeek is 0, else memcmp fails.
_stLastRunTime.wDayOfWeek = 0;
//
// Get next run time
//
hr = pJob->GetNextRunTime(&_stNextRunTime);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
// ensure wDayOfWeek is 0, else memcmp fails.
_stNextRunTime.wDayOfWeek = 0;
//
// Get the job flags
//
hr = pJob->GetFlags(&_ulJobFlags);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
//
// Get the first job trigger if any
//
hr = pJob->GetTriggerCount(&_cTriggers);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
if (_cTriggers > 0)
{
ITaskTrigger * pIJobTrigger = NULL;
hr = pJob->GetTrigger(0, &pIJobTrigger);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
_sJobTrigger.cbTriggerSize = sizeof(TASK_TRIGGER);
hr = pIJobTrigger->GetTrigger(&_sJobTrigger);
pIJobTrigger->Release();
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
}
else
{
_sJobTrigger.cbTriggerSize = 0;
}
///////////////////////////////////////////////////////////////////
//
// Fill up the buffer cBuf
//
USHORT cchCurr = 0;
//
// Get the command
//
LPWSTR pwszCommand = NULL;
hr = pJob->GetApplicationName(&pwszCommand);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
#ifndef UNICODE
hr = UnicodeToAnsi(_cBuf, pwszCommand, MAX_PATH);
CoTaskMemFree(pwszCommand);
BREAK_ON_FAIL(hr);
#else
lstrcpy(_cBuf, pwszCommand);
CoTaskMemFree(pwszCommand);
#endif
DEBUG_OUT((DEB_USER12, "Command = %ws\n", _cBuf));
// update size
cchCurr += lstrlen(_cBuf) + 1;
//
// Get the account name
//
_oCreator = cchCurr;
LPWSTR pwszCreator = NULL;
hr = pJob->GetCreator(&pwszCreator);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
#if defined(UNICODE)
lstrcpy(&_cBuf[_oCreator], pwszCreator);
CoTaskMemFree(pwszCreator);
#else
hr = UnicodeToAnsi(&_cBuf[_oCreator], pwszCreator, MAX_PATH);
CoTaskMemFree(pwszCreator);
BREAK_ON_FAIL(hr);
#endif
// update size
cchCurr += lstrlen(&_cBuf[_oCreator]) + 1;
//
// Copy the job path
//
_oPath = cchCurr;
if (pszFolderPath == NULL)
{
pszJob = PathFindFileName(pszJob);
}
lstrcpy(&_cBuf[_oPath], pszJob);
TCHAR * ptcPath = &_cBuf[_oPath];
TCHAR * ptcName = PathFindFileName(ptcPath);
TCHAR * ptcExtn = PathFindExtension(ptcName);
if (ptcExtn)
{
*ptcExtn = TEXT('\0');
}
_oName = _oPath + (USHORT)(ptcName - ptcPath) * sizeof(TCHAR);
// update buff size
cchCurr += lstrlen(ptcPath) + 1;
//
// Finaly set the size
//
_cb = offsetof(CJobID, _cBuf) + cchCurr * sizeof(TCHAR);
//
// Ensure that the DWORD at the end is zero, used by ILClone, etc.
//
_NullTerminate();
} while (0);
if (pJob != NULL)
{
pJob->Release();
}
return hr;
}
//____________________________________________________________________________
//
// Member: CJobID::Rename
//
// Synopsis: Loads this object with data from jidIn, except for
// the name which is set to lpszName.
//
// Arguments: [jidIn] -- IN
// [lpszName] -- IN
//
// Returns: HRESULT.
//
// History: 1/25/1996 RaviR Created
//
//____________________________________________________________________________
HRESULT
CJobID::Rename(
CJobID & jidIn,
LPCOLESTR lpszNameIn)
{
ZeroMemory(this, sizeof(CJobID));
CopyMemory(this, &jidIn, jidIn.GetSize());
LPTSTR lpszName = (LPTSTR)lpszNameIn;
#if !defined(UNICODE)
CHAR cBufTemp[MAX_PATH];
HRESULT hr = UnicodeToAnsi(cBufTemp, lpszNameIn, MAX_PATH);
if (FAILED(hr))
{
return hr;
}
lpszName = cBufTemp;
#endif
lstrcpy(&_cBuf[_oName], lpszName);
_cb = offsetof(CJobID, _cBuf) +
(_oName + lstrlen(lpszName) + 1) * sizeof(TCHAR);
_NullTerminate();
return S_OK;
}
//____________________________________________________________________________
//
// Member: CJobID::Clone
//
// Returns: CJobID *
//____________________________________________________________________________
CJobID *
CJobID::Clone(void)
{
CJobID * pjid = (CJobID *) SHAlloc(_cb + sizeof(_cb));
if (pjid)
{
CopyMemory(pjid, this, _cb);
pjid->_NullTerminate();
}
return pjid;
}
#if (DBG == 1)
//+--------------------------------------------------------------------------
//
// Member: CJobID::Validate
//
// Synopsis: Assert if this job idlist object is invalid
//
// History: 12-04-1997 DavidMun Created
//
// Notes: For debugging only.
//
//---------------------------------------------------------------------------
VOID
CJobID::Validate()
{
//
// Expect _cb to have been set to nonzero value
//
Win4Assert(_cb);
Win4Assert(_cb < sizeof(CJobID));
//
// Expect all jobids to have a name. Offset should be nonzero because
// name is not the first string.
//
Win4Assert(_oName < IDJOB_BUFFER_SIZE);
//
// Expect that name is null terminated before the end of the buffer.
//
Win4Assert(_oName + lstrlen(GetName()) < IDJOB_BUFFER_SIZE);
//
// Expect the jobid itself to be null terminated
//
UNALIGNED USHORT *pusNextCB = (UNALIGNED USHORT *)(((BYTE *)this) + _cb);
Win4Assert(_cb + sizeof(USHORT) <= sizeof(CJobID));
Win4Assert(!*pusNextCB);
}
#endif // (DBG == 1)
BOOL
GetLocaleDateTimeString(
SYSTEMTIME* pst,
DWORD dwDateFlags,
DWORD dwTimeFlags,
TCHAR szBuff[],
int cchBuffLen,
LPSHELLDETAILS lpDetails);
//____________________________________________________________________________
//
// Member: CJobID::GetNextRunTimeString
//
// Synopsis: S
//
// Arguments: [tcBuff] -- IN
// [cchBuff] -- IN
// [fForComparison] -- IN
//
// Returns: HRESULT.
//
// History: 4/25/1996 RaviR Created
//
//____________________________________________________________________________
LPTSTR
CJobID::GetNextRunTimeString(
TCHAR tcBuff[],
UINT cchBuff,
BOOL fForComparison,
LPSHELLDETAILS lpDetails)
{
if (this->IsJobNotScheduled() == TRUE)
{
LoadString(g_hInstance, IDS_NEVER, tcBuff, cchBuff);
}
else if (this->IsJobFlagOn(TASK_FLAG_DISABLED) == TRUE)
{
LoadString(g_hInstance, IDS_DISABLED, tcBuff, cchBuff);
}
else if (this->IsTriggerFlagOn(TASK_TRIGGER_FLAG_DISABLED))
{
LoadString(g_hInstance, IDS_TRIGGER_DISABLED, tcBuff, cchBuff);
}
else if (this->GetTriggerType() == TASK_EVENT_TRIGGER_AT_SYSTEMSTART)
{
LoadString(g_hInstance, IDS_ON_STARTUP, tcBuff, cchBuff);
}
else if (this->GetTriggerType() == TASK_EVENT_TRIGGER_AT_LOGON)
{
LoadString(g_hInstance, IDS_ON_LOGON, tcBuff, cchBuff);
}
else if (this->GetTriggerType() == TASK_EVENT_TRIGGER_ON_IDLE)
{
LoadString(g_hInstance, IDS_WHEN_IDLE, tcBuff, cchBuff);
}
else
{
SYSTEMTIME &st = this->GetNextRunTime();
if (st.wYear == 0 || st.wMonth == 0 || st.wDay == 0)
{
LoadString(g_hInstance, IDS_NEVER, tcBuff, cchBuff);
}
else
{
if (fForComparison == TRUE)
{
return NULL;
}
GetLocaleDateTimeString(&st, DATE_SHORTDATE, 0, tcBuff, cchBuff, lpDetails);
}
}
return tcBuff;
}
//____________________________________________________________________________
//
// Function: HDROPFromJobIDList
//
// Synopsis: Create an HDROP for the files in the apjid array.
// Used for CF_HDROP format.
//
// Arguments: [cidl] -- IN
// [apjidl] -- IN
//
// Returns: HDROP
//
// History: 1/31/1996 RaviR Created
//
//____________________________________________________________________________
HDROP
HDROPFromJobIDList(
LPCTSTR pszFolderPath,
UINT cidl,
PJOBID * apjidl)
{
HDROP hMem = 0;
LPDROPFILESTRUCT lpDrop;
DWORD dwSize = 0;
if (cidl == 0)
{
return NULL;
}
TCHAR tcFolder[MAX_PATH];
lstrcpy(tcFolder, pszFolderPath);
lstrcat(tcFolder, TEXT("\\"));
USHORT cbFolderPathLen = (USHORT)(lstrlen(tcFolder) * sizeof(TCHAR));
//
// Walk the list and find out how much space we need.
//
dwSize = sizeof(DROPFILESTRUCT) + sizeof(TCHAR); // size + terminal nul
USHORT * pusPathLen = new USHORT[cidl * 2];
if (pusPathLen == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
return NULL;
}
USHORT * pusExtLen = &pusPathLen[cidl];
for (UINT i=0; i < cidl; i++)
{
pusPathLen[i] = (USHORT)(lstrlen(apjidl[i]->GetPath()) * sizeof(TCHAR));
pusExtLen[i] = (USHORT)((lstrlen(apjidl[i]->GetExtension()) + 1) * sizeof(TCHAR));
dwSize += cbFolderPathLen + pusPathLen[i] + pusExtLen[i];
}
//
// If it's bigger than the struct can hold, then bail.
// TODO: Return an error?
//
if (dwSize > 0x0000ffff)
{
delete [] pusPathLen;
return NULL;
}
//
// Allocate the buffer and fill it in.
//
hMem = (HDROP)GlobalAlloc(GHND, dwSize);
if (hMem == NULL)
{
delete [] pusPathLen;
CHECK_HRESULT(E_OUTOFMEMORY);
return NULL;
}
lpDrop = (LPDROPFILESTRUCT) GlobalLock(hMem);
lpDrop->pFiles = (DWORD)(sizeof(DROPFILESTRUCT));
lpDrop->pt.x = 0;
lpDrop->pt.y = 0;
lpDrop->fNC = FALSE;
#ifdef UNICODE
lpDrop->fWide = TRUE;
#else
lpDrop->fWide = FALSE;
#endif
//
// Fill in the path names.
//
LPBYTE pbTemp = (LPBYTE) ((LPBYTE) lpDrop + lpDrop->pFiles);
for (i=0; i < cidl; i++)
{
CopyMemory(pbTemp, tcFolder, cbFolderPathLen);
pbTemp += cbFolderPathLen;
CopyMemory(pbTemp, apjidl[i]->GetPath(), pusPathLen[i]);
pbTemp += pusPathLen[i];
CopyMemory(pbTemp, apjidl[i]->GetExtension(), pusExtLen[i]);
pbTemp += pusExtLen[i];
}
*((LPTSTR)pbTemp) = TEXT('\0'); // Extra Nul terminate
//
// Unlock the buffer and return it.
//
GlobalUnlock(hMem);
delete [] pusPathLen;
return hMem;
}
//+--------------------------------------------------------------------------
//
// Function: CreateIDListArray
//
// Synopsis: Create shell idlist array in the format required by the
// CFSTR_SHELLIDLIST clipboard format.
//
// Arguments: [pidlFolder] - pidl of tasks folder
// [cidl] - number of elements in [apjidl]
// [apjidl] - array of pointers to idls, each idl
// specifies a .job object.
//
// Returns: Handle to created array, or NULL on error.
//
// History: 05-30-1997 DavidMun Created
//
// Notes: For this format, the first element in the array is an
// absolute idl to a container (the tasks folder), and the
// remainder (each a single .job object) are relative to the
// first.
//
//---------------------------------------------------------------------------
HGLOBAL
CreateIDListArray(
LPCITEMIDLIST pidlFolder,
UINT cidl,
PJOBID *apjidl)
{
TRACE_FUNCTION(CreateIDListArray);
Win4Assert(cidl);
if (cidl == 0)
{
return NULL;
}
HJOBIDA hJobIDA = NULL;
DWORD offset = sizeof(CJobIDA) + sizeof(UINT) * cidl;
DWORD dwSize = offset;
for (UINT i=0; i < cidl ; i++)
{
dwSize += apjidl[i]->GetSize() + 2; // +2 for null list terminator
}
dwSize += ILGetSize(pidlFolder);
hJobIDA = GlobalAlloc(GPTR, dwSize); // This MUST be GlobalAlloc!!!
if (hJobIDA == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
return NULL;
}
PJOBIDA pJobIDA = (PJOBIDA)hJobIDA; // no need to lock
pJobIDA->cidl = cidl; // count doesn't include idl at offset 0,
pJobIDA->aoffset[0] = offset; // which is container
CopyMemory(((LPBYTE)pJobIDA)+offset, pidlFolder, ILGetSize(pidlFolder));
offset += ILGetSize(pidlFolder);
for (i=0; i < cidl ; i++)
{
UINT cbSize = apjidl[i]->GetSize();
pJobIDA->aoffset[i+1] = offset;
CopyMemory(((LPBYTE)pJobIDA)+offset, apjidl[i], cbSize);
offset += cbSize + 2; // +2 to leave null after copied in idl
}
Win4Assert(offset == dwSize);
return hJobIDA;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
////////
//////// CJobIDA related functions.
////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//____________________________________________________________________________
//
// Function: HJOBIDA_Create
//
// Synopsis: Create an HJOBIDA for the files in the apjid array.
// Used for CF_JOBIDLIST data format.
//
// Arguments: [cidl] -- IN
// [apjidl] -- IN
//
// Returns: HJOBIDA
//
// History: 1/31/1996 RaviR Created
//
//____________________________________________________________________________
HJOBIDA
HJOBIDA_Create(
UINT cidl,
PJOBID * apjidl)
{
if (cidl == 0)
{
return NULL;
}
HJOBIDA hJobIDA = NULL;
DWORD offset = sizeof(CJobIDA) + sizeof(UINT) * (cidl - 1);
DWORD dwSize = offset;
for (UINT i=0; i < cidl ; i++)
{
dwSize += apjidl[i]->GetSize() + 2; // +2 for null list terminator
}
hJobIDA = GlobalAlloc(GPTR, dwSize); // This MUST be GlobalAlloc with
// GPTR!
if (hJobIDA == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
return NULL;
}
PJOBIDA pJobIDA = (PJOBIDA)hJobIDA; // no need to lock
pJobIDA->cidl = cidl;
//
// Note that apjidl[i] reports its true size, which doesn't include the
// extra 0 ulong following it. That null terminator is required, and
// isn't copied into pJobIDA by the CopyMemory, which is using
// apjidl[i]'s reported size.
//
// Since the GPTR ensures zero-initialized memory, and the extra 2
// bytes per jobid has been accounted for in computing dwSize, we can
// get the terminator just by increasing offset by the terminator size
// on each iteration.
//
for (i=0; i < cidl ; i++)
{
UINT cbSize = apjidl[i]->GetSize();
pJobIDA->aoffset[i] = offset;
CopyMemory(((LPBYTE)pJobIDA)+offset, apjidl[i], cbSize);
offset += cbSize + 2;
}
Win4Assert(offset == dwSize);
return hJobIDA;
}
void
HJOBIDA_Free(
HJOBIDA hJobIDA)
{
GlobalFree(hJobIDA); // This MUST be GlobalFree
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
////////
//////// Functions to clone and free a LPCITEMIDLIST array.
////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//____________________________________________________________________________
//
// Function: ILA_Clone
//
// Synopsis: S
//
// Arguments: [cidl] -- IN
// [apidl] -- IN
//
// Returns: LPITEMIDLIST
//
// History: 1/9/1996 RaviR Created
//
//____________________________________________________________________________
LPITEMIDLIST*
ILA_Clone(
UINT cidl,
LPCITEMIDLIST * apidl)
{
TRACE_FUNCTION(ILA_Clone);
LPITEMIDLIST* aNewPidl = new LPITEMIDLIST[cidl];
if (NULL == aNewPidl)
{
return NULL;
}
for (UINT i = 0; i < cidl; i++)
{
aNewPidl[i] = ILClone(apidl[i]);
if (NULL == aNewPidl[i])
{
// delete what we've allocated so far
for (UINT j = 0; j < i; j++)
{
ILFree(aNewPidl[i]);
}
delete[] aNewPidl;
return NULL;
}
}
return aNewPidl;
}
//____________________________________________________________________________
//
// Function: ILA_Free
//
// Synopsis: S
//
// Arguments: [cidl] -- IN
// [apidl] -- IN
//
// Returns: VOID
//
// History: 1/9/1996 RaviR Created
//
//____________________________________________________________________________
VOID
ILA_Free(
UINT cidl,
LPITEMIDLIST * apidl)
{
TRACE_FUNCTION(ILA_Free);
for (UINT i = 0; i < cidl; i++)
{
ILFree(apidl[i]);
}
delete [] apidl;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
////////
//////// Functions to access the CJob & CSchedule
////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//____________________________________________________________________________
//
// Function: JFGetJobScheduler
//
// Synopsis: S
//
// Arguments: [ppJobScheduler] -- IN
// [ppwszFolderPath] -- IN
//
// Returns: HRESULT
//
// History: 1/25/1996 RaviR Created
//
//____________________________________________________________________________
HRESULT
JFGetJobScheduler(
LPTSTR pszMachine,
ITaskScheduler ** ppJobScheduler,
LPCTSTR *ppszFolderPath)
{
HRESULT hr = S_OK;
CSchedule * pCSchedule = NULL;
do
{
pCSchedule = new CSchedule;
if (pCSchedule == NULL)
{
hr = E_OUTOFMEMORY;
CHECK_HRESULT(hr);
break;
}
hr = pCSchedule->Init();
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
if (pszMachine != NULL)
{
#ifdef UNICODE
hr = pCSchedule->SetTargetComputer(pszMachine);
#else
WCHAR wBuff[MAX_PATH];
hr = AnsiToUnicode(wBuff, pszMachine, MAX_PATH);
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
hr = pCSchedule->SetTargetComputer(wBuff);
#endif
CHECK_HRESULT(hr);
BREAK_ON_FAIL(hr);
}
*ppszFolderPath = pCSchedule->GetFolderPath();
*ppJobScheduler = (ITaskScheduler *)pCSchedule;
} while (0);
if (FAILED(hr) && pCSchedule != NULL)
{
pCSchedule->Release();
}
return hr;
}
//____________________________________________________________________________
//
// Member: CreateAndLoadCJob
//
// Arguments: [pszJob] -- IN
// [ppJob] -- OUT
//
// Returns: HRESULT.
//____________________________________________________________________________
HRESULT
JFCreateAndLoadCJob(
LPCTSTR pszFolderPath,
LPTSTR pszJob, // job path relative to the folder
CJob ** ppJob)
{
TRACE_FUNCTION(CreateAndLoadCJob);
*ppJob = NULL; // init for failure
CJob *pJob = CJob::Create();
if (pJob == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
return E_OUTOFMEMORY;
}
TCHAR buff[MAX_PATH];
LPTSTR pszJobPathTemp = pszJob;
if (pszFolderPath != NULL)
{
lstrcpy(buff, pszFolderPath);
lstrcat(buff, TEXT("\\"));
lstrcat(buff, pszJob);
pszJobPathTemp = buff;
}
HRESULT hr = S_OK;
#if defined(UNICODE)
LPWSTR pwszJobPath = pszJobPathTemp;
#else
WCHAR wcBuff[MAX_PATH];
hr = AnsiToUnicode(wcBuff, pszJobPathTemp, MAX_PATH);
if (FAILED(hr))
{
pJob->Release();
CHECK_HRESULT(hr);
return hr;
}
LPWSTR pwszJobPath = wcBuff;
#endif
DEBUG_OUT((DEB_USER1, "Load Job <%ws>\n", pwszJobPath));
hr = pJob->Load(pwszJobPath, STGM_READWRITE | STGM_SHARE_EXCLUSIVE);
if (FAILED(hr))
{
pJob->Release();
CHECK_HRESULT(hr);
return hr;
}
//
// Success, return the object
//
*ppJob = pJob;
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: JFCreateAndLoadTask
//
// Synopsis: Create an in-memory task object and initialize it from
// [pszJob], returning the ITask interface on the object.
//
// Arguments: [pszFolderPath] - path to tasks folder
// [pszJob] - filename of job
// [ppITask] - filled with ITask interface ptr
//
// Returns: HRESULT
//
// Modifies: *[ppITask]
//
// History: 10-07-1997 DavidMun Created
//
// Notes: Caller must Release returned interface.
//
//---------------------------------------------------------------------------
HRESULT
JFCreateAndLoadTask(
LPCTSTR pszFolderPath,
LPTSTR pszJob, // job path relative to the folder
ITask ** ppITask)
{
TRACE_FUNCTION(CreateAndLoadTask);
HRESULT hr;
CJob *pJob;
hr = JFCreateAndLoadCJob(pszFolderPath, pszJob, &pJob);
if (SUCCEEDED(hr))
{
hr = pJob->QueryInterface(IID_ITask, (void **)ppITask);
pJob->Release();
}
return hr;
}
//____________________________________________________________________________
//
// Function: JFSaveJob
//
// Synopsis: Save task settings to storage via the task's IPersistFile
// interface. Also, if applicable, prompt the user for security
// account information.
//
// Arguments: [hwndOwner] -- Owner window.
// [pIJob] -- Target task object.
// [fSecuritySupported] -- Flag indicating if
// security-specific code
// should be invoked.
// [fTaskAccountChange] -- TRUE, the task account
// information has
// changed.
// [fTaskApplicationChange] -- TRUE, the task
// application has
// changed.
// [fSuppressAccountInformationRequest] -- TRUE, do not prompt
// the user for account
// information.
//
// Returns: HRESULT
//
// History: 4/25/1996 RaviR Created
//
//____________________________________________________________________________
HRESULT
JFSaveJob(
HWND hwndOwner,
ITask * pITask,
BOOL fSecuritySupported,
BOOL fTaskAccountChange,
BOOL fTaskApplicationChange,
BOOL fSuppressAccountInformationRequest)
{
#if defined(_CHICAGO_)
Win4Assert(!fSecuritySupported);
#endif // defined(_CHICAGO_)
#if !defined(_CHICAGO_)
AccountInfo AcctInfo;
#endif // !defined(_CHICAGO_)
HRESULT hr;
IPersistFile * pipfTask;
WCHAR * pwszAccountName = NULL;
#if !defined(_CHICAGO_)
BOOL fChangesSaved = FALSE;
#endif // !defined(_CHICAGO_)
hr = pITask->QueryInterface(IID_IPersistFile, (void **)&pipfTask);
if (FAILED(hr))
{
return hr;
}
#if !defined(_CHICAGO_)
if (fSecuritySupported)
{
InitializeAccountInfo(&AcctInfo);
//
// Application change but no corresponding account information change.
// Launch the set account information dialog in this case.
//
if (fTaskApplicationChange && !fTaskAccountChange)
{
//
// Attempt to retreive account information for the set account
// information dialog. Ignore failures, we would just like to
// have something to fill in the account name control.
//
if (SUCCEEDED(pITask->GetAccountInformation(&pwszAccountName)))
{
AcctInfo.pwszAccountName = pwszAccountName;
}
goto SetAccountInformationDlg;
}
}
#endif // !defined(_CHICAGO_)
//
// Go ahead and save the changes.
//
hr = pipfTask->Save(NULL, FALSE);
#if !defined(_CHICAGO_)
fChangesSaved = TRUE;
#endif // !defined(_CHICAGO_)
#if !defined(_CHICAGO_)
if (fSecuritySupported)
{
if (FAILED(hr))
{
if (pipfTask->IsDirty() == S_FALSE)
{
//
// If Save failed, yet the job is no longer dirty, the
// error is due to a failure setting security information.
//
// Let the user know there was a problem. Remap the return
// code so we don't get further error dialogs.
//
CHECK_HRESULT(hr);
SecurityErrorDialog(hwndOwner, hr);
hr = S_OK;
}
#if DBG == 1
else
{
//
// Standard persist code failure. Calling page code will
// put up an error dialog.
//
CHECK_HRESULT(hr);
}
#endif // DBG == 1
goto CleanExit;
}
if (!fTaskAccountChange)
{
//
// No account information changes. Verify that this job does
// indeed have account information associated with it.
//
hr = pITask->GetAccountInformation(&pwszAccountName);
if (hr == SCHED_E_ACCOUNT_INFORMATION_NOT_SET)
{
//
// No account information. Launch the set account information
// dialog.
//
hr = S_OK;
goto SetAccountInformationDlg;
}
else if (SUCCEEDED(hr))
{
//
// Done.
//
goto CleanExit;
}
else
{
//
// In error cases, silently fail. There's nothing we can do
// about it other than confuse the user. Remapping the return
// code so the calling page code doesn't put up an error
// dialog.
//
CHECK_HRESULT(hr);
hr = S_OK;
goto CleanExit;
}
}
else if (fTaskApplicationChange && fTaskAccountChange)
{
//
// Fetch cached account information from the job object for
// the pending set account information dialog. Silently fail
// in an error case.
//
hr = pITask->GetAccountInformation(&pwszAccountName);
Win4Assert(hr != SCHED_E_ACCOUNT_INFORMATION_NOT_SET);
if (FAILED(hr) || hr == S_FALSE)
{
//
// The information is cached. This would fail for no
// reason other than insufficient memory.
//
// Though, did we goof?
//
CHECK_HRESULT(hr);
hr = S_OK;
goto CleanExit;
}
AcctInfo.pwszAccountName = pwszAccountName;
}
else
{
//
// Done.
//
goto CleanExit;
}
}
else
{
CHECK_HRESULT(hr);
goto CleanExit;
}
SetAccountInformationDlg:
//
// Should've arrived here only for security reasons.
//
Win4Assert(fSecuritySupported);
//
// Can only arrive at this point if the user must specify security
// account information.
//
// Launch the set account information dialog.
//
if (!fSuppressAccountInformationRequest)
{
LaunchSetAccountInformationDlg(hwndOwner, &AcctInfo);
//
// Check if the data is dirty. On dialog entry, the password is set
// to the global empty string. If the password ptr still equals this,
// then the user didn't change the password (e.g. the user canceled
// the dialog).
//
if (AcctInfo.pwszAccountName != NULL &&
AcctInfo.pwszPassword != tszEmpty)
{
//
// Reset the account information and persist the changes.
//
hr = pITask->SetAccountInformation(AcctInfo.pwszAccountName,
AcctInfo.pwszPassword);
fChangesSaved = FALSE;
if (FAILED(hr))
{
goto CleanExit;
}
}
}
if (!fChangesSaved)
{
CWaitCursor WaitCursor;
hr = pipfTask->Save(NULL, FALSE);
if (FAILED(hr) && pipfTask->IsDirty() == S_FALSE)
{
//
// Similar check as above. General save succeeded but the attempt
// to set security information failed. Let the user know there
// was a problem and remap the return code so we don't get
// further dialogs.
//
SecurityErrorDialog(hwndOwner, hr);
hr = S_OK;
}
#if DBG == 1
else
{
CHECK_HRESULT(hr);
}
#endif // DBG == 1
}
#endif // !defined(_CHICAGO_)
#if !defined(_CHICAGO_)
CleanExit:
#endif // !defined(_CHICAGO_)
pipfTask->Release();
#if !defined(_CHICAGO_)
if (fSecuritySupported)
{
ResetAccountInfo(&AcctInfo);
}
#endif // !defined(_CHICAGO_)
return hr;
}
#if !defined(_CHICAGO_)
//____________________________________________________________________________
//
// Function: SecurityErrorDialog
//
// Synopsis: Map the error to a hopefully friendly & informative dialog.
//
// Arguments: [hWndOwner] -- Parent window handle.
// [hr] -- Security error to map.
//
// Returns: None.
//
// Notes: None.
//
//____________________________________________________________________________
void
SecurityErrorDialog(
HWND hWndOwner,
HRESULT hr)
{
int idsErrorMessage;
UINT idsHelpHint;
idsErrorMessage = IERR_SECURITY_WRITE_ERROR;
if (hr == SCHED_E_ACCOUNT_NAME_NOT_FOUND)
{
idsHelpHint = IDS_HELP_HINT_INVALID_ACCT;
}
else if (hr == SCHED_E_ACCOUNT_DBASE_CORRUPT)
{
idsHelpHint = IDS_HELP_HINT_DBASE_CORRUPT;
}
else if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
{
idsHelpHint = IDS_HELP_HINT_ACCESS_DENIED;
}
else if (hr == SCHED_E_SERVICE_NOT_RUNNING ||
HRESULT_FACILITY(hr) == FACILITY_RPC)
{
idsHelpHint = IDS_HELP_HINT_SEC_GENERAL;
}
else
{
//
// No help hint for unexpected errors.
//
idsHelpHint = 0;
}
//
// Put up the error dialog.
//
SchedUIErrorDialog(hWndOwner, idsErrorMessage, hr, idsHelpHint);
}
#endif // !defined(_CHICAGO_)
//____________________________________________________________________________
//
// Function: JFGetAppNameForTask
//
// Synopsis: S
//
// Arguments: [path] -- IN
// [pszAppName] -- IN
// [cchAppName] -- IN
//
// Returns: HRESULT
//
// History: 4/25/1996 RaviR Created
//
//____________________________________________________________________________
HRESULT
JFGetAppNameForTask(
LPCTSTR pszTask, // Full path
LPTSTR pszAppName,
UINT cchAppName)
{
TRACE_FUNCTION(JFGetAppNameForTask);
HRESULT hr = S_OK;
CJob *pJob = CJob::Create();
if (pJob == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
return E_OUTOFMEMORY;
}
hr = pJob->LoadP(pszTask, 0, FALSE, FALSE);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
{
LPWSTR pwszCommand = NULL;
hr = pJob->GetApplicationName(&pwszCommand);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
{
#ifdef UNICODE
lstrcpy(pszAppName, pwszCommand);
DEBUG_OUT((DEB_USER1, "JFGetAppNameForTask -> %ws\n", pszAppName));
#else
hr = UnicodeToAnsi(pszAppName, pwszCommand, cchAppName);
#endif
CoTaskMemFree(pwszCommand);
}
}
pJob->Release();
return hr;
}
BOOL
IsAScheduleObject(
TCHAR szFile[])
{
if( NULL == szFile )
{
return FALSE;
}
LPTSTR pszName = PathFindFileName(szFile);
LPTSTR pszExt = PathFindExtension(pszName);
if (lstrcmpi(pszExt, TSZ_DOTJOB) != 0)
// && (lstrcmpi(pszExt, g_szDotQue) != 0)
{
return FALSE;
}
return TRUE;
}
//____________________________________________________________________________
//
// Function: JFCopyJob
//
// Synopsis: S
//
// Arguments: [hwndOwner] -- IN
// [szFileFrom] -- IN
// [pszFolderPath] -- IN
// [fMove] -- IN
//
// Returns: HRESULT
//
// History: 2/2/1996 RaviR Created
//
//____________________________________________________________________________
HRESULT
JFCopyJob(
HWND hwndOwner,
TCHAR szFileFrom[],
LPCTSTR pszFolderPath,
BOOL fMove)
{
HRESULT hr = S_OK;
ITask * pJob = NULL;
LPTSTR pszName = PathFindFileName(szFileFrom);
hr = JFCreateAndLoadTask(NULL, szFileFrom, &pJob);
if (FAILED(hr))
{
if (hr == HRESULT_FROM_WIN32(ERROR_INVALID_DATA))
{
SchedUIErrorDialog(hwndOwner, IERR_INVALID_DATA, pszName);
}
return hr;
}
else
{
pJob->Release();
}
TCHAR szFileTo[MAX_PATH+1];
lstrcpy(szFileTo, pszFolderPath);
SHFILEOPSTRUCT fo = {hwndOwner, (fMove ? FO_MOVE : FO_COPY), szFileFrom,
szFileTo, FOF_ALLOWUNDO, FALSE, NULL, NULL};
// Make sure we have double trailing NULL!
*(szFileFrom + lstrlen(szFileFrom) + 1) = TEXT('\0');
if ((SHFileOperation(&fo) !=0) || fo.fAnyOperationsAborted == TRUE)
{
hr = E_FAIL;
CHECK_HRESULT(hr);
return hr;
}
//SHChangeNotify(SHCNE_RENAMEITEM, SHCNF_PATH, szFileFrom, szFileTo);
return hr;
}
//____________________________________________________________________________
//
// Function: GetTriggerStringFromTrigger
//
// Synopsis: S
//
// Arguments: [pJobTrigger] -- IN
// [psTrigger] -- IN
// [cchTrigger] -- IN
//
// Returns: HRESULT
//____________________________________________________________________________
HRESULT
GetTriggerStringFromTrigger(
TASK_TRIGGER * pJobTrigger,
LPTSTR psTrigger,
UINT cchTrigger,
LPSHELLDETAILS lpDetails)
{
HRESULT hr = S_OK;
LPWSTR pwsz = NULL;
if (pJobTrigger->cbTriggerSize > 0)
{
hr = ::StringFromTrigger(pJobTrigger, &pwsz, lpDetails);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
{
#if defined(UNICODE)
lstrcpy(psTrigger, pwsz);
#else
hr = UnicodeToAnsi(psTrigger, pwsz, cchTrigger);
#endif
CoTaskMemFree(pwsz);
}
}
else
{
LoadString(g_hInstance, IDS_JOB_NOT_SCHEDULED, psTrigger, cchTrigger);
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
////////
//////// Misc functions.
////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
LPITEMIDLIST *
SHIDLFromJobIDL(
UINT cidl,
PJOBID * apjidl)
{
LPITEMIDLIST * apidlOut = (LPITEMIDLIST *)SHAlloc(
sizeof(LPITEMIDLIST) * cidl);
if (apidlOut)
{
for (UINT i=0; i < cidl; i++)
{
apidlOut[i] = ILCreateFromPath(apjidl[i]->GetPath());
if (apidlOut[i] == NULL)
{
break;
}
}
if (i < cidl) // => memory error
{
while (i--)
{
ILFree(apidlOut[i]);
}
SHFree(apidlOut);
apidlOut = NULL;
}
}
#if DBG==1
if (apidlOut == NULL)
{
CHECK_HRESULT(E_OUTOFMEMORY);
}
#endif
return apidlOut;
}