You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1402 lines
38 KiB
1402 lines
38 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Time.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the absolute time conversion routines for NT.
|
|
|
|
Absolute LARGE_INTEGER in NT is represented by a 64-bit large integer accurate
|
|
to 100ns resolution. The smallest time resolution used by this package
|
|
is One millisecond. The basis for NT time is the start of 1601 which
|
|
was chosen because it is the start of a new quadricentury. Some facts
|
|
to note are:
|
|
|
|
o At 100ns resolution 32 bits is good for about 429 seconds (or 7 minutes)
|
|
|
|
o At 100ns resolution a large integer (i.e., 63 bits) is good for
|
|
about 29,227 years, or around 10,675,199 days
|
|
|
|
o At 1 second resolution 31 bits is good for about 68 years
|
|
|
|
o At 1 second resolution 32 bits is good for about 136 years
|
|
|
|
o 100ns Time (ignoring time less than a millisecond) can be expressed
|
|
as two values, Days and Milliseconds. Where Days is the number of
|
|
whole days and Milliseconds is the number of milliseconds for the
|
|
partial day. Both of these values are ULONG.
|
|
|
|
Given these facts most of the conversions are done by first splitting
|
|
LARGE_INTEGER into Days and Milliseconds.
|
|
|
|
Author:
|
|
|
|
Gary Kimura [GaryKi] 26-Aug-1989
|
|
|
|
Environment:
|
|
|
|
Pure utility routine
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "ntrtlp.h"
|
|
|
|
#if defined(ALLOC_PRAGMA) && defined(NTOS_KERNEL_RUNTIME)
|
|
ULONG
|
|
ElapsedDaysToYears (
|
|
IN ULONG ElapsedDays
|
|
);
|
|
static
|
|
VOID
|
|
TimeToDaysAndFraction (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PULONG ElapsedDays,
|
|
OUT PULONG Milliseconds
|
|
);
|
|
VOID
|
|
DaysAndFractionToTime (
|
|
IN ULONG ElapsedDays,
|
|
IN ULONG Milliseconds,
|
|
OUT PLARGE_INTEGER Time
|
|
);
|
|
|
|
ULONG
|
|
RtlGetTickCount (
|
|
VOID
|
|
);
|
|
|
|
#pragma alloc_text(PAGE, RtlCutoverTimeToSystemTime)
|
|
#pragma alloc_text(PAGE, RtlTimeToElapsedTimeFields)
|
|
#pragma alloc_text(PAGE, RtlSystemTimeToLocalTime)
|
|
#pragma alloc_text(PAGE, RtlLocalTimeToSystemTime)
|
|
#pragma alloc_text(INIT, RtlGetTickCount)
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// The following two tables map a day offset within a year to the month
|
|
// containing the day. Both tables are zero based. For example, day
|
|
// offset of 0 to 30 map to 0 (which is Jan).
|
|
//
|
|
|
|
CONST UCHAR LeapYearDayToMonth[366] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // January
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // February
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // March
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // April
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // May
|
|
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, // June
|
|
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, // July
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // August
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, // September
|
|
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // October
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, // November
|
|
11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11}; // December
|
|
|
|
CONST UCHAR NormalYearDayToMonth[365] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // January
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // February
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // March
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // April
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // May
|
|
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, // June
|
|
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, // July
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // August
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, // September
|
|
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // October
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, // November
|
|
11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11}; // December
|
|
|
|
//
|
|
// The following two tables map a month index to the number of days preceding
|
|
// the month in the year. Both tables are zero based. For example, 1 (Feb)
|
|
// has 31 days preceding it. To help calculate the maximum number of days
|
|
// in a month each table has 13 entries, so the number of days in a month
|
|
// of index i is the table entry of i+1 minus the table entry of i.
|
|
//
|
|
|
|
CONST CSHORT LeapYearDaysPrecedingMonth[13] = {
|
|
0, // January
|
|
31, // February
|
|
31+29, // March
|
|
31+29+31, // April
|
|
31+29+31+30, // May
|
|
31+29+31+30+31, // June
|
|
31+29+31+30+31+30, // July
|
|
31+29+31+30+31+30+31, // August
|
|
31+29+31+30+31+30+31+31, // September
|
|
31+29+31+30+31+30+31+31+30, // October
|
|
31+29+31+30+31+30+31+31+30+31, // November
|
|
31+29+31+30+31+30+31+31+30+31+30, // December
|
|
31+29+31+30+31+30+31+31+30+31+30+31};
|
|
|
|
CONST CSHORT NormalYearDaysPrecedingMonth[13] = {
|
|
0, // January
|
|
31, // February
|
|
31+28, // March
|
|
31+28+31, // April
|
|
31+28+31+30, // May
|
|
31+28+31+30+31, // June
|
|
31+28+31+30+31+30, // July
|
|
31+28+31+30+31+30+31, // August
|
|
31+28+31+30+31+30+31+31, // September
|
|
31+28+31+30+31+30+31+31+30, // October
|
|
31+28+31+30+31+30+31+31+30+31, // November
|
|
31+28+31+30+31+30+31+31+30+31+30, // December
|
|
31+28+31+30+31+30+31+31+30+31+30+31};
|
|
|
|
|
|
//
|
|
// The following definitions and declarations are some important constants
|
|
// used in the time conversion routines
|
|
//
|
|
|
|
//
|
|
// This is the week day that January 1st, 1601 fell on (a Monday)
|
|
//
|
|
|
|
#define WEEKDAY_OF_1601 1
|
|
|
|
//
|
|
// These are known constants used to convert 1970 and 1980 times to 1601
|
|
// times. They are the number of seconds from the 1601 base to the start
|
|
// of 1970 and the start of 1980. The number of seconds from 1601 to
|
|
// 1970 is 369 years worth, or (369 * 365) + 89 leap days = 134774 days, or
|
|
// 134774 * 86400 seconds, which is equal to the large integer defined
|
|
// below. The number of seconds from 1601 to 1980 is 379 years worth, or etc.
|
|
//
|
|
|
|
const LARGE_INTEGER SecondsToStartOf1970 = {0xb6109100, 0x00000002};
|
|
|
|
const LARGE_INTEGER SecondsToStartOf1980 = {0xc8df3700, 0x00000002};
|
|
|
|
//
|
|
// These are the magic numbers needed to do our extended division. The
|
|
// only numbers we ever need to divide by are
|
|
//
|
|
// 10,000 = convert 100ns tics to millisecond tics
|
|
//
|
|
// 10,000,000 = convert 100ns tics to one second tics
|
|
//
|
|
// 86,400,000 = convert Millisecond tics to one day tics
|
|
//
|
|
|
|
const LARGE_INTEGER Magic10000 = {0xe219652c, 0xd1b71758};
|
|
#define SHIFT10000 13
|
|
|
|
const LARGE_INTEGER Magic10000000 = {0xe57a42bd, 0xd6bf94d5};
|
|
#define SHIFT10000000 23
|
|
|
|
const LARGE_INTEGER Magic86400000 = {0xfa67b90e, 0xc6d750eb};
|
|
#define SHIFT86400000 26
|
|
|
|
//
|
|
// To make the code more readable we'll also define some macros to
|
|
// do the actual division for use
|
|
//
|
|
|
|
#define Convert100nsToMilliseconds(LARGE_INTEGER) ( \
|
|
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000, SHIFT10000 ) \
|
|
)
|
|
|
|
#define ConvertMillisecondsTo100ns(MILLISECONDS) ( \
|
|
RtlExtendedIntegerMultiply( (MILLISECONDS), 10000 ) \
|
|
)
|
|
|
|
#define Convert100nsToSeconds(LARGE_INTEGER) ( \
|
|
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000000, SHIFT10000000 ) \
|
|
)
|
|
|
|
#define ConvertSecondsTo100ns(SECONDS) ( \
|
|
RtlExtendedIntegerMultiply( (SECONDS), 10000000 ) \
|
|
)
|
|
|
|
#define ConvertMillisecondsToDays(LARGE_INTEGER) ( \
|
|
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic86400000, SHIFT86400000 ) \
|
|
)
|
|
|
|
#define ConvertDaysToMilliseconds(DAYS) ( \
|
|
Int32x32To64( (DAYS), 86400000 ) \
|
|
)
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
ULONG
|
|
ElapsedDaysToYears (
|
|
IN ULONG ElapsedDays
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine computes the number of total years contained in the indicated
|
|
number of elapsed days. The computation is to first compute the number of
|
|
400 years and subtract that it, then do the 100 years and subtract that out,
|
|
then do the number of 4 years and subtract that out. Then what we have left
|
|
is the number of days with in a normalized 4 year block. Normalized being that
|
|
the first three years are not leap years.
|
|
|
|
Arguments:
|
|
|
|
ElapsedDays - Supplies the number of days to use
|
|
|
|
Return Value:
|
|
|
|
ULONG - Returns the number of whole years contained within the input number
|
|
of days.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG NumberOf400s;
|
|
ULONG NumberOf100s;
|
|
ULONG NumberOf4s;
|
|
ULONG Years;
|
|
|
|
//
|
|
// A 400 year time block is 365*400 + 400/4 - 400/100 + 400/400 = 146097 days
|
|
// long. So we simply compute the number of whole 400 year block and the
|
|
// the number days contained in those whole blocks, and subtract if from the
|
|
// elapsed day total
|
|
//
|
|
|
|
NumberOf400s = ElapsedDays / 146097;
|
|
ElapsedDays -= NumberOf400s * 146097;
|
|
|
|
//
|
|
// A 100 year time block is 365*100 + 100/4 - 100/100 = 36524 days long.
|
|
// The computation for the number of 100 year blocks is biased by 3/4 days per
|
|
// 100 years to account for the extra leap day thrown in on the last year
|
|
// of each 400 year block.
|
|
//
|
|
|
|
NumberOf100s = (ElapsedDays * 100 + 75) / 3652425;
|
|
ElapsedDays -= NumberOf100s * 36524;
|
|
|
|
//
|
|
// A 4 year time block is 365*4 + 4/4 = 1461 days long.
|
|
//
|
|
|
|
NumberOf4s = ElapsedDays / 1461;
|
|
ElapsedDays -= NumberOf4s * 1461;
|
|
|
|
//
|
|
// Now the number of whole years is the number of 400 year blocks times 400,
|
|
// 100 year blocks time 100, 4 year blocks times 4, and the number of elapsed
|
|
// whole years, taking into account the 3/4 day per year needed to handle the
|
|
// leap year.
|
|
//
|
|
|
|
Years = (NumberOf400s * 400) +
|
|
(NumberOf100s * 100) +
|
|
(NumberOf4s * 4) +
|
|
(ElapsedDays * 100 + 75) / 36525;
|
|
|
|
return Years;
|
|
}
|
|
|
|
|
|
//
|
|
// ULONG
|
|
// NumberOfLeapYears (
|
|
// IN ULONG ElapsedYears
|
|
// );
|
|
//
|
|
// The number of leap years is simply the number of years divided by 4
|
|
// minus years divided by 100 plus years divided by 400. This says
|
|
// that every four years is a leap year except centuries, and the
|
|
// exception to the exception is the quadricenturies
|
|
//
|
|
|
|
#define NumberOfLeapYears(YEARS) ( \
|
|
((YEARS) / 4) - ((YEARS) / 100) + ((YEARS) / 400) \
|
|
)
|
|
|
|
//
|
|
// ULONG
|
|
// ElapsedYearsToDays (
|
|
// IN ULONG ElapsedYears
|
|
// );
|
|
//
|
|
// The number of days contained in elapsed years is simply the number
|
|
// of years times 365 (because every year has at least 365 days) plus
|
|
// the number of leap years there are (i.e., the number of 366 days years)
|
|
//
|
|
|
|
#define ElapsedYearsToDays(YEARS) ( \
|
|
((YEARS) * 365) + NumberOfLeapYears(YEARS) \
|
|
)
|
|
|
|
//
|
|
// BOOLEAN
|
|
// IsLeapYear (
|
|
// IN ULONG ElapsedYears
|
|
// );
|
|
//
|
|
// If it is an even 400 or a non century leapyear then the
|
|
// answer is true otherwise it's false
|
|
//
|
|
|
|
#define IsLeapYear(YEARS) ( \
|
|
(((YEARS) % 400 == 0) || \
|
|
((YEARS) % 100 != 0) && ((YEARS) % 4 == 0)) ? \
|
|
TRUE \
|
|
: \
|
|
FALSE \
|
|
)
|
|
|
|
//
|
|
// ULONG
|
|
// MaxDaysInMonth (
|
|
// IN ULONG Year,
|
|
// IN ULONG Month
|
|
// );
|
|
//
|
|
// The maximum number of days in a month depend on the year and month.
|
|
// It is the difference between the days to the month and the days
|
|
// to the following month
|
|
//
|
|
|
|
#define MaxDaysInMonth(YEAR,MONTH) ( \
|
|
IsLeapYear(YEAR) ? \
|
|
LeapYearDaysPrecedingMonth[(MONTH) + 1] - \
|
|
LeapYearDaysPrecedingMonth[(MONTH)] \
|
|
: \
|
|
NormalYearDaysPrecedingMonth[(MONTH) + 1] - \
|
|
NormalYearDaysPrecedingMonth[(MONTH)] \
|
|
)
|
|
|
|
|
|
|
|
//
|
|
// Internal Support routine
|
|
//
|
|
|
|
static
|
|
VOID
|
|
TimeToDaysAndFraction (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PULONG ElapsedDays,
|
|
OUT PULONG Milliseconds
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input 64-bit time value to the number
|
|
of total elapsed days and the number of milliseconds in the
|
|
partial day.
|
|
|
|
Arguments:
|
|
|
|
Time - Supplies the input time to convert from
|
|
|
|
ElapsedDays - Receives the number of elapsed days
|
|
|
|
Milliseconds - Receives the number of milliseconds in the partial day
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER TotalMilliseconds;
|
|
LARGE_INTEGER Temp;
|
|
|
|
//
|
|
// Convert the input time to total milliseconds
|
|
//
|
|
|
|
TotalMilliseconds = Convert100nsToMilliseconds( *(PLARGE_INTEGER)Time );
|
|
|
|
//
|
|
// Convert milliseconds to total days
|
|
//
|
|
|
|
Temp = ConvertMillisecondsToDays( TotalMilliseconds );
|
|
|
|
//
|
|
// Set the elapsed days from temp, we've divided it enough so that
|
|
// the high part must be zero.
|
|
//
|
|
|
|
*ElapsedDays = Temp.LowPart;
|
|
|
|
//
|
|
// Calculate the exact number of milliseconds in the elapsed days
|
|
// and subtract that from the total milliseconds to figure out
|
|
// the number of milliseconds left in the partial day
|
|
//
|
|
|
|
Temp.QuadPart = ConvertDaysToMilliseconds( *ElapsedDays );
|
|
|
|
Temp.QuadPart = TotalMilliseconds.QuadPart - Temp.QuadPart;
|
|
|
|
//
|
|
// Set the fraction part from temp, the total number of milliseconds in
|
|
// a day guarantees that the high part must be zero.
|
|
//
|
|
|
|
*Milliseconds = Temp.LowPart;
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Internal Support routine
|
|
//
|
|
|
|
//static
|
|
VOID
|
|
DaysAndFractionToTime (
|
|
IN ULONG ElapsedDays,
|
|
IN ULONG Milliseconds,
|
|
OUT PLARGE_INTEGER Time
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input elapsed day count and partial time
|
|
in milliseconds to a 64-bit time value.
|
|
|
|
Arguments:
|
|
|
|
ElapsedDays - Supplies the number of elapsed days
|
|
|
|
Milliseconds - Supplies the number of milliseconds in the partial day
|
|
|
|
Time - Receives the output time to value
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER Temp;
|
|
LARGE_INTEGER Temp2;
|
|
|
|
//
|
|
// Calculate the exact number of milliseconds in the elapsed days.
|
|
//
|
|
|
|
Temp.QuadPart = ConvertDaysToMilliseconds( ElapsedDays );
|
|
|
|
//
|
|
// Convert milliseconds to a large integer
|
|
//
|
|
|
|
Temp2.LowPart = Milliseconds;
|
|
Temp2.HighPart = 0;
|
|
|
|
//
|
|
// add milliseconds to the whole day milliseconds
|
|
//
|
|
|
|
Temp.QuadPart = Temp.QuadPart + Temp2.QuadPart;
|
|
|
|
//
|
|
// Finally convert the milliseconds to 100ns resolution
|
|
//
|
|
|
|
*(PLARGE_INTEGER)Time = ConvertMillisecondsTo100ns( Temp );
|
|
|
|
//
|
|
// and return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
RtlTimeToTimeFields (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PTIME_FIELDS TimeFields
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input 64-bit LARGE_INTEGER variable to its corresponding
|
|
time field record. It will tell the caller the year, month, day, hour,
|
|
minute, second, millisecond, and weekday corresponding to the input time
|
|
variable.
|
|
|
|
Arguments:
|
|
|
|
Time - Supplies the time value to interpret
|
|
|
|
TimeFields - Receives a value corresponding to Time
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Years;
|
|
ULONG Month;
|
|
ULONG Days;
|
|
|
|
ULONG Hours;
|
|
ULONG Minutes;
|
|
ULONG Seconds;
|
|
ULONG Milliseconds;
|
|
|
|
//
|
|
// First divide the input time 64 bit time variable into
|
|
// the number of whole days and part days (in milliseconds)
|
|
//
|
|
|
|
TimeToDaysAndFraction( Time, &Days, &Milliseconds );
|
|
|
|
//
|
|
// Compute which weekday it is and save it away now in the output
|
|
// variable. We add the weekday of the base day to bias our computation
|
|
// which means that if one day has elapsed then we the weekday we want
|
|
// is the Jan 2nd, 1601.
|
|
//
|
|
|
|
TimeFields->Weekday = (CSHORT)((Days + WEEKDAY_OF_1601) % 7);
|
|
|
|
//
|
|
// Calculate the number of whole years contained in the elapsed days
|
|
// For example if Days = 500 then Years = 1
|
|
//
|
|
|
|
Years = ElapsedDaysToYears( Days );
|
|
|
|
//
|
|
// And subtract the number of whole years from our elapsed days
|
|
// For example if Days = 500, Years = 1, and the new days is equal
|
|
// to 500 - 365 (normal year).
|
|
//
|
|
|
|
Days = Days - ElapsedYearsToDays( Years );
|
|
|
|
//
|
|
// Now test whether the year we are working on (i.e., The year
|
|
// after the total number of elapsed years) is a leap year
|
|
// or not.
|
|
//
|
|
|
|
if (IsLeapYear( Years + 1 )) {
|
|
|
|
//
|
|
// The current year is a leap year, so figure out what month
|
|
// it is, and then subtract the number of days preceding the
|
|
// month from the days to figure out what day of the month it is
|
|
//
|
|
|
|
Month = LeapYearDayToMonth[Days];
|
|
Days = Days - LeapYearDaysPrecedingMonth[Month];
|
|
|
|
} else {
|
|
|
|
//
|
|
// The current year is a normal year, so figure out the month
|
|
// and days as described above for the leap year case
|
|
//
|
|
|
|
Month = NormalYearDayToMonth[Days];
|
|
Days = Days - NormalYearDaysPrecedingMonth[Month];
|
|
|
|
}
|
|
|
|
//
|
|
// Now we need to compute the elapsed hour, minute, second, milliseconds
|
|
// from the millisecond variable. This variable currently contains
|
|
// the number of milliseconds in our input time variable that did not
|
|
// fit into a whole day. To compute the hour, minute, second part
|
|
// we will actually do the arithmetic backwards computing milliseconds
|
|
// seconds, minutes, and then hours. We start by computing the
|
|
// number of whole seconds left in the day, and then computing
|
|
// the millisecond remainder.
|
|
//
|
|
|
|
Seconds = Milliseconds / 1000;
|
|
Milliseconds = Milliseconds % 1000;
|
|
|
|
//
|
|
// Now we compute the number of whole minutes left in the day
|
|
// and the number of remainder seconds
|
|
//
|
|
|
|
Minutes = Seconds / 60;
|
|
Seconds = Seconds % 60;
|
|
|
|
//
|
|
// Now compute the number of whole hours left in the day
|
|
// and the number of remainder minutes
|
|
//
|
|
|
|
Hours = Minutes / 60;
|
|
Minutes = Minutes % 60;
|
|
|
|
//
|
|
// As our final step we put everything into the time fields
|
|
// output variable
|
|
//
|
|
|
|
TimeFields->Year = (CSHORT)(Years + 1601);
|
|
TimeFields->Month = (CSHORT)(Month + 1);
|
|
TimeFields->Day = (CSHORT)(Days + 1);
|
|
TimeFields->Hour = (CSHORT)Hours;
|
|
TimeFields->Minute = (CSHORT)Minutes;
|
|
TimeFields->Second = (CSHORT)Seconds;
|
|
TimeFields->Milliseconds = (CSHORT)Milliseconds;
|
|
|
|
//
|
|
// and return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
BOOLEAN
|
|
RtlCutoverTimeToSystemTime(
|
|
PTIME_FIELDS CutoverTime,
|
|
PLARGE_INTEGER SystemTime,
|
|
PLARGE_INTEGER CurrentSystemTime,
|
|
BOOLEAN ThisYear
|
|
)
|
|
{
|
|
TIME_FIELDS CurrentTimeFields;
|
|
|
|
//
|
|
// Get the current system time
|
|
//
|
|
|
|
RtlTimeToTimeFields(CurrentSystemTime,&CurrentTimeFields);
|
|
|
|
//
|
|
// check for absolute time field. If the year is specified,
|
|
// the the time is an abosulte time
|
|
//
|
|
|
|
if ( CutoverTime->Year ) {
|
|
|
|
//
|
|
// Convert this to a time value and make sure it
|
|
// is greater than the current system time
|
|
//
|
|
|
|
if ( !RtlTimeFieldsToTime(CutoverTime,SystemTime) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (SystemTime->QuadPart < CurrentSystemTime->QuadPart) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else {
|
|
|
|
TIME_FIELDS WorkingTimeField;
|
|
TIME_FIELDS ScratchTimeField;
|
|
LARGE_INTEGER ScratchTime;
|
|
CSHORT BestWeekdayDate;
|
|
CSHORT WorkingWeekdayNumber;
|
|
CSHORT TargetWeekdayNumber;
|
|
CSHORT TargetYear;
|
|
CSHORT TargetMonth;
|
|
CSHORT TargetWeekday; // range [0..6] == [Sunday..Saturday]
|
|
BOOLEAN MonthMatches;
|
|
//
|
|
// The time is an day in the month style time
|
|
//
|
|
// the convention is the Day is 1-5 specifying 1st, 2nd... Last
|
|
// day within the month. The day is WeekDay.
|
|
//
|
|
|
|
//
|
|
// Compute the target month and year
|
|
//
|
|
|
|
TargetWeekdayNumber = CutoverTime->Day;
|
|
if ( TargetWeekdayNumber > 5 || TargetWeekdayNumber == 0 ) {
|
|
return FALSE;
|
|
}
|
|
TargetWeekday = CutoverTime->Weekday;
|
|
TargetMonth = CutoverTime->Month;
|
|
MonthMatches = FALSE;
|
|
if ( !ThisYear ) {
|
|
if ( TargetMonth < CurrentTimeFields.Month ) {
|
|
TargetYear = CurrentTimeFields.Year + 1;
|
|
}
|
|
else if ( TargetMonth > CurrentTimeFields.Month ) {
|
|
TargetYear = CurrentTimeFields.Year;
|
|
}
|
|
else {
|
|
TargetYear = CurrentTimeFields.Year;
|
|
MonthMatches = TRUE;
|
|
}
|
|
}
|
|
else {
|
|
TargetYear = CurrentTimeFields.Year;
|
|
}
|
|
try_next_year:
|
|
BestWeekdayDate = 0;
|
|
|
|
WorkingTimeField.Year = TargetYear;
|
|
WorkingTimeField.Month = TargetMonth;
|
|
WorkingTimeField.Day = 1;
|
|
WorkingTimeField.Hour = CutoverTime->Hour;
|
|
WorkingTimeField.Minute = CutoverTime->Minute;
|
|
WorkingTimeField.Second = CutoverTime->Second;
|
|
WorkingTimeField.Milliseconds = CutoverTime->Milliseconds;
|
|
WorkingTimeField.Weekday = 0;
|
|
|
|
//
|
|
// Convert to time and then back to time fields so we can determine
|
|
// the weekday of day 1 on the month
|
|
//
|
|
|
|
if ( !RtlTimeFieldsToTime(&WorkingTimeField,&ScratchTime) ) {
|
|
return FALSE;
|
|
}
|
|
RtlTimeToTimeFields(&ScratchTime,&ScratchTimeField);
|
|
|
|
//
|
|
// Compute bias to target weekday
|
|
//
|
|
if ( ScratchTimeField.Weekday > TargetWeekday ) {
|
|
WorkingTimeField.Day += (7-(ScratchTimeField.Weekday - TargetWeekday));
|
|
}
|
|
else if ( ScratchTimeField.Weekday < TargetWeekday ) {
|
|
WorkingTimeField.Day += (TargetWeekday - ScratchTimeField.Weekday);
|
|
}
|
|
|
|
//
|
|
// We are now at the first weekday that matches our target weekday
|
|
//
|
|
|
|
BestWeekdayDate = WorkingTimeField.Day;
|
|
WorkingWeekdayNumber = 1;
|
|
|
|
//
|
|
// Keep going one week at a time until we either pass the
|
|
// target weekday, or we match exactly
|
|
//
|
|
|
|
while ( WorkingWeekdayNumber < TargetWeekdayNumber ) {
|
|
WorkingTimeField.Day += 7;
|
|
if ( !RtlTimeFieldsToTime(&WorkingTimeField,&ScratchTime) ) {
|
|
break;
|
|
}
|
|
RtlTimeToTimeFields(&ScratchTime,&ScratchTimeField);
|
|
WorkingWeekdayNumber++;
|
|
BestWeekdayDate = ScratchTimeField.Day;
|
|
}
|
|
WorkingTimeField.Day = BestWeekdayDate;
|
|
|
|
//
|
|
// If the months match, and the date is less than the current
|
|
// date, then be have to go to next year.
|
|
//
|
|
|
|
if ( !RtlTimeFieldsToTime(&WorkingTimeField,&ScratchTime) ) {
|
|
return FALSE;
|
|
}
|
|
if ( MonthMatches ) {
|
|
if ( WorkingTimeField.Day < CurrentTimeFields.Day ) {
|
|
MonthMatches = FALSE;
|
|
TargetYear++;
|
|
goto try_next_year;
|
|
}
|
|
if ( WorkingTimeField.Day == CurrentTimeFields.Day ) {
|
|
|
|
if (ScratchTime.QuadPart < CurrentSystemTime->QuadPart) {
|
|
MonthMatches = FALSE;
|
|
TargetYear++;
|
|
goto try_next_year;
|
|
}
|
|
}
|
|
}
|
|
*SystemTime = ScratchTime;
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
RtlTimeFieldsToTime (
|
|
IN PTIME_FIELDS TimeFields,
|
|
OUT PLARGE_INTEGER Time
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input Time Field variable to a 64-bit NT time
|
|
value. It ignores the WeekDay of the time field.
|
|
|
|
Arguments:
|
|
|
|
TimeFields - Supplies the time field record to use
|
|
|
|
Time - Receives the NT Time corresponding to TimeFields
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if the Time Fields is well formed and within the
|
|
range of time expressible by LARGE_INTEGER and FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Year;
|
|
ULONG Month;
|
|
ULONG Day;
|
|
ULONG Hour;
|
|
ULONG Minute;
|
|
ULONG Second;
|
|
ULONG Milliseconds;
|
|
|
|
ULONG ElapsedDays;
|
|
ULONG ElapsedMilliseconds;
|
|
|
|
//
|
|
// Load the time field elements into local variables. This should
|
|
// ensure that the compiler will only load the input elements
|
|
// once, even if there are alias problems. It will also make
|
|
// everything (except the year) zero based. We cannot zero base the
|
|
// year because then we can't recognize cases where we're given a year
|
|
// before 1601.
|
|
//
|
|
|
|
Year = TimeFields->Year;
|
|
Month = TimeFields->Month - 1;
|
|
Day = TimeFields->Day - 1;
|
|
Hour = TimeFields->Hour;
|
|
Minute = TimeFields->Minute;
|
|
Second = TimeFields->Second;
|
|
Milliseconds = TimeFields->Milliseconds;
|
|
|
|
//
|
|
// Check that the time field input variable contains
|
|
// proper values.
|
|
//
|
|
|
|
//
|
|
// Year 30827 check: Time (in 100ns units) is stored in a
|
|
// 64-bit integer, rooted at 1/1/1601.
|
|
//
|
|
// 2^63 / (10^7 * 86400) = 10675199 days
|
|
// 10675199 / 146097 = 73 400-year chunks, 10118 days
|
|
// 10118 / 1461 = 6 4-year chunks, 1352 days
|
|
// 1352 / 365 = 3 years, some residual days
|
|
// 1600 + 73*400 + 6*4 + 3 = 30827 is last year fully
|
|
// supported.
|
|
//
|
|
// I'm guessing it's undesirable to support part of the
|
|
// year 30828.
|
|
//
|
|
|
|
if ((TimeFields->Month < 1) ||
|
|
(TimeFields->Day < 1) ||
|
|
(Year < 1601) ||
|
|
(Year > 30827) ||
|
|
(Month > 11) ||
|
|
((CSHORT)Day >= MaxDaysInMonth(Year, Month)) ||
|
|
(Hour > 23) ||
|
|
(Minute > 59) ||
|
|
(Second > 59) ||
|
|
(Milliseconds > 999)) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Compute the total number of elapsed days represented by the
|
|
// input time field variable
|
|
//
|
|
|
|
ElapsedDays = ElapsedYearsToDays( Year - 1601 );
|
|
|
|
if (IsLeapYear( Year - 1600 )) {
|
|
|
|
ElapsedDays += LeapYearDaysPrecedingMonth[ Month ];
|
|
|
|
} else {
|
|
|
|
ElapsedDays += NormalYearDaysPrecedingMonth[ Month ];
|
|
|
|
}
|
|
|
|
ElapsedDays += Day;
|
|
|
|
//
|
|
// Now compute the total number of milliseconds in the fractional
|
|
// part of the day
|
|
//
|
|
|
|
ElapsedMilliseconds = (((Hour*60) + Minute)*60 + Second)*1000 + Milliseconds;
|
|
|
|
//
|
|
// Given the elapsed days and milliseconds we can now build
|
|
// the output time variable
|
|
//
|
|
|
|
DaysAndFractionToTime( ElapsedDays, ElapsedMilliseconds, Time );
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
RtlTimeToElapsedTimeFields (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PTIME_FIELDS TimeFields
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input 64-bit LARGE_INTEGER variable to its corresponding
|
|
time field record. The input time is the elapsed time (difference
|
|
between to times). It will tell the caller the number of days, hour,
|
|
minute, second, and milliseconds that the elapsed time represents.
|
|
|
|
Arguments:
|
|
|
|
Time - Supplies the time value to interpret
|
|
|
|
TimeFields - Receives a value corresponding to Time
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Days;
|
|
ULONG Hours;
|
|
ULONG Minutes;
|
|
ULONG Seconds;
|
|
ULONG Milliseconds;
|
|
|
|
//
|
|
// First divide the input time 64 bit time variable into
|
|
// the number of whole days and part days (in milliseconds)
|
|
//
|
|
|
|
TimeToDaysAndFraction( Time, &Days, &Milliseconds );
|
|
|
|
//
|
|
// Now we need to compute the elapsed hour, minute, second, milliseconds
|
|
// from the millisecond variable. This variable currently contains
|
|
// the number of milliseconds in our input time variable that did not
|
|
// fit into a whole day. To compute the hour, minute, second part
|
|
// we will actually do the arithmetic backwards computing milliseconds
|
|
// seconds, minutes, and then hours. We start by computing the
|
|
// number of whole seconds left in the day, and then computing
|
|
// the millisecond remainder.
|
|
//
|
|
|
|
Seconds = Milliseconds / 1000;
|
|
Milliseconds = Milliseconds % 1000;
|
|
|
|
//
|
|
// Now we compute the number of whole minutes left in the day
|
|
// and the number of remainder seconds
|
|
//
|
|
|
|
Minutes = Seconds / 60;
|
|
Seconds = Seconds % 60;
|
|
|
|
//
|
|
// Now compute the number of whole hours left in the day
|
|
// and the number of remainder minutes
|
|
//
|
|
|
|
Hours = Minutes / 60;
|
|
Minutes = Minutes % 60;
|
|
|
|
//
|
|
// As our final step we put everything into the time fields
|
|
// output variable
|
|
//
|
|
|
|
TimeFields->Year = 0;
|
|
TimeFields->Month = 0;
|
|
TimeFields->Day = (CSHORT)Days;
|
|
TimeFields->Hour = (CSHORT)Hours;
|
|
TimeFields->Minute = (CSHORT)Minutes;
|
|
TimeFields->Second = (CSHORT)Seconds;
|
|
TimeFields->Milliseconds = (CSHORT)Milliseconds;
|
|
|
|
//
|
|
// and return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
RtlTimeToSecondsSince1980 (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PULONG ElapsedSeconds
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input 64-bit NT Time variable to the
|
|
number of seconds since the start of 1980. The NT time must be
|
|
within the range 1980 to around 2115.
|
|
|
|
Arguments:
|
|
|
|
Time - Supplies the Time to convert from
|
|
|
|
ElapsedSeconds - Receives the number of seconds since the start of 1980
|
|
denoted by Time
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if the input Time is within a range expressible by
|
|
ElapsedSeconds and FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER Seconds;
|
|
|
|
//
|
|
// First convert time to seconds since 1601
|
|
//
|
|
|
|
Seconds = Convert100nsToSeconds( *(PLARGE_INTEGER)Time );
|
|
|
|
//
|
|
// Then subtract the number of seconds from 1601 to 1980.
|
|
//
|
|
|
|
Seconds.QuadPart = Seconds.QuadPart - SecondsToStartOf1980.QuadPart;
|
|
|
|
//
|
|
// If the results is negative then the date was before 1980 or if
|
|
// the results is greater than a ulong then its too far in the
|
|
// future so we return FALSE
|
|
//
|
|
|
|
if (Seconds.HighPart != 0) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Otherwise we have the answer
|
|
//
|
|
|
|
*ElapsedSeconds = Seconds.LowPart;
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
RtlSecondsSince1980ToTime (
|
|
IN ULONG ElapsedSeconds,
|
|
OUT PLARGE_INTEGER Time
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts the seconds since the start of 1980 to an
|
|
NT Time value.
|
|
|
|
Arguments:
|
|
|
|
ElapsedSeconds - Supplies the number of seconds from the start of 1980
|
|
to convert from
|
|
|
|
Time - Receives the converted Time value
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER Seconds;
|
|
|
|
//
|
|
// Move elapsed seconds to a large integer
|
|
//
|
|
|
|
Seconds.LowPart = ElapsedSeconds;
|
|
Seconds.HighPart = 0;
|
|
|
|
//
|
|
// convert number of seconds from 1980 to number of seconds from 1601
|
|
//
|
|
|
|
Seconds.QuadPart = Seconds.QuadPart + SecondsToStartOf1980.QuadPart;
|
|
|
|
//
|
|
// Convert seconds to 100ns resolution
|
|
//
|
|
|
|
*(PLARGE_INTEGER)Time = ConvertSecondsTo100ns( Seconds );
|
|
|
|
//
|
|
// and return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
RtlTimeToSecondsSince1970 (
|
|
IN PLARGE_INTEGER Time,
|
|
OUT PULONG ElapsedSeconds
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts an input 64-bit NT Time variable to the
|
|
number of seconds since the start of 1970. The NT time must be
|
|
within the range 1970 to around 2105.
|
|
|
|
Arguments:
|
|
|
|
Time - Supplies the Time to convert from
|
|
|
|
ElapsedSeconds - Receives the number of seconds since the start of 1970
|
|
denoted by Time
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if the input time is within the range expressible by
|
|
ElapsedSeconds and FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER Seconds;
|
|
|
|
//
|
|
// First convert time to seconds since 1601
|
|
//
|
|
|
|
Seconds = Convert100nsToSeconds( *(PLARGE_INTEGER)Time );
|
|
|
|
//
|
|
// Then subtract the number of seconds from 1601 to 1970.
|
|
//
|
|
|
|
Seconds.QuadPart = Seconds.QuadPart - SecondsToStartOf1970.QuadPart;
|
|
|
|
//
|
|
// If the results is negative then the date was before 1970 or if
|
|
// the results is greater than a ulong then its too far in the
|
|
// future so we return FALSE
|
|
//
|
|
|
|
if (Seconds.HighPart != 0) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Otherwise we have the answer
|
|
//
|
|
|
|
*ElapsedSeconds = Seconds.LowPart;
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
RtlSecondsSince1970ToTime (
|
|
IN ULONG ElapsedSeconds,
|
|
OUT PLARGE_INTEGER Time
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts the seconds since the start of 1970 to an
|
|
NT Time value
|
|
|
|
Arguments:
|
|
|
|
ElapsedSeconds - Supplies the number of seconds from the start of 1970
|
|
to convert from
|
|
|
|
Time - Receives the converted Time value
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
LARGE_INTEGER Seconds;
|
|
|
|
//
|
|
// Move elapsed seconds to a large integer
|
|
//
|
|
|
|
Seconds.LowPart = ElapsedSeconds;
|
|
Seconds.HighPart = 0;
|
|
|
|
//
|
|
// Convert number of seconds from 1970 to number of seconds from 1601
|
|
//
|
|
|
|
Seconds.QuadPart = Seconds.QuadPart + SecondsToStartOf1970.QuadPart;
|
|
|
|
//
|
|
// Convert seconds to 100ns resolution
|
|
//
|
|
|
|
*(PLARGE_INTEGER)Time = ConvertSecondsTo100ns( Seconds );
|
|
|
|
//
|
|
// return to our caller
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlSystemTimeToLocalTime (
|
|
IN PLARGE_INTEGER SystemTime,
|
|
OUT PLARGE_INTEGER LocalTime
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
SYSTEM_TIMEOFDAY_INFORMATION TimeOfDay;
|
|
|
|
Status = ZwQuerySystemInformation(
|
|
SystemTimeOfDayInformation,
|
|
&TimeOfDay,
|
|
sizeof(TimeOfDay),
|
|
NULL
|
|
);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// LocalTime = SystemTime - TimeZoneBias
|
|
//
|
|
|
|
LocalTime->QuadPart = SystemTime->QuadPart - TimeOfDay.TimeZoneBias.QuadPart;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlLocalTimeToSystemTime (
|
|
IN PLARGE_INTEGER LocalTime,
|
|
OUT PLARGE_INTEGER SystemTime
|
|
)
|
|
{
|
|
|
|
NTSTATUS Status;
|
|
SYSTEM_TIMEOFDAY_INFORMATION TimeOfDay;
|
|
|
|
Status = ZwQuerySystemInformation(
|
|
SystemTimeOfDayInformation,
|
|
&TimeOfDay,
|
|
sizeof(TimeOfDay),
|
|
NULL
|
|
);
|
|
if ( !NT_SUCCESS(Status) ) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// SystemTime = LocalTime + TimeZoneBias
|
|
//
|
|
|
|
SystemTime->QuadPart = LocalTime->QuadPart + TimeOfDay.TimeZoneBias.QuadPart;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
ULONG
|
|
RtlGetTickCount (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns the current tick count for the system.
|
|
This routine is provided for compatibility only
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
System tick count.
|
|
|
|
--*/
|
|
|
|
{
|
|
return NtGetTickCount ();
|
|
}
|
|
|