bool COutFile::SetTime(const FILETIME *lpCreationTime,
const FILETIME *lpLastAccessTime, const FILETIME *lpLastWriteTime)
{
LARGE_INTEGER ltime;
DWORD dw;
if (_fd == -1) {
SetLastError( ERROR_INVALID_HANDLE );
return false;
}
/* On some OS (cygwin, MacOSX ...), you must close the file before updating times */
if (lpLastAccessTime) {
ltime.QuadPart = lpLastAccessTime->dwHighDateTime;
ltime.QuadPart = (ltime.QuadPart << 32) | lpLastAccessTime->dwLowDateTime;
RtlTimeToSecondsSince1970( <ime, &dw );
_lastAccessTime = dw;
}
if (lpLastWriteTime) {
ltime.QuadPart = lpLastWriteTime->dwHighDateTime;
ltime.QuadPart = (ltime.QuadPart << 32) | lpLastWriteTime->dwLowDateTime;
RtlTimeToSecondsSince1970( <ime, &dw );
_lastWriteTime = dw;
}
return true;
}
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, WORD *fatdate, WORD *fattime ) {
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
WORD fat_d,fat_t;
TRACEN((printf("FileTimeToDosDateTime\n")))
li.QuadPart = ft->dwHighDateTime;
li.QuadPart = (li.QuadPart << 32) | ft->dwLowDateTime;
RtlTimeToSecondsSince1970( &li, &t );
unixtime = t; /* unixtime = t; * FIXME unixtime = t - TIME_GetBias(); */
tm = gmtime( &unixtime );
fat_t = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
fat_d = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday;
if (fattime)
*fattime = fat_t;
if (fatdate)
*fatdate = fat_d;
TRACEN((printf("FileTimeToDosDateTime : %lx %lx => %d %d\n",
(long)ft->dwHighDateTime,(long)ft->dwLowDateTime,(unsigned)fat_d,(unsigned)fat_t)))
return TRUE;
}
time_t
time_now(
VOID
)
/*++
Routine Description:
This function returns the UTC time in seconds since 1970.
Arguments:
None.
Return Value:
None.
--*/
{
LARGE_INTEGER Time;
time_t CurrentTime;
// Get the 64-bit system time.
// Convert the system time to the number of seconds
// since 1-1-1970.
//
NtQuerySystemTime(&Time);
RtlTimeToSecondsSince1970(&Time, (PVOID) &CurrentTime);
return(CurrentTime);
}
VOID
NetpFileTimeToSecondsSince1970(
IN LPFILETIME FileTime,
OUT LPDWORD SecondsSince1970 // Round UP if needed.
)
{
LARGE_INTEGER LargeInteger;
NetpAssert( FileTime != NULL );
NetpAssert( SecondsSince1970 != NULL );
//
// BUGBUG: This assumes that FILETIME and LARGE_INTEGER have same
// precision. Is this guaranteed?
//
NetpAssert( sizeof(LARGE_INTEGER) == sizeof(FILETIME) );
LargeInteger.HighPart = FileTime->dwHighDateTime;
LargeInteger.LowPart = FileTime->dwLowDateTime;
// Round LargeInteger UP to 1 second.
NetpRoundUpLargeIntegerTimeToOneSecond( &LargeInteger );
// Convert to seconds since 1970.
NetpAssert( sizeof(DWORD) == sizeof(ULONG) );
RtlTimeToSecondsSince1970(
&LargeInteger,
(PVOID) SecondsSince1970);
} // NetpFileTimeToSecondsSince1970
VOID
LogfReportEvent(USHORT wType,
USHORT wCategory,
ULONG dwEventId,
USHORT wNumStrings,
PWSTR pStrings,
ULONG dwDataSize,
PVOID pRawData)
{
NTSTATUS Status;
UNICODE_STRING SourceName, ComputerName;
PEVENTLOGRECORD LogBuffer;
LARGE_INTEGER SystemTime;
ULONG Time;
SIZE_T RecSize;
DWORD dwComputerNameLength;
WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
if (!EventLogSource)
return;
RtlInitUnicodeString(&SourceName, EventLogSource->szName);
dwComputerNameLength = ARRAYSIZE(szComputerName);
if (!GetComputerNameW(szComputerName, &dwComputerNameLength))
szComputerName[0] = L'\0';
RtlInitUnicodeString(&ComputerName, szComputerName);
NtQuerySystemTime(&SystemTime);
RtlTimeToSecondsSince1970(&SystemTime, &Time);
LogBuffer = LogfAllocAndBuildNewRecord(&RecSize,
Time,
wType,
wCategory,
dwEventId,
&SourceName,
&ComputerName,
0,
NULL,
wNumStrings,
pStrings,
dwDataSize,
pRawData);
if (LogBuffer == NULL)
{
DPRINT1("LogfAllocAndBuildNewRecord failed!\n");
return;
}
Status = LogfWriteRecord(EventLogSource->LogFile, LogBuffer, RecSize);
if (!NT_SUCCESS(Status))
{
DPRINT1("ERROR writing to event log `%S' (Status 0x%08lx)\n",
EventLogSource->LogFile->LogName, Status);
}
LogfFreeRecord(LogBuffer);
}
bool create_bad_block_inode( PEXT2_FILESYS Ext2Sys,
PEXT2_BADBLK_LIST bb_list)
{
bool retval;
EXT2_INODE inode;
LARGE_INTEGER SysTime;
NtQuerySystemTime(&SysTime);
ext2_mark_inode_bitmap(Ext2Sys->inode_map, EXT2_BAD_INO);
Ext2Sys->group_desc[0].bg_free_inodes_count--;
Ext2Sys->ext2_sb->s_free_inodes_count--;
memset(&inode, 0, sizeof(EXT2_INODE));
inode.i_mode = (USHORT)((0777 & ~Ext2Sys->umask));
inode.i_uid = inode.i_gid = 0;
inode.i_blocks = 0;
inode.i_block[0] = 0;
inode.i_links_count = 2;
RtlTimeToSecondsSince1970(&SysTime, &inode.i_mtime);
inode.i_ctime = inode.i_atime = inode.i_mtime;
inode.i_size = 0;
retval = ext2_save_inode(Ext2Sys, EXT2_BAD_INO, &inode);
return retval;
}
/***********************************************************************
* FileTimeToDosDateTime (KERNEL32.@)
*/
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
LPWORD fattime )
{
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
if (!fatdate || !fattime)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
li.u.LowPart = ft->dwLowDateTime;
li.u.HighPart = ft->dwHighDateTime;
if (!RtlTimeToSecondsSince1970( &li, &t ))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
unixtime = t;
tm = gmtime( &unixtime );
if (fattime)
*fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
if (fatdate)
*fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
+ tm->tm_mday;
return TRUE;
}
/* INTERNAL: Translate WIN32_FIND_DATAW to wfinddata32_t */
static void msvcrt_wfttofd32(const WIN32_FIND_DATAW *fd, struct MSVCRT__wfinddata32_t* ft)
{
DWORD dw;
if (fd->dwFileAttributes == FILE_ATTRIBUTE_NORMAL)
ft->attrib = 0;
else
ft->attrib = fd->dwFileAttributes;
RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftCreationTime, &dw );
ft->time_create = dw;
RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastAccessTime, &dw );
ft->time_access = dw;
RtlTimeToSecondsSince1970( (const LARGE_INTEGER *)&fd->ftLastWriteTime, &dw );
ft->time_write = dw;
ft->size = fd->nFileSizeLow;
strcpyW(ft->name, fd->cFileName);
}
ULONG GetCurrentTime()
{
LARGE_INTEGER currentSystemTime;
LARGE_INTEGER currentLocalTime;
ULONG time;
KeQuerySystemTime(¤tSystemTime);
ExSystemTimeToLocalTime(¤tSystemTime,¤tLocalTime);
RtlTimeToSecondsSince1970(¤tLocalTime, &time);
return time;
}
bool ConvertFileTimeToString(const FILETIME &ft, char *s, bool includeTime, bool includeSeconds)
{
#ifdef _WIN32
s[0] = '\0';
SYSTEMTIME st;
if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
return false;
s = UIntToStringSpec(0, st.wYear, s, 4);
s = UIntToStringSpec('-', st.wMonth, s, 2);
s = UIntToStringSpec('-', st.wDay, s, 2);
if (includeTime)
{
s = UIntToStringSpec(' ', st.wHour, s, 2);
s = UIntToStringSpec(':', st.wMinute, s, 2);
if (includeSeconds)
UIntToStringSpec(':', st.wSecond, s, 2);
}
/*
sprintf(s, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
if (includeTime)
{
sprintf(s + strlen(s), " %02d:%02d", st.wHour, st.wMinute);
if (includeSeconds)
sprintf(s + strlen(s), ":%02d", st.wSecond);
}
*/
#else
BOOLEAN WINAPI RtlTimeToSecondsSince1970( const LARGE_INTEGER *Time, DWORD *Seconds );
FILETIME filetime;
LocalFileTimeToFileTime(&ft, &filetime);
LARGE_INTEGER ltime;
ltime.QuadPart = filetime.dwHighDateTime;
ltime.QuadPart = (ltime.QuadPart << 32) | filetime.dwLowDateTime;
DWORD dw;
RtlTimeToSecondsSince1970(<ime, &dw );
time_t timep = (time_t)dw;
struct tm * date = localtime(&timep);
sprintf(s, "%04d-%02d-%02d", date->tm_year+1900, date->tm_mon+1,date->tm_mday);
if (includeTime)
{
sprintf(s + strlen(s), " %02d:%02d", date->tm_hour,date->tm_min);
if (includeSeconds)
sprintf(s + strlen(s), ":%02d", date->tm_sec);
}
#endif
return true;
}
NET_API_STATUS
NetpSystemTimeToGmtTime(
IN LPSYSTEMTIME WinSplitTime,
OUT LPDWORD GmtTime // seconds since 1970 (GMT).
)
{
TIME_FIELDS NtSplitTime;
LARGE_INTEGER NtPreciseTime;
if ( (WinSplitTime==NULL) || (GmtTime==NULL) ) {
return (ERROR_INVALID_PARAMETER);
}
NtSplitTime.Year = (CSHORT) WinSplitTime->wYear;
NtSplitTime.Month = (CSHORT) WinSplitTime->wMonth;
NtSplitTime.Day = (CSHORT) WinSplitTime->wDay;
NtSplitTime.Hour = (CSHORT) WinSplitTime->wHour;
NtSplitTime.Minute = (CSHORT) WinSplitTime->wMinute;
NtSplitTime.Second = (CSHORT) WinSplitTime->wSecond;
NtSplitTime.Milliseconds = (CSHORT) WinSplitTime->wMilliseconds;
NtSplitTime.Weekday = (CSHORT) WinSplitTime->wDayOfWeek;
if ( !RtlTimeFieldsToTime (
& NtSplitTime, // input
& NtPreciseTime // output
) ) {
NetpKdPrint(( PREFIX_NETLIB
"NetpSystemTimeToGmtTime: RtlTimeFieldsToTime failed.\n" ));
// BUGBUG: Better error code? Log this?
return (NERR_InternalError);
}
if ( !RtlTimeToSecondsSince1970 (
& NtPreciseTime, // input
(PULONG) GmtTime ) ) {
NetpKdPrint(( PREFIX_NETLIB
"NetpSystemTimeToGmtTime: "
"RtlTimeToSecondsSince1970 failed.\n" ));
// BUGBUG: Better error code? Log this?
return (NERR_InternalError);
}
return (NO_ERROR);
} // NetpSystemTimeToGmtTime
/***********************************************************************
* NtSetSystemTime [NTDLL.@]
* ZwSetSystemTime [NTDLL.@]
*
* Set the system time.
*
* PARAMS
* NewTime [I] The time to set.
* OldTime [O] Optional destination for the previous system time.
*
* RETURNS
* Success: STATUS_SUCCESS.
* Failure: An NTSTATUS error code indicating the problem.
*/
NTSTATUS WINAPI NtSetSystemTime(const LARGE_INTEGER *NewTime, LARGE_INTEGER *OldTime)
{
struct timeval tv;
time_t tm_t;
DWORD sec, oldsec;
LARGE_INTEGER tm;
/* Return the old time if necessary */
if (!OldTime) OldTime = &tm;
NtQuerySystemTime( OldTime );
RtlTimeToSecondsSince1970( OldTime, &oldsec );
RtlTimeToSecondsSince1970( NewTime, &sec );
/* set the new time */
tv.tv_sec = sec;
tv.tv_usec = 0;
#ifdef HAVE_SETTIMEOFDAY
if (!settimeofday(&tv, NULL)) /* 0 is OK, -1 is error */
return STATUS_SUCCESS;
tm_t = sec;
ERR("Cannot set time to %s, time adjustment %ld: %s\n",
ctime(&tm_t), (long)(sec-oldsec), strerror(errno));
if (errno == EPERM)
return STATUS_PRIVILEGE_NOT_HELD;
else
return STATUS_INVALID_PARAMETER;
#else
tm_t = sec;
FIXME("setting time to %s not implemented for missing settimeofday\n",
ctime(&tm_t));
return STATUS_NOT_IMPLEMENTED;
#endif
}
static
DWORD
GetTimeInSeconds(VOID)
{
LARGE_INTEGER Time;
FILETIME FileTime;
DWORD dwSeconds;
GetSystemTimeAsFileTime(&FileTime);
Time.u.LowPart = FileTime.dwLowDateTime;
Time.u.HighPart = FileTime.dwHighDateTime;
RtlTimeToSecondsSince1970(&Time, &dwSeconds);
return dwSeconds;
}
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, WORD *fatdate, WORD *fattime ) {
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
TRACEN((printf("FileTimeToDosDateTime\n")))
li.QuadPart = ft->dwHighDateTime;
li.QuadPart = (li.QuadPart << 32) | ft->dwLowDateTime;
RtlTimeToSecondsSince1970( &li, &t );
unixtime = t;
tm = gmtime( &unixtime );
if (fattime)
*fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
if (fatdate)
*fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday;
return TRUE;
}
/***********************************************************************
* FileTimeToDosDateTime (KERNEL32.@)
*/
BOOL WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
LPWORD fattime )
{
LARGE_INTEGER li;
ULONG t;
time_t unixtime;
struct tm* tm;
li.u.LowPart = ft->dwLowDateTime;
li.u.HighPart = ft->dwHighDateTime;
RtlTimeToSecondsSince1970( &li, &t );
unixtime = t;
tm = gmtime( &unixtime );
if (fattime)
*fattime = (tm->tm_hour << 11) + (tm->tm_min << 5) + (tm->tm_sec / 2);
if (fatdate)
*fatdate = ((tm->tm_year - 80) << 9) + ((tm->tm_mon + 1) << 5)
+ tm->tm_mday;
return TRUE;
}
NTSTATUS
LogfWriteRecord(PLOGFILE LogFile,
PEVENTLOGRECORD Record,
SIZE_T BufSize)
{
NTSTATUS Status;
LARGE_INTEGER SystemTime;
// ASSERT(sizeof(*Record) == sizeof(RecBuf));
if (!Record || BufSize < sizeof(*Record))
return STATUS_INVALID_PARAMETER;
/* Lock the log file exclusive */
RtlAcquireResourceExclusive(&LogFile->Lock, TRUE);
/*
* Retrieve the record written time now, that will also be compared
* with the existing events timestamps in case the log is wrapping.
*/
NtQuerySystemTime(&SystemTime);
RtlTimeToSecondsSince1970(&SystemTime, &Record->TimeWritten);
Status = ElfWriteRecord(&LogFile->LogFile, Record, BufSize);
if (Status == STATUS_LOG_FILE_FULL)
{
/* The event log file is full, queue a message box for the user and exit */
// TODO!
DPRINT1("Log file `%S' is full!\n", LogFile->LogName);
}
/* Unlock the log file */
RtlReleaseResource(&LogFile->Lock);
return Status;
}
NTSTATUS
NlCheckAuthenticator(
IN OUT PSERVER_SESSION ServerSession,
IN PNETLOGON_AUTHENTICATOR Authenticator,
OUT PNETLOGON_AUTHENTICATOR ReturnAuthenticator
)
/*++
Routine Description:
Verify that supplied Authenticator is valid.
It is intended for use by the server side after initial authentication
has succeeded. This routine will modify the seed by
first adding the time-of-day received from the Authenticator
and then by incrementing it.
A ReturnAuthenticator is built based on the final seed.
Arguments:
ServerSession - Pointer to the ServerSession structure. The following
fields are used:
SsAuthenticationSeed - Supplies the seed used for authentication and
returns the updated seed.
SsSessionKey - The session key used for encryption.
SsCheck - Is zeroed to indicate successful communication with the client.
Authenticator - The authenticator passed by the caller.
ReturnAuthenticator - The authenticator we'll return to the caller.
Return Value:
STATUS_SUCCESS;
STATUS_ACCESS_DENIED;
STATUS_TIME_DIFFERENCE_AT_DC;
--*/
{
NETLOGON_CREDENTIAL TargetCredential;
#ifdef notdef // Doesn't work if caller in different time zone
LARGE_INTEGER TimeNow;
long timeofday;
long timediff;
//
// First check if time-of-day is rational.
//
NtQuerySystemTime( &TimeNow );
RtlTimeToSecondsSince1970( &TimeNow, &timeofday );
timediff = timeofday - Authenticator->timestamp;
if (timediff < 0) {
timediff = Authenticator->timestamp - timeofday;
}
if (timediff > RATIONAL_TIME) {
return STATUS_TIME_DIFFERENCE_AT_DC;
}
#endif // notdef
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,"NlCheckAuthenticator: Seed = %lx %lx\n",
((DWORD *) (&ServerSession->SsAuthenticationSeed))[0],
((DWORD *) (&ServerSession->SsAuthenticationSeed))[1]));
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: SessionKey = %lx %lx %lx %lx\n",
((DWORD *) (&ServerSession->SsSessionKey))[0],
((DWORD *) (&ServerSession->SsSessionKey))[1],
((DWORD *) (&ServerSession->SsSessionKey))[2],
((DWORD *) (&ServerSession->SsSessionKey))[3]));
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Client Authenticator GOT = %lx %lx\n",
((DWORD *) (&Authenticator->Credential))[0],
((DWORD *) (&Authenticator->Credential))[1]));
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Time = %lx\n",
((DWORD *) (&Authenticator->timestamp))[0] ));
#endif // BAD_ALIGNMENT
//
// modify the seed before computing auth_credential for verification
// Two long words are added and overflow carry (if any) ignored
// This will leave upper 4 bytes unchanged
//
*((unsigned long * ) &ServerSession->SsAuthenticationSeed) += Authenticator->timestamp;
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Seed + TIME = %lx %lx\n",
((DWORD *) (&ServerSession->SsAuthenticationSeed))[0],
((DWORD *) (&ServerSession->SsAuthenticationSeed))[1]));
#endif // BAD_ALIGNMENT
//
// Compute TargetCredential to verify the one supplied in the Authenticator
//
NlComputeCredentials( &ServerSession->SsAuthenticationSeed,
&TargetCredential,
&ServerSession->SsSessionKey );
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Client Authenticator MADE = %lx %lx\n",
((DWORD *) (&TargetCredential))[0],
((DWORD *) (&TargetCredential))[1]));
#endif // BAD_ALIGNMENT
//
// verify the computed credentials with those supplied
// Authenticator must have used seed + time_of_day as seed
//
if (RtlCompareMemory( &Authenticator->Credential,
&TargetCredential,
sizeof(TargetCredential)) !=
sizeof(TargetCredential)) {
return STATUS_ACCESS_DENIED;
}
//
// modify our seed before computing the ReturnAuthenticator.
// The requestor will increment his seed if he matches this credentials.
//
(*((unsigned long * ) &ServerSession->SsAuthenticationSeed))++;
//
// compute ClientCredential to send back to requestor
//
NlComputeCredentials( &ServerSession->SsAuthenticationSeed,
&ReturnAuthenticator->Credential,
&ServerSession->SsSessionKey);
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Server Authenticator SEND = %lx %lx\n",
((DWORD *) (&ReturnAuthenticator->Credential))[0],
((DWORD *) (&ReturnAuthenticator->Credential))[1]));
NlPrint((NL_CHALLENGE_RES,
"NlCheckAuthenticator: Seed + time + 1= %lx %lx\n",
((DWORD *) (&ServerSession->SsAuthenticationSeed))[0],
((DWORD *) (&ServerSession->SsAuthenticationSeed))[1]));
#endif // BAD_ALIGNMENT
//
// Indicate successful communication with the client
//
ServerSession->SsCheck = 0;
ServerSession->SsPulseTimeoutCount = 0;
ServerSession->SsFlags &= ~SS_PULSE_SENT;
return STATUS_SUCCESS;
}
VOID
NlBuildAuthenticator(
IN OUT PNETLOGON_CREDENTIAL AuthenticationSeed,
IN PNETLOGON_SESSION_KEY SessionKey,
OUT PNETLOGON_AUTHENTICATOR Authenticator
)
/*++
Routine Description:
Build the authenticator to be sent to primary.
This routine will modify the seed by adding the
time-of-day before computing the credentials.
Arguments:
AuthenticationSeed -- The current authentication seed. This seed will
have the current time of day added to it prior to building the
Authenticator.
SessionKey - The Session Key used for encrypting the Authenticator.
Authenticator - The Authenticator to pass to the PDC for the current
call.
Return Value:
NT Status code
--*/
{
NTSTATUS Status;
LARGE_INTEGER TimeNow;
//
// Use the current time of day to modify the authentication seed
//
RtlZeroMemory(Authenticator, sizeof(*Authenticator));
Status = NtQuerySystemTime( &TimeNow );
NlAssert( NT_SUCCESS(Status) );
Status = RtlTimeToSecondsSince1970( &TimeNow, &Authenticator->timestamp );
NlAssert( NT_SUCCESS(Status) );
//
// Modify the AuthenticationSeed before computing auth_credential for
// verification .
//
// Two long words are added and overflow carry (if any) ignored
// This will leave upper 4 bytes unchanged
//
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,"NlBuildAuthenticator: Old Seed = %lx %lx\n",
((DWORD *) (AuthenticationSeed))[0],
((DWORD *) (AuthenticationSeed))[1]));
NlPrint((NL_CHALLENGE_RES,"NlBuildAuthenticator: Time = %lx\n",
((DWORD *) (&Authenticator->timestamp))[0] ));
#endif // BAD_ALIGNMENT
*((unsigned long * ) AuthenticationSeed) += Authenticator->timestamp;
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,"NlBuildAuthenticator: New Seed = %lx %lx\n",
((DWORD *) (AuthenticationSeed))[0],
((DWORD *) (AuthenticationSeed))[1]));
NlPrint((NL_CHALLENGE_RES,
"NlBuildAuthenticator: SessionKey = %lx %lx %lx %lx\n",
((DWORD *) (SessionKey))[0],
((DWORD *) (SessionKey))[1],
((DWORD *) (SessionKey))[2],
((DWORD *) (SessionKey))[3]));
#endif // BAD_ALIGNMENT
//
// compute AuthenticationSeed to verify the one supplied by Requestor
//
NlComputeCredentials( AuthenticationSeed,
&Authenticator->Credential,
SessionKey);
#ifdef BAD_ALIGNMENT
NlPrint((NL_CHALLENGE_RES,"NlBuildAuthenticator: Client Authenticator = %lx %lx\n",
((DWORD *) (&Authenticator->Credential))[0],
((DWORD *) (&Authenticator->Credential))[1]));
#endif // BAD_ALIGNMENT
return;
}
/* Function 28 */
NET_API_STATUS
__stdcall
NetrRemoteTOD(
SRVSVC_HANDLE ServerName,
LPTIME_OF_DAY_INFO *BufferPtr)
{
SYSTEMTIME SystemTime;
LARGE_INTEGER Time;
TIME_ZONE_INFORMATION TimeZoneInfo;
DWORD TimeZoneId;
LPTIME_OF_DAY_INFO lpTod;
TRACE("NetrRemoteTOD(%p %p)\n", ServerName, BufferPtr);
*BufferPtr = midl_user_allocate(sizeof(TIME_OF_DAY_INFO));
if (*BufferPtr == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
lpTod = *BufferPtr;
/* Set the seconds since 1970 */
NtQuerySystemTime(&Time);
RtlTimeToSecondsSince1970(&Time,
&lpTod->tod_elapsedt);
/* Set the tick count */
lpTod->tod_msecs = GetTickCount();
/* Set the timezone */
TimeZoneId = GetTimeZoneInformation(&TimeZoneInfo);
switch (TimeZoneId)
{
case TIME_ZONE_ID_UNKNOWN:
lpTod->tod_timezone = TimeZoneInfo.Bias;
break;
case TIME_ZONE_ID_STANDARD:
lpTod->tod_timezone = TimeZoneInfo.Bias + TimeZoneInfo.StandardBias;
break;
case TIME_ZONE_ID_DAYLIGHT:
lpTod->tod_timezone = TimeZoneInfo.Bias + TimeZoneInfo.DaylightBias;
break;
default:
lpTod->tod_timezone = 0;
}
/* Set the ??? */
lpTod->tod_tinterval = 310;
/* Set the date and time */
GetSystemTime(&SystemTime);
lpTod->tod_hours = SystemTime.wHour;
lpTod->tod_mins = SystemTime.wMinute;
lpTod->tod_secs = SystemTime.wSecond;
lpTod->tod_hunds = SystemTime.wMilliseconds / 10;
lpTod->tod_day = SystemTime.wDay;
lpTod->tod_month = SystemTime.wMonth;
lpTod->tod_year = SystemTime.wYear;
lpTod->tod_weekday = SystemTime.wDayOfWeek;
return NERR_Success;
}
int
main(
int argc,
char *argv[]
)
{
ULONG i;
//
// We're starting the test
//
DbgPrint("Start Time Test\n");
//
// Start by initializing some constants and making sure they
// are correct
//
Zero.QuadPart = 0;
OneSecond.QuadPart = 10000000;
OneMinute.QuadPart = OneSecond.QuadPart * 60;
OneHour.QuadPart = OneMinute.QuadPart * 60;
OneDay.QuadPart = OneHour.QuadPart * 24;
OneWeek.QuadPart = OneDay.QuadPart * 7;
OneNormalYear.QuadPart = OneDay.QuadPart * 365;
OneLeapYear.QuadPart = OneDay.QuadPart * 366;
OneCentury.QuadPart = (OneNormalYear.QuadPart * 76) + (OneLeapYear.QuadPart * 24);
TwoCenturies.QuadPart = OneCentury.QuadPart * 2;
ThreeCenturies.QuadPart = OneCentury.QuadPart * 3;
FourCenturies.QuadPart = (OneCentury.QuadPart * 4) + OneDay.QuadPart;
Sum.QuadPart = Zero.QuadPart +
OneSecond.QuadPart +
OneMinute.QuadPart +
OneHour.QuadPart +
OneDay.QuadPart +
OneWeek.QuadPart +
OneNormalYear.QuadPart +
ThreeCenturies.QuadPart;
RtlTimeToTimeFields( (PLARGE_INTEGER)&Zero, &TimeFields );
DbgPrint("StartOf1601 = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to Zero\n");
}
if ((Time.LowPart != Zero.LowPart) || (Time.HighPart != Zero.HighPart)) {
DbgPrint("****ERROR Time != Zero\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneSecond, &TimeFields );
DbgPrint(" + 1 Second = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneSecond\n");
}
if ((Time.LowPart != OneSecond.LowPart) || (Time.HighPart != OneSecond.HighPart)) {
DbgPrint("****ERROR Time != OneSecond\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneMinute, &TimeFields );
DbgPrint(" + 1 Minute = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneMinute\n");
}
if ((Time.LowPart != OneMinute.LowPart) || (Time.HighPart != OneMinute.HighPart)) {
DbgPrint("****ERROR Time != OneMinute\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneHour, &TimeFields );
DbgPrint(" + 1 Hour = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneHour\n");
}
if ((Time.LowPart != OneHour.LowPart) || (Time.HighPart != OneHour.HighPart)) {
DbgPrint("****ERROR Time != OneHour\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneDay, &TimeFields );
DbgPrint(" + 1 Day = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneDay\n");
}
if ((Time.LowPart != OneDay.LowPart) || (Time.HighPart != OneDay.HighPart)) {
DbgPrint("****ERROR Time != OneDay\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneWeek, &TimeFields );
DbgPrint(" + 1 Week = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneWeek\n");
}
if ((Time.LowPart != OneWeek.LowPart) || (Time.HighPart != OneWeek.HighPart)) {
DbgPrint("****ERROR Time != OneWeek\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneNormalYear, &TimeFields );
DbgPrint(" + 1 NormalYear = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneNormalYear\n");
}
if ((Time.LowPart != OneNormalYear.LowPart) || (Time.HighPart != OneNormalYear.HighPart)) {
DbgPrint("****ERROR Time != OneNormalYear\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneLeapYear, &TimeFields );
DbgPrint(" + 1 LeapYear = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneLeapYear\n");
}
if ((Time.LowPart != OneLeapYear.LowPart) || (Time.HighPart != OneLeapYear.HighPart)) {
DbgPrint("****ERROR Time != OneLeapYear\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&OneCentury, &TimeFields );
DbgPrint(" + 1 Century = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to OneCentury\n");
}
if ((Time.LowPart != OneCentury.LowPart) || (Time.HighPart != OneCentury.HighPart)) {
DbgPrint("****ERROR Time != OneCentury\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&TwoCenturies, &TimeFields );
DbgPrint(" + 2 Centuries = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to TwoCenturies\n");
}
if ((Time.LowPart != TwoCenturies.LowPart) || (Time.HighPart != TwoCenturies.HighPart)) {
DbgPrint("****ERROR Time != TwoCenturies\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&ThreeCenturies, &TimeFields );
DbgPrint(" + 3 Centuries = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to ThreeCenturies\n");
}
if ((Time.LowPart != ThreeCenturies.LowPart) || (Time.HighPart != ThreeCenturies.HighPart)) {
DbgPrint("****ERROR Time != ThreeCenturies\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&FourCenturies, &TimeFields );
DbgPrint(" + 4 Centuries = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to FourCenturies\n");
}
if ((Time.LowPart != FourCenturies.LowPart) || (Time.HighPart != FourCenturies.HighPart)) {
DbgPrint("****ERROR Time != FourCenturies\n");
}
RtlTimeToTimeFields( (PLARGE_INTEGER)&Sum, &TimeFields );
DbgPrint(" + sum = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to Sum\n");
}
if ((Time.LowPart != Sum.LowPart) || (Time.HighPart != Sum.HighPart)) {
DbgPrint("****ERROR Time != Sum\n");
}
DbgPrint("\n");
//
// Setup and test the start 1970 time
//
RtlSecondsSince1970ToTime( 0, &StartOf1970 );
RtlTimeToTimeFields( &StartOf1970, &TimeFields );
DbgPrint(" Start of 1970 = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to start of 1970\n");
}
if ((Time.LowPart != StartOf1970.LowPart) || (Time.HighPart != StartOf1970.HighPart)) {
DbgPrint("****ERROR Time != StartOf1970\n");
}
if (!RtlTimeToSecondsSince1970( &StartOf1970, &i )) {
DbgPrint("****ERROR converting time to seconds since 1970\n");
}
if (i != 0) {
DbgPrint("****ERROR seconds since 1970 != 0\n");
}
//
// Setup and test the start 1980 time
//
RtlSecondsSince1980ToTime( 0, &StartOf1980 );
RtlTimeToTimeFields( &StartOf1980, &TimeFields );
DbgPrint(" Start of 1980 = "); PrintTimeFields( &TimeFields ); DbgPrint("\n");
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields back to start of 1980\n");
}
if ((Time.LowPart != StartOf1980.LowPart) || (Time.HighPart != StartOf1980.HighPart)) {
DbgPrint("****ERROR Time != StartOf1980\n");
}
if (!RtlTimeToSecondsSince1980( &StartOf1980, &i )) {
DbgPrint("****ERROR converting time to seconds since 1980\n");
}
if (i != 0) {
DbgPrint("****ERROR seconds since 1980 != 0\n");
}
//
// Lets try to print the Christmas when Santa arrives for 1901 to 2001
// every 10 years
//
TimeFields.Month = 12;
TimeFields.Day = 25;
TimeFields.Hour = 3;
TimeFields.Minute = 30;
TimeFields.Second = 15;
TimeFields.Milliseconds = 250;
for (i = 1901; i < 2002; i += 10) {
TimeFields.Year = i;
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields to Christmas %4d\n", TimeFields.Year);
}
RtlTimeToTimeFields( &Time, &TimeFields );
DbgPrint(" Christmas %4d = ", i); PrintTimeFields( &TimeFields ); DbgPrint("\n");
}
//
// Let's see how old I really am, when I turn 10, 20, 30, ...
//
TimeFields.Month = 12;
TimeFields.Day = 5;
TimeFields.Hour = 3;
TimeFields.Minute = 14;
TimeFields.Second = 0;
TimeFields.Milliseconds = 0;
for (i = 1956; i <= 1956+60; i += 10) {
TimeFields.Year = i;
if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
DbgPrint("****ERROR converting TimeFields to DOB %4d\n", TimeFields.Year);
}
RtlTimeToTimeFields( &Time, &TimeFields );
DbgPrint(" DOB + %4d = ", i-1956); PrintTimeFields( &TimeFields ); DbgPrint("\n");
}
DbgPrint("End Time Test\n");
return TRUE;
}
NTSTATUS
timesvc_RemoteTimeOfDay(
OUT LPTIME_OF_DAY_INFO *lpTimeOfDayInfo
)
/*++
Routine Description:
This routine calls the Win32 and NT base timer APIs to get the
relevant time/date information. It also calls the Rtl routine to
convert the time elapsed since 1-1-1970.
The routine allocates a buffer to contain the time of day information
and returns a pointer to that buffer to the caller.
Arguments:
lpTimeOfDayInfo - Location of where to place pointer to buffer.
Return Value:
NTSTATUS - STATUS_SUCCESS or reason for failure.
--*/
{
SYSTEMTIME SystemTime;
LARGE_INTEGER Time;
DWORD TickCount;
LPTIME_OF_DAY_INFO lpTimeOfDay;
LONG LocalTimeZoneOffsetSecs; // offset (+ for West of GMT, etc).
if (lpTimeOfDayInfo == NULL) {
return (STATUS_INVALID_PARAMETER);
}
//
// Call the appropriate routines to collect the time information
//
GetSystemTime(&SystemTime);
//
// Get number of seconds from UTC. Positive values for west of Greenwich,
// negative values for east of Greenwich.
//
LocalTimeZoneOffsetSecs = NetpLocalTimeZoneOffset();
//
// Allocate a TimeOfDay_INFO structure that is to be returned to the
// caller and fill it with the relevant data.
//
*lpTimeOfDayInfo = (TIME_OF_DAY_INFO *) MIDL_user_allocate(
sizeof (struct _TIME_OF_DAY_INFO)
);
if (*lpTimeOfDayInfo == NULL) {
SS_PRINT((
"SRVSVC: timesvc_RemoteTimeOfDay"
"got NULL from MIDL_user_allocate!\n" ));
return(STATUS_NO_MEMORY);
}
lpTimeOfDay = (LPTIME_OF_DAY_INFO)(*lpTimeOfDayInfo);
lpTimeOfDay->tod_hours = SystemTime.wHour;
lpTimeOfDay->tod_mins = SystemTime.wMinute;
lpTimeOfDay->tod_secs = SystemTime.wSecond;
lpTimeOfDay->tod_hunds = SystemTime.wMilliseconds/10;
lpTimeOfDay->tod_tinterval = TOD_DEFAULT_INTERVAL;
lpTimeOfDay->tod_day = SystemTime.wDay;
lpTimeOfDay->tod_month = SystemTime.wMonth;
lpTimeOfDay->tod_year = SystemTime.wYear;
lpTimeOfDay->tod_weekday = SystemTime.wDayOfWeek;
// tod_timezone is + for west of GMT, - for east of it.
// tod_timezone is in minutes.
lpTimeOfDay->tod_timezone = LocalTimeZoneOffsetSecs / 60;
// Get the 64-bit system time.
// Convert the system time to the number of miliseconds
// since 1-1-1970.
//
NtQuerySystemTime(&Time);
RtlTimeToSecondsSince1970(&Time,
&(lpTimeOfDay->tod_elapsedt)
);
// Get the free running counter value
//
TickCount = GetTickCount();
lpTimeOfDay->tod_msecs = TickCount;
return(STATUS_SUCCESS);
} // timesvc_RemoteTimeOfDay
VOID RplAlertRaise( IN DWORD ErrorCode)
/*++
Routine Description:
Sends an ADMIN alert. The input is a LanManager error message.
This is a combination of the original Send_alert() routine &&
RaiseAlert() routine from logonsrv\server\error.c
Arguments:
ErrorCode - the alert to be raised, text in alertmsg.h
Return Value:
None.
Notes:
Failing to post an alert is considered unimportant. This is why this
function is VOID.
--*/
{
char message[ ALERTSZ + sizeof(STD_ALERT) + sizeof(ADMIN_OTHER_INFO)];
PSTD_ALERT alert = (PSTD_ALERT)message;
PADMIN_OTHER_INFO other = (PADMIN_OTHER_INFO)ALERT_OTHER_INFO( alert);
LARGE_INTEGER time;
HANDLE fileHandle;
DWORD inBytes;
DWORD outBytes;
NtQuerySystemTime( &time);
RtlTimeToSecondsSince1970( &time, &alert->alrt_timestamp );
// Original code used alrt_servicename == SERVICE_SERVER
wcscpy( alert->alrt_servicename, SERVICE_RIPL);
wcscpy( alert->alrt_eventname, ALERT_ADMIN_EVENT );
other->alrtad_errcode = ErrorCode;
other->alrtad_numstrings = 0;
// NetAlertRaise() is gone, must use mailslots instead. So, first
// open the Alerter mailslot to write to it.
fileHandle = CreateFile(
ALERTER_MAILSLOT,
GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ,
(LPSECURITY_ATTRIBUTES) NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( fileHandle == INVALID_HANDLE_VALUE) {
RplDump( RG_DebugLevel & RPL_DEBUG_MISC,(
"AlertRaise: Error opening alerter mailslot, error=%d",
GetLastError()));
return;
}
inBytes = min( sizeof( message),
(DWORD)( (PCHAR)ALERT_VAR_DATA(other) - (PCHAR)message));
// Write alert notification to mailslot to be read by Alerter service
if ( !WriteFile(
fileHandle,
message,
inBytes,
&outBytes,
NULL) || inBytes != outBytes) {
RplDump( RG_DebugLevel & RPL_DEBUG_MISC,(
"AlertRaise: Error writing to alerter mailslot %d",
GetLastError()));
} else if ( ! CloseHandle( fileHandle)) {
RplDump( RG_DebugLevel & RPL_DEBUG_MISC,(
"AlertRaise: Error closing alerter mailslot %d",
GetLastError()
));
}
(VOID)CloseHandle( fileHandle);
}
/******************************************************************************
* ReportEventW [ADVAPI32.@]
*
* PARAMS
* hEventLog []
* wType []
* wCategory []
* dwEventID []
* lpUserSid []
* wNumStrings []
* dwDataSize []
* lpStrings []
* lpRawData []
*/
BOOL WINAPI
ReportEventW(IN HANDLE hEventLog,
IN WORD wType,
IN WORD wCategory,
IN DWORD dwEventID,
IN PSID lpUserSid,
IN WORD wNumStrings,
IN DWORD dwDataSize,
IN LPCWSTR *lpStrings,
IN LPVOID lpRawData)
{
NTSTATUS Status;
PUNICODE_STRING *Strings;
UNICODE_STRING ComputerName;
WORD i;
WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwSize;
LARGE_INTEGER SystemTime;
ULONG Seconds;
TRACE("%p, %u, %u, %lu, %p, %u, %lu, %p, %p\n",
hEventLog, wType, wCategory, dwEventID, lpUserSid,
wNumStrings, dwDataSize, lpStrings, lpRawData);
Strings = HeapAlloc(GetProcessHeap(),
0,
wNumStrings * sizeof(PUNICODE_STRING));
if (!Strings)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
for (i = 0; i < wNumStrings; i++)
{
Strings[i] = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(ANSI_STRING));
if (Strings[i])
{
RtlInitUnicodeString(Strings[i], lpStrings[i]);
}
}
dwSize = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerNameW(szComputerName, &dwSize);
RtlInitUnicodeString(&ComputerName, szComputerName);
NtQuerySystemTime(&SystemTime);
RtlTimeToSecondsSince1970(&SystemTime, &Seconds);
RpcTryExcept
{
Status = ElfrReportEventW(hEventLog,
Seconds,
wType,
wCategory,
dwEventID,
wNumStrings,
dwDataSize,
(PRPC_UNICODE_STRING)&ComputerName,
lpUserSid,
(PRPC_UNICODE_STRING*)Strings,
lpRawData,
0,
NULL,
NULL);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
for (i = 0; i < wNumStrings; i++)
{
if (Strings[i] != NULL)
HeapFree(GetProcessHeap(), 0, Strings[i]);
}
HeapFree(GetProcessHeap(), 0, Strings);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
}
static
BOOL
ParseDate(
PWSTR s,
PULONG pSeconds)
{
SYSTEMTIME SystemTime = {0};
FILETIME LocalFileTime, FileTime;
LARGE_INTEGER Time;
INT nDateFormat = 0;
PWSTR p = s;
if (!*s)
return FALSE;
GetLocaleInfoW(LOCALE_USER_DEFAULT,
LOCALE_IDATE,
(PWSTR)&nDateFormat,
sizeof(INT));
switch (nDateFormat)
{
case 0: /* mmddyy */
default:
if (!ReadNumber(&p, &SystemTime.wMonth))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wDay))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wYear))
return FALSE;
break;
case 1: /* ddmmyy */
if (!ReadNumber(&p, &SystemTime.wDay))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wMonth))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wYear))
return FALSE;
break;
case 2: /* yymmdd */
if (!ReadNumber(&p, &SystemTime.wYear))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wMonth))
return FALSE;
if (!ReadSeparator(&p))
return FALSE;
if (!ReadNumber(&p, &SystemTime.wDay))
return FALSE;
break;
}
/* if only entered two digits: */
/* assume 2000's if value less than 80 */
/* assume 1900's if value greater or equal 80 */
if (SystemTime.wYear <= 99)
{
if (SystemTime.wYear >= 80)
SystemTime.wYear += 1900;
else
SystemTime.wYear += 2000;
}
if (!SystemTimeToFileTime(&SystemTime, &LocalFileTime))
return FALSE;
if (!LocalFileTimeToFileTime(&LocalFileTime, &FileTime))
return FALSE;
Time.u.LowPart = FileTime.dwLowDateTime;
Time.u.HighPart = FileTime.dwHighDateTime;
if (!RtlTimeToSecondsSince1970(&Time, pSeconds))
return FALSE;
return TRUE;
}
VOID
NlComputeChallenge(
OUT PNETLOGON_CREDENTIAL Challenge
)
/*++
Routine Description:
Generates a 64 bit challenge
Make an 8 byte seed by filling in BigTime i.e. seconds
since Jan 1 1970 in lower four bytes and a counter in
upper four bytes. Counter is incremented after each use.
This seed is used as encryption key to encrypt standard
text which will be used as challenge.
Arguments:
Challenge - Returns the computed challenge
Return Value:
None.
--*/
{
NTSTATUS Status;
char Seed[PWLEN];
LM_OWF_PASSWORD BigChallenge;
LARGE_INTEGER TimeNow;
RtlZeroMemory(Seed, sizeof(Seed) );
//
// we need to remember ClientChallenge and RequestorName for future use
// put these into shared seg SSISEG
// NlGlobalSessionCounter is a global initialized to 0 at UAS init time
//
Status = NtQuerySystemTime( &TimeNow );
NlAssert( NT_SUCCESS(Status) );
Status = RtlTimeToSecondsSince1970( &TimeNow, ((unsigned long * ) Seed) );
NlAssert( NT_SUCCESS(Status) );
*((unsigned long * ) & Seed[4]) = NlGlobalSessionCounter++;
//
// Create ClientChallenge
//
// NOTE: RtlCalculateLmOwfPassword() will generate 16 byte txt
//
Status = RtlCalculateLmOwfPassword(Seed, &BigChallenge);
NlAssert( NT_SUCCESS(Status) );
//
// we need (or will use) only 8 bytes of this info
//
RtlCopyMemory(Challenge, &BigChallenge, sizeof(Challenge) );
return;
}
