job.c File Reference

#include "precomp.h"

Include dependency graph for job.c:

Go to the source code of this file.

Classes
struct	_SCHEDULE

Typedefs
typedef struct _SCHEDULE	SCHEDULE
typedef struct _SCHEDULE	PSCHEDULE

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (schedsvc)
VOID	GetNextJobTimeout (HANDLE hTimer)
VOID	RunCurrentJobs (VOID)
static VOID	GetJobName (HKEY hJobsKey, PWSTR pszJobName)
LONG	SaveJob (_In_ PJOB pJob)
LONG	DeleteJob (_In_ PJOB pJob)
LONG	LoadJobs (VOID)
static WORD	DaysOfMonth (WORD wMonth, WORD wYear)
VOID	CalculateNextStartTime (_In_ PJOB pJob)

Variables
DWORD	dwNextJobId = 0
DWORD	dwJobCount = 0
LIST_ENTRY	JobListHead
RTL_RESOURCE	JobListLock
LIST_ENTRY	StartListHead
RTL_RESOURCE	StartListLock
FILETIME	NextJobStartTime
BOOL	bValidNextJobStartTime = FALSE
static WORD	wDaysArray [13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}

Typedef Documentation

PSCHEDULE

typedef struct _SCHEDULE PSCHEDULE

SCHEDULE

typedef struct _SCHEDULE SCHEDULE

Function Documentation

CalculateNextStartTime()

VOID CalculateNextStartTime

(

_In_ PJOB

pJob

)

Definition at line 467 of file job.c.

{
    SYSTEMTIME CurrentSystemTime, StartSystemTime;
    FILETIME StartFileTime;
    WORD wDaysOffset, wTempOffset, i, wJobDayOfWeek, wJobDayOfMonth;
    DWORD_PTR CurrentTimeMs;
    BOOL bDaysOffsetValid;
    ULARGE_INTEGER LocalStartTime;
 
    TRACE("CalculateNextStartTime(%p)\n", pJob);
    TRACE("JobTime: %lu\n", pJob->JobTime);
    TRACE("DaysOfWeek: 0x%x\n", pJob->DaysOfWeek);
    TRACE("DaysOfMonth: 0x%x\n", pJob->DaysOfMonth);
 
    GetLocalTime(&CurrentSystemTime);
 
    CurrentTimeMs = (DWORD_PTR)CurrentSystemTime.wHour * 3600000 +
                    (DWORD_PTR)CurrentSystemTime.wMinute * 60000;
 
    bDaysOffsetValid = FALSE;
    wDaysOffset = 0;
    if ((pJob->DaysOfWeek == 0) && (pJob->DaysOfMonth == 0))
    {
        if (CurrentTimeMs >= pJob->JobTime)
        {
            TRACE("Tomorrow!\n");
            wDaysOffset = 1;
        }
 
        bDaysOffsetValid = TRUE;
    }
    else
    {
        if (pJob->DaysOfWeek != 0)
        {
            TRACE("DaysOfWeek!\n");
            for (i = 0; i < 7; i++)
            {
                if (pJob->DaysOfWeek & (1 << i))
                {
                    /* Adjust the range */
                    wJobDayOfWeek = (i + 1) % 7;
                    TRACE("wJobDayOfWeek: %hu\n", wJobDayOfWeek);
                    TRACE("CurrentSystemTime.wDayOfWeek: %hu\n", CurrentSystemTime.wDayOfWeek);
 
                    /* Calculate the days offset */
                    if ((CurrentSystemTime.wDayOfWeek > wJobDayOfWeek ) ||
                        ((CurrentSystemTime.wDayOfWeek == wJobDayOfWeek) && (CurrentTimeMs >= pJob->JobTime)))
                    {
                        wTempOffset = 7 - CurrentSystemTime.wDayOfWeek + wJobDayOfWeek;
                        TRACE("wTempOffset: %hu\n", wTempOffset);
                    }
                    else
                    {
                        wTempOffset = wJobDayOfWeek - CurrentSystemTime.wDayOfWeek;
                        TRACE("wTempOffset: %hu\n", wTempOffset);
                    }
 
                    /* Use the smallest offset */
                    if (bDaysOffsetValid == FALSE)
                    {
                        wDaysOffset = wTempOffset;
                        bDaysOffsetValid = TRUE;
                    }
                    else
                    {
                        if (wTempOffset < wDaysOffset)
                            wDaysOffset = wTempOffset;
                    }
                }
            }
        }
 
        if (pJob->DaysOfMonth != 0)
        {
            FIXME("Support DaysOfMonth!\n");
            for (i = 0; i < 31; i++)
            {
                if (pJob->DaysOfMonth & (1 << i))
                {
                    /* Adjust the range */
                    wJobDayOfMonth = i + 1;
                    FIXME("wJobDayOfMonth: %hu\n", wJobDayOfMonth);
                    FIXME("CurrentSystemTime.wDay: %hu\n", CurrentSystemTime.wDay);
 
                    if ((CurrentSystemTime.wDay > wJobDayOfMonth) ||
                        ((CurrentSystemTime.wDay == wJobDayOfMonth) && (CurrentTimeMs >= pJob->JobTime)))
                    {
                        wTempOffset = DaysOfMonth(CurrentSystemTime.wMonth, CurrentSystemTime.wYear) -
                                      CurrentSystemTime.wDay + wJobDayOfMonth;
                        FIXME("wTempOffset: %hu\n", wTempOffset);
                    }
                    else
                    {
                        wTempOffset = wJobDayOfMonth - CurrentSystemTime.wDay;
                        FIXME("wTempOffset: %hu\n", wTempOffset);
                    }
 
                    /* Use the smallest offset */
                    if (bDaysOffsetValid == FALSE)
                    {
                        wDaysOffset = wTempOffset;
                        bDaysOffsetValid = TRUE;
                    }
                    else
                    {
                        if (wTempOffset < wDaysOffset)
                            wDaysOffset = wTempOffset;
                    }
                }
            }
        }
    }
 
    TRACE("wDaysOffset: %hu\n", wDaysOffset);
 
    CopyMemory(&StartSystemTime, &CurrentSystemTime, sizeof(SYSTEMTIME));
 
    StartSystemTime.wMilliseconds = 0;
    StartSystemTime.wSecond = 0;
    StartSystemTime.wHour = (WORD)(pJob->JobTime / 3600000);
    StartSystemTime.wMinute = (WORD)((pJob->JobTime % 3600000) / 60000);
 
    SystemTimeToFileTime(&StartSystemTime, &StartFileTime);
 
    LocalStartTime.u.LowPart = StartFileTime.dwLowDateTime;
    LocalStartTime.u.HighPart = StartFileTime.dwHighDateTime;
    if (bDaysOffsetValid && wDaysOffset != 0)
    {
        LocalStartTime.QuadPart += ((ULONGLONG)wDaysOffset * 24 * 60 * 60 * 10000);
    }
 
    pJob->StartTime.dwLowDateTime = LocalStartTime.u.LowPart;
    pJob->StartTime.dwHighDateTime = LocalStartTime.u.HighPart;
}

Referenced by LoadJobs(), and NetrJobAdd().

DaysOfMonth()

static WORD DaysOfMonth ( WORD  wMonth, WORD  wYear  )

static

Definition at line 455 of file job.c.

{
    if (wMonth == 2 && wYear % 4 == 0 && wYear % 400 != 0)
        return 29;
 
    return wDaysArray[wMonth];
}

Referenced by CalculateNextStartTime(), and PrintAllJobs().

DeleteJob()

LONG DeleteJob

(

_In_ PJOB

pJob

)

Definition at line 284 of file job.c.

{
    HKEY hJobsKey = NULL;
    LONG lError;
 
    TRACE("DeleteJob()\n");
 
    lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                             L"System\\CurrentControlSet\\Services\\Schedule\\Jobs",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_WRITE,
                             NULL,
                             &hJobsKey,
                             NULL);
    if (lError != ERROR_SUCCESS)
        goto done;
 
    lError = RegDeleteKey(hJobsKey,
                          pJob->Name);
    if (lError != ERROR_SUCCESS)
        goto done;
 
done:
    if (hJobsKey != NULL)
        RegCloseKey(hJobsKey);
 
    return lError;
}

GetJobName()

static VOID GetJobName ( HKEY  hJobsKey, PWSTR  pszJobName  )

static

Definition at line 179 of file job.c.

{
    WCHAR szNameBuffer[JOB_NAME_LENGTH];
    FILETIME SystemTime;
    ULONG ulSeed, ulValue;
    HKEY hKey;
    LONG lError;
 
    GetSystemTimeAsFileTime(&SystemTime);
    ulSeed = SystemTime.dwLowDateTime;
    for (;;)
    {
        ulValue = RtlRandomEx(&ulSeed);
        swprintf(szNameBuffer, L"%08lx", ulValue);
 
        hKey = NULL;
        lError = RegOpenKeyEx(hJobsKey,
                              szNameBuffer,
                              0,
                              KEY_READ,
                              &hKey);
        if (lError != ERROR_SUCCESS)
        {
            wcscpy(pszJobName, szNameBuffer);
            return;
        }
 
        RegCloseKey(hKey);
    }
}

Referenced by SaveJob().

GetNextJobTimeout()

VOID GetNextJobTimeout

(

HANDLE

hTimer

)

Definition at line 44 of file job.c.

{
    PLIST_ENTRY CurrentEntry;
    FILETIME DueTime;
    PJOB CurrentJob;
 
    bValidNextJobStartTime = FALSE;
    CurrentEntry = JobListHead.Flink;
    while (CurrentEntry != &JobListHead)
    {
        CurrentJob = CONTAINING_RECORD(CurrentEntry, JOB, JobEntry);
 
        if (bValidNextJobStartTime == FALSE)
        {
            CopyMemory(&NextJobStartTime, &CurrentJob->StartTime, sizeof(FILETIME));
            bValidNextJobStartTime = TRUE;
        }
        else
        {
            if (CompareFileTime(&NextJobStartTime, &CurrentJob->StartTime) > 0)
                CopyMemory(&NextJobStartTime, &CurrentJob->StartTime, sizeof(FILETIME));
        }
 
        CurrentEntry = CurrentEntry->Flink;
    }
 
    if (bValidNextJobStartTime == FALSE)
    {
        TRACE("No valid job!\n");
        return;
    }
 
    LocalFileTimeToFileTime(&DueTime, &NextJobStartTime);
 
    SetWaitableTimer(hTimer,
                     (PLARGE_INTEGER)&DueTime,
                     0,
                     NULL,
                     NULL,
                     TRUE);
}

Referenced by SchedServiceMain().

LoadJobs()

LONG LoadJobs

(

VOID

)

Definition at line 318 of file job.c.

{
    SCHEDULE Schedule;
    WCHAR szNameBuffer[JOB_NAME_LENGTH];
    DWORD dwNameLength, dwIndex, dwSize;
    HKEY hJobsKey = NULL, hJobKey = NULL;
    PJOB pJob = NULL;
    LONG lError;
 
    TRACE("LoadJobs()\n");
 
    lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                             L"System\\CurrentControlSet\\Services\\Schedule\\Jobs",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_READ,
                             NULL,
                             &hJobsKey,
                             NULL);
    if (lError != ERROR_SUCCESS)
        goto done;
 
    for (dwIndex = 0; dwIndex < 1000; dwIndex++)
    {
        dwNameLength = JOB_NAME_LENGTH;
        lError = RegEnumKeyEx(hJobsKey,
                              dwIndex,
                              szNameBuffer,
                              &dwNameLength,
                              NULL,
                              NULL,
                              NULL,
                              NULL);
        if (lError != ERROR_SUCCESS)
        {
            lError = ERROR_SUCCESS;
            break;
        }
 
        TRACE("KeyName: %S\n", szNameBuffer);
 
        lError = RegOpenKeyEx(hJobsKey,
                              szNameBuffer,
                              0,
                              KEY_READ,
                              &hJobKey);
        if (lError != ERROR_SUCCESS)
            break;
 
        dwSize = sizeof(SCHEDULE);
        lError = RegQueryValueEx(hJobKey,
                                 L"Schedule",
                                 NULL,
                                 NULL,
                                 (PBYTE)&Schedule,
                                 &dwSize);
        if (lError == ERROR_SUCCESS)
        {
            dwSize = 0;
            RegQueryValueEx(hJobKey,
                            L"Command",
                            NULL,
                            NULL,
                            NULL,
                            &dwSize);
            if (dwSize != 0)
            {
                /* Allocate a new job object */
                pJob = HeapAlloc(GetProcessHeap(),
                                 HEAP_ZERO_MEMORY,
                                 sizeof(JOB) + dwSize - sizeof(WCHAR));
                if (pJob == NULL)
                {
                    lError = ERROR_OUTOFMEMORY;
                    break;
                }
 
                lError = RegQueryValueEx(hJobKey,
                                         L"Command",
                                         NULL,
                                         NULL,
                                         (PBYTE)pJob->Command,
                                         &dwSize);
                if (lError != ERROR_SUCCESS)
                    break;
 
                wcscpy(pJob->Name, szNameBuffer);
                pJob->JobTime = Schedule.JobTime;
                pJob->DaysOfMonth = Schedule.DaysOfMonth;
                pJob->DaysOfWeek = Schedule.DaysOfWeek;
                pJob->Flags = Schedule.Flags;
 
                /* Acquire the job list lock exclusively */
                RtlAcquireResourceExclusive(&JobListLock, TRUE);
 
                /* Assign a new job ID */
                pJob->JobId = dwNextJobId++;
                dwJobCount++;
 
                /* Append the new job to the job list */
                InsertTailList(&JobListHead, &pJob->JobEntry);
 
                /* Calculate the next start time */
                CalculateNextStartTime(pJob);
 
#if 0
                DumpStartList(&StartListHead);
#endif
 
                /* Release the job list lock */
                RtlReleaseResource(&JobListLock);
 
                pJob = NULL;
            }
        }
 
        RegCloseKey(hJobKey);
        hJobKey = NULL;
    }
 
done:
    if (pJob != NULL)
        HeapFree(GetProcessHeap(), 0, pJob);
 
    if (hJobKey != NULL)
        RegCloseKey(hJobKey);
 
    if (hJobsKey != NULL)
        RegCloseKey(hJobsKey);
 
    return lError;
}

Referenced by ServiceInit().

RunCurrentJobs()

VOID RunCurrentJobs

(

VOID

)

Definition at line 122 of file job.c.

{
    PROCESS_INFORMATION ProcessInformation;
    STARTUPINFOW StartupInfo;
    PLIST_ENTRY CurrentEntry;
    PJOB CurrentJob;
    BOOL bRet;
 
    CurrentEntry = JobListHead.Flink;
    while (CurrentEntry != &JobListHead)
    {
        CurrentJob = CONTAINING_RECORD(CurrentEntry, JOB, JobEntry);
 
        if (CompareFileTime(&NextJobStartTime, &CurrentJob->StartTime) == 0)
        {
            TRACE("Run job %ld: %S\n", CurrentJob->JobId, CurrentJob->Command);
 
            ZeroMemory(&StartupInfo, sizeof(StartupInfo));
            StartupInfo.cb = sizeof(StartupInfo);
            StartupInfo.lpTitle = CurrentJob->Command;
            StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
            StartupInfo.wShowWindow = SW_SHOWDEFAULT;
 
            if ((CurrentJob->Flags & JOB_NONINTERACTIVE) == 0)
            {
                StartupInfo.dwFlags |= STARTF_INHERITDESKTOP;
                StartupInfo.lpDesktop = L"WinSta0\\Default";
            }
 
            bRet = CreateProcessW(NULL,
                                  CurrentJob->Command,
                                  NULL,
                                  NULL,
                                  FALSE,
                                  CREATE_NEW_CONSOLE,
                                  NULL,
                                  NULL,
                                  &StartupInfo,
                                  &ProcessInformation);
            if (bRet == FALSE)
            {
                ERR("CreateProcessW() failed (Error %lu)\n", GetLastError());
            }
            else
            {
                CloseHandle(ProcessInformation.hThread);
                CloseHandle(ProcessInformation.hProcess);
            }
        }
 
        CurrentEntry = CurrentEntry->Flink;
    }
}

Referenced by SchedServiceMain().

SaveJob()

LONG SaveJob

(

_In_ PJOB

pJob

)

Definition at line 214 of file job.c.

{
    SCHEDULE Schedule;
    HKEY hJobsKey = NULL, hJobKey = NULL;
    LONG lError;
 
    TRACE("SaveJob()\n");
 
    lError = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                             L"System\\CurrentControlSet\\Services\\Schedule\\Jobs",
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_WRITE,
                             NULL,
                             &hJobsKey,
                             NULL);
    if (lError != ERROR_SUCCESS)
        goto done;
 
    GetJobName(hJobsKey, pJob->Name);
 
    lError = RegCreateKeyExW(hJobsKey,
                             pJob->Name,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_WRITE,
                             NULL,
                             &hJobKey,
                             NULL);
    if (lError != ERROR_SUCCESS)
        goto done;
 
    Schedule.JobTime = pJob->JobTime;
    Schedule.DaysOfMonth = pJob->DaysOfMonth;
    Schedule.DaysOfWeek = pJob->DaysOfWeek;
    Schedule.Flags = pJob->Flags;
 
    lError = RegSetValueEx(hJobKey,
                           L"Schedule",
                           0,
                           REG_BINARY,
                           (PBYTE)&Schedule,
                           sizeof(Schedule));
    if (lError != ERROR_SUCCESS)
        goto done;
 
    lError = RegSetValueEx(hJobKey,
                           L"Command",
                           0,
                           REG_SZ,
                           (PBYTE)pJob->Command,
                           (wcslen(pJob->Command) + 1) * sizeof(WCHAR));
    if (lError != ERROR_SUCCESS)
        goto done;
 
done:
    if (hJobKey != NULL)
        RegCloseKey(hJobKey);
 
    if (hJobsKey != NULL)
        RegCloseKey(hJobsKey);
 
    return lError;
}

Referenced by NetrJobAdd().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

schedsvc

)

Variable Documentation

bValidNextJobStartTime

BOOL bValidNextJobStartTime = FALSE

Definition at line 35 of file job.c.

Referenced by GetNextJobTimeout().

dwJobCount

DWORD dwJobCount = 0

Definition at line 28 of file job.c.

Referenced by LoadJobs(), NetrJobAdd(), NetrJobDel(), and NetrJobEnum().

dwNextJobId

DWORD dwNextJobId = 0

Definition at line 27 of file job.c.

Referenced by LoadJobs(), and NetrJobAdd().

JobListHead

LIST_ENTRY JobListHead

Definition at line 29 of file job.c.

Referenced by GetNextJobTimeout(), LoadJobs(), NetrJobAdd(), NetrJobDel(), NetrJobEnum(), NetrJobGetInfo(), RunCurrentJobs(), and ServiceInit().

JobListLock

RTL_RESOURCE JobListLock

Definition at line 30 of file job.c.

Referenced by LoadJobs(), NetrJobAdd(), NetrJobDel(), NetrJobEnum(), NetrJobGetInfo(), SchedServiceMain(), and ServiceInit().

NextJobStartTime

FILETIME NextJobStartTime

Definition at line 34 of file job.c.

Referenced by GetNextJobTimeout(), and RunCurrentJobs().

StartListHead

LIST_ENTRY StartListHead

Definition at line 32 of file job.c.

Referenced by LoadJobs(), NetrJobAdd(), NetrJobDel(), and ServiceInit().

StartListLock

RTL_RESOURCE StartListLock

Definition at line 33 of file job.c.

Referenced by ServiceInit().

wDaysArray

WORD wDaysArray[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}

static

Definition at line 38 of file job.c.

Referenced by DaysOfMonth().