268 lines
9 KiB
C++
268 lines
9 KiB
C++
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Microsoft Windows
|
||
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996.
|
||
|
|
//
|
||
|
|
// File: runobj.hxx
|
||
|
|
//
|
||
|
|
// Contents: CRun class definition.
|
||
|
|
//
|
||
|
|
// Classes: CRun
|
||
|
|
//
|
||
|
|
// Functions: None.
|
||
|
|
//
|
||
|
|
// History: 08-Sep-95 EricB Created.
|
||
|
|
// 01-Dec-95 MarkBl Split from util.hxx.
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
#ifndef __RUNOBJ_HXX__
|
||
|
|
#define __RUNOBJ_HXX__
|
||
|
|
|
||
|
|
//#include "time.hxx"
|
||
|
|
|
||
|
|
#undef SetFlag
|
||
|
|
#undef ClearFlag
|
||
|
|
#undef IsFlagSet
|
||
|
|
|
||
|
|
//
|
||
|
|
// Run processing flags: values 0x00010000 through 0x80000000 for run state:
|
||
|
|
//
|
||
|
|
#define RUN_STATUS_RUNNING 0x00010000
|
||
|
|
#define RUN_STATUS_FINISHED 0x00020000
|
||
|
|
#define RUN_STATUS_ABORTED 0x00040000
|
||
|
|
#define RUN_STATUS_TIMED_OUT 0x00080000
|
||
|
|
#define RUN_STATUS_CLOSE_PENDING 0x00100000
|
||
|
|
#define RUN_STATUS_CLOSED 0x00200000 // (This is set, but not used yet)
|
||
|
|
#define RUN_STATUS_RESTART_ON_IDLE_RESUME 0x00400000
|
||
|
|
|
||
|
|
//+----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Class: CRun
|
||
|
|
//
|
||
|
|
// Synopsis: Lightweight job object. A moniker of sorts to the real thing.
|
||
|
|
// Represents one run instance of a job.
|
||
|
|
//
|
||
|
|
// CODEWORK: (AnirudhS 11/7/96) The inheritance relationship should be:
|
||
|
|
// class CRun : protected CDLink (instead of public CDLink)
|
||
|
|
// class CRunList : private CRun (instead of having a private CRun member)
|
||
|
|
// This would assure us that only CRunList could call CRun's CDLink methods.
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
class CRun : public CDLink
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CRun(LPFILETIME pft, LPFILETIME pftDeadline, FILETIME ftKill,
|
||
|
|
DWORD MaxRunTime, DWORD rgFlags, WORD wIdleWait,
|
||
|
|
BOOL fKeepAfterRunning);
|
||
|
|
CRun(DWORD MaxRunTime, DWORD rgFlags, FILETIME ftDeadline,
|
||
|
|
BOOL fKeepAfterRunning);
|
||
|
|
CRun(DWORD MaxRunTime, DWORD rgFlags, WORD wIdleWait,
|
||
|
|
FILETIME ftDeadline, BOOL fKeepAfterRunning);
|
||
|
|
CRun(CRun * pRun);
|
||
|
|
CRun(void);
|
||
|
|
~CRun();
|
||
|
|
|
||
|
|
HRESULT Initialize(LPCTSTR ptszName) {
|
||
|
|
return(this->SetName(ptszName));
|
||
|
|
}
|
||
|
|
|
||
|
|
void GetSysTime(LPSYSTEMTIME pst) {FileTimeToSystemTime(&m_ft, pst);}
|
||
|
|
void GetTime(LPFILETIME pft) {*pft = m_ft;}
|
||
|
|
LPFILETIME GetTime(void) {return &m_ft;}
|
||
|
|
LPFILETIME GetDeadline(void) {return &m_ftDeadline;}
|
||
|
|
void RelaxDeadline(FILETIME ftDeadline)
|
||
|
|
{ if (CompareFileTime(&ftDeadline, &m_ftDeadline) > 0)
|
||
|
|
m_ftDeadline = ftDeadline; }
|
||
|
|
WORD GetWait(void) {return m_wIdleWait;}
|
||
|
|
void ReduceWaitTo(WORD wIdleWait) { m_wIdleWait = min(m_wIdleWait, wIdleWait);}
|
||
|
|
|
||
|
|
FILETIME GetKillTime() { return m_ftKill; }
|
||
|
|
void AdvanceKillTime(FILETIME ftKill)
|
||
|
|
{ if (CompareFileTime(&ftKill, &m_ftKill) < 0)
|
||
|
|
m_ftKill = ftKill; }
|
||
|
|
void AdjustKillTimeByMaxRunTime(FILETIME ftNow);
|
||
|
|
|
||
|
|
void SetMaxRunTime(DWORD dwMaxRunTime) {m_dwMaxRunTime = dwMaxRunTime;}
|
||
|
|
DWORD GetMaxRunTime(void) {return(m_dwMaxRunTime);}
|
||
|
|
|
||
|
|
CRun * Next(void) { return (CRun *)CDLink::Next(); }
|
||
|
|
CRun * Prev(void) { return (CRun *)CDLink::Prev(); }
|
||
|
|
|
||
|
|
BOOL IsNull(void) {return(m_ft.dwLowDateTime == 0 &&
|
||
|
|
m_ft.dwHighDateTime == 0);};
|
||
|
|
|
||
|
|
HRESULT SetName(LPCTSTR ptszName);
|
||
|
|
LPTSTR GetName(void) { return m_ptszJobName; }
|
||
|
|
|
||
|
|
void SetHandle(HANDLE hJob) {
|
||
|
|
m_hJob = hJob;
|
||
|
|
this->SetFlag(RUN_STATUS_RUNNING);
|
||
|
|
}
|
||
|
|
HANDLE GetHandle(void) const { return(m_hJob); }
|
||
|
|
|
||
|
|
#if !defined(_CHICAGO_)
|
||
|
|
void SetProfileHandles(HANDLE hUser, HANDLE hProfile) {
|
||
|
|
m_hUserToken = hUser;
|
||
|
|
m_hProfile = hProfile;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT SetDesktop( LPCTSTR ptszDesktop );
|
||
|
|
|
||
|
|
LPTSTR GetDesktop( void ) {
|
||
|
|
return m_ptszDesktop;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT SetStation( LPCTSTR ptszStation );
|
||
|
|
|
||
|
|
LPTSTR GetStation( void ) {
|
||
|
|
return m_ptszStation;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#endif // !defined(_CHICAGO_)
|
||
|
|
|
||
|
|
void SetFlag(DWORD rgFlag) { m_rgFlags |= rgFlag; }
|
||
|
|
void ClearFlag(DWORD rgFlag) { m_rgFlags &= ~rgFlag; }
|
||
|
|
DWORD GetFlags(void) { return(m_rgFlags); }
|
||
|
|
BOOL IsFlagSet(DWORD rgFlag) {return (m_rgFlags & rgFlag);}
|
||
|
|
|
||
|
|
BOOL IsIdleTriggered() { return m_fKeepInList; }
|
||
|
|
|
||
|
|
void SetProcessId(DWORD dwProcessId) { m_dwProcessId = dwProcessId; }
|
||
|
|
DWORD GetProcessId(void) { return(m_dwProcessId); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
FILETIME m_ft; // When this instance is to run
|
||
|
|
FILETIME m_ftDeadline; // Latest time when this instance may be started
|
||
|
|
FILETIME m_ftKill; // Time by which this instance must terminate
|
||
|
|
// (see the detailed comment on this field in
|
||
|
|
// procssr.cxx)
|
||
|
|
LPTSTR m_ptszJobName; // Job name.
|
||
|
|
HANDLE m_hJob; // The process handle when run
|
||
|
|
DWORD m_dwProcessId; // The process ID when run
|
||
|
|
#if !defined(_CHICAGO_)
|
||
|
|
HANDLE m_hUserToken; // User token
|
||
|
|
HANDLE m_hProfile; // User profile
|
||
|
|
LPTSTR m_ptszDesktop; //Windows Desktop
|
||
|
|
LPTSTR m_ptszStation; //WindowsStation
|
||
|
|
#endif // !defined(_CHICAGO_)
|
||
|
|
DWORD m_rgFlags; // Job Flags
|
||
|
|
DWORD m_dwMaxRunTime; // The remaining time to wait for the job to
|
||
|
|
// terminate (see the detailed comment on this
|
||
|
|
// field in procssr.cxx)
|
||
|
|
WORD m_wIdleWait; // The idle wait to determine when to run
|
||
|
|
// idle tasks.
|
||
|
|
BOOL m_fKeepInList; // Whether to keep this run in the idle list
|
||
|
|
// after starting it (set for jobs with idle
|
||
|
|
// triggers)
|
||
|
|
public:
|
||
|
|
BOOL m_fStarted; // Whether the run was started since the last
|
||
|
|
// idle period began
|
||
|
|
};
|
||
|
|
|
||
|
|
//+----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Run object list class
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
class CRunList
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CRunList();
|
||
|
|
~CRunList();
|
||
|
|
|
||
|
|
void FreeList(void);
|
||
|
|
CRun * GetFirstJob(void) {return m_RunHead.Next();}
|
||
|
|
BOOL IsEmpty() {return m_RunHead.Next() == &m_RunHead;}
|
||
|
|
//
|
||
|
|
// The following members allow the list to be used as a simple, unsorted,
|
||
|
|
// (doubly) linked list.
|
||
|
|
//
|
||
|
|
void Add(CRun * pRun);
|
||
|
|
HRESULT AddCopy(CRun * pRun);
|
||
|
|
|
||
|
|
protected:
|
||
|
|
CRun m_RunHead;
|
||
|
|
};
|
||
|
|
|
||
|
|
class CTimeRunList : private CRunList
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void FreeList(void) {CRunList::FreeList();}
|
||
|
|
CRun * GetFirstJob(void) {return CRunList::GetFirstJob();}
|
||
|
|
BOOL IsEmpty() {return CRunList::IsEmpty();}
|
||
|
|
//
|
||
|
|
// The following members allow the list to be used as a sorted queue:
|
||
|
|
//
|
||
|
|
HRESULT AddSorted(FILETIME ftRun, FILETIME ftDeadline,
|
||
|
|
FILETIME ftKillTime,
|
||
|
|
LPTSTR ptszJobName, DWORD dwJobFlags,
|
||
|
|
DWORD dwMaxRunTime, WORD wIdleWait,
|
||
|
|
WORD * pCount, WORD cLimit);
|
||
|
|
CRun * Pop(void);
|
||
|
|
HRESULT PeekHeadTime(LPFILETIME pft);
|
||
|
|
HRESULT MakeSysTimeArray(LPSYSTEMTIME *, WORD *);
|
||
|
|
};
|
||
|
|
|
||
|
|
class CIdleRunList : private CRunList
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void FreeList(void);
|
||
|
|
CRun * GetFirstJob(void) {return CRunList::GetFirstJob();}
|
||
|
|
//
|
||
|
|
// The following members allow the list to be used as a sorted queue,
|
||
|
|
// sorted on idle wait times. The member at the head of the queue has
|
||
|
|
// the least idle wait time.
|
||
|
|
//
|
||
|
|
void AddSortedByIdleWait(CRun * pRun);
|
||
|
|
WORD GetFirstWait(void);
|
||
|
|
void MarkNoneStarted(void);
|
||
|
|
void FreeExpiredOrRegenerated();
|
||
|
|
};
|
||
|
|
|
||
|
|
//+----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Method: CRunList::CRunList
|
||
|
|
//
|
||
|
|
// Synopsis: Constructor
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
inline CRunList::CRunList(void)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Set the head node to point to itself. Note that the head node uses
|
||
|
|
// the default ctor which sets the FILETIME member to {0, 0}. This null
|
||
|
|
// FILETIME will be used as a marker for the head of the doubly linked
|
||
|
|
// list.
|
||
|
|
//
|
||
|
|
m_RunHead.SetNext(&m_RunHead);
|
||
|
|
m_RunHead.SetPrev(&m_RunHead);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Method: CRunList::CRunList
|
||
|
|
//
|
||
|
|
// Synopsis: Destructor
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
inline CRunList::~CRunList(void)
|
||
|
|
{
|
||
|
|
FreeList();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CRunList::Add
|
||
|
|
//
|
||
|
|
// Synopsis: Add an element to the unsorted list.
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
inline void
|
||
|
|
CRunList::Add(CRun * pAdd)
|
||
|
|
{
|
||
|
|
pAdd->LinkAfter(&m_RunHead);
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // __RUNOBJ_HXX__
|