windows-server-2003/admin/services/sched/inc/runobj.hxx

//+---------------------------------------------------------------------------
//
//  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); }

    
    // this function takes ownership of the handles
    // will release / close them on destruction
    // bCloseUserHandle == FALSE will prevent dtor from closing handle
    void SetProfileHandles(HANDLE hUser, HANDLE hProfile, BOOL bCloseUserHandle) 
    {                
        m_hUserToken = hUser;
        m_hProfile = hProfile;

        m_bCloseUserHandle = bCloseUserHandle;
    }

	HRESULT	SetDesktop( LPCTSTR ptszDesktop );
	
	LPTSTR  GetDesktop( void ) {
				return m_ptszDesktop;
			}

	HRESULT	SetStation( LPCTSTR ptszStation );

	LPTSTR  GetStation( void ) {
				return m_ptszStation;
			}

    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
    HANDLE      m_hUserToken;   // User token
    HANDLE      m_hProfile;     // User profile
	LPTSTR      m_ptszDesktop;  //Windows Desktop
	LPTSTR		m_ptszStation;	//WindowsStation
    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)
    BOOL        m_bCloseUserHandle; // if TRUE, m_hUserToken is ClosedHandle'd in dtor
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__