// function like DosDateTimeToFileTime BOOLEAN FsdDosDateTimeToSystemTime (PDEVICE_EXTENSION DeviceExt, USHORT DosDate, USHORT DosTime, PLARGE_INTEGER SystemTime) { PDOSTIME pdtime = (PDOSTIME) &DosTime; PDOSDATE pddate = (PDOSDATE) &DosDate; TIME_FIELDS TimeFields; LARGE_INTEGER LocalTime; if (SystemTime == NULL) return FALSE; TimeFields.Milliseconds = 0; TimeFields.Second = pdtime->Second * 2; TimeFields.Minute = pdtime->Minute; TimeFields.Hour = pdtime->Hour; TimeFields.Day = pddate->Day; TimeFields.Month = pddate->Month; TimeFields.Year = (CSHORT)(DeviceExt->BaseDateYear + pddate->Year); RtlTimeFieldsToTime (&TimeFields, &LocalTime); ExLocalTimeToSystemTime(&LocalTime, SystemTime); return TRUE; }
LARGE_INTEGER FatFatDateToNtTime ( IN PIRP_CONTEXT IrpContext, IN FAT_DATE FatDate ) /*++ Routine Description: This routine converts a Fat datev value to its corresponding Nt GMT Time value. Arguments: FatDate - Supplies the Fat Date to convert from Return Value: LARGE_INTEGER - Receives the corresponding Nt Time value --*/ { TIME_FIELDS TimeFields; LARGE_INTEGER Time; // // Pack the input time/date into a time field record // TimeFields.Year = (USHORT)(FatDate.Year + 1980); TimeFields.Month = (USHORT)(FatDate.Month); TimeFields.Day = (USHORT)(FatDate.Day); TimeFields.Hour = (USHORT)0; TimeFields.Minute = (USHORT)0; TimeFields.Second = (USHORT)0; TimeFields.Milliseconds = (USHORT)0; // // Convert the time field record to Nt LARGE_INTEGER, and set it to zero // if we were given a bogus time. // if (!RtlTimeFieldsToTime( &TimeFields, &Time )) { Time.LowPart = 0; Time.HighPart = 0; } else { ExLocalTimeToSystemTime( &Time, &Time ); } return Time; UNREFERENCED_PARAMETER( IrpContext ); }
NTSTATUS ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation) { LARGE_INTEGER LocalTime, SystemTime, OldTime; TIME_FIELDS TimeFields; DPRINT("ExpSetTimeZoneInformation() called\n"); DPRINT("Old time zone bias: %d minutes\n", ExpTimeZoneInfo.Bias); DPRINT("Old time zone standard bias: %d minutes\n", ExpTimeZoneInfo.StandardBias); DPRINT("New time zone bias: %d minutes\n", TimeZoneInformation->Bias); DPRINT("New time zone standard bias: %d minutes\n", TimeZoneInformation->StandardBias); /* Get the local time */ HalQueryRealTimeClock(&TimeFields); RtlTimeFieldsToTime(&TimeFields, &LocalTime); /* FIXME: Calculate transition dates */ /* Calculate the bias and set the ID */ ExpTimeZoneBias.QuadPart = ((LONGLONG)(TimeZoneInformation->Bias + TimeZoneInformation->StandardBias)) * TICKSPERMINUTE; ExpTimeZoneId = TIME_ZONE_ID_STANDARD; /* Copy the timezone information */ RtlCopyMemory(&ExpTimeZoneInfo, TimeZoneInformation, sizeof(TIME_ZONE_INFORMATION)); /* Set the new time zone information */ SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart; SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart; SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart; SharedUserData->TimeZoneId = ExpTimeZoneId; DPRINT("New time zone bias: %I64d minutes\n", ExpTimeZoneBias.QuadPart / TICKSPERMINUTE); /* Calculate the new system time */ ExLocalTimeToSystemTime(&LocalTime, &SystemTime); /* Set the new system time */ KeSetSystemTime(&SystemTime, &OldTime, FALSE, NULL); /* Return success */ DPRINT("ExpSetTimeZoneInformation() done\n"); return STATUS_SUCCESS; }
FORCEINLINE VOID FatDateTimeToSystemTime(OUT PLARGE_INTEGER SystemTime, IN PFAT_DATETIME FatDateTime, IN UCHAR TenMs OPTIONAL) { TIME_FIELDS TimeFields; /* Setup time fields */ TimeFields.Year = FatDateTime->Date.Year + 1980; TimeFields.Month = FatDateTime->Date.Month; TimeFields.Day = FatDateTime->Date.Day; TimeFields.Hour = FatDateTime->Time.Hour; TimeFields.Minute = FatDateTime->Time.Minute; TimeFields.Second = (FatDateTime->Time.DoubleSeconds << 1); /* Adjust up to 10 milliseconds * if the parameter was supplied */ if (ARGUMENT_PRESENT(TenMs)) { TimeFields.Second += TenMs / 100; TimeFields.Milliseconds = (TenMs % 100) * 10; } else { TimeFields.Milliseconds = 0; } /* Fix seconds value that might get beyoud the bound */ if (TimeFields.Second > 59) TimeFields.Second = 0; /* Perform ceonversion to system time if possible */ if (RtlTimeFieldsToTime(&TimeFields, SystemTime)) { /* Convert to system time */ ExLocalTimeToSystemTime(SystemTime, SystemTime); } else { /* Set to default time if conversion failed */ *SystemTime = FatGlobalData.DefaultFileTime; } }
BOOLEAN FatNtTimeToFatTime ( IN PIRP_CONTEXT IrpContext, IN PLARGE_INTEGER NtTime, IN BOOLEAN Rounding, OUT PFAT_TIME_STAMP FatTime, OUT OPTIONAL PCHAR TenMsecs ) /*++ Routine Description: This routine converts an NtTime value to its corresponding Fat time value. Arguments: NtTime - Supplies the Nt GMT Time value to convert from Rounding - Indicates whether the NT time should be rounded up to a FAT boundary. This should only be done *once* in the lifetime of a timestamp (important for tunneling, which will cause a timestamp to pass through at least twice). If true, rounded up. If false, rounded down to 10ms boundary. This obeys the rules for non-creation time and creation times (respectively). FatTime - Receives the equivalent Fat time value TenMsecs - Optionally receive the number of tens of milliseconds the NtTime, after any rounding, is greater than the FatTime Return Value: BOOLEAN - TRUE if the Nt time value is within the range of Fat's time range, and FALSE otherwise --*/ { TIME_FIELDS TimeFields; // // Convert the input to the a time field record. // if (Rounding) { // // Add almost two seconds to round up to the nearest double second. // NtTime->QuadPart = NtTime->QuadPart + AlmostTwoSeconds; } ExSystemTimeToLocalTime( NtTime, NtTime ); RtlTimeToTimeFields( NtTime, &TimeFields ); // // Check the range of the date found in the time field record // if ((TimeFields.Year < 1980) || (TimeFields.Year > (1980 + 127))) { ExLocalTimeToSystemTime( NtTime, NtTime ); return FALSE; } // // The year will fit in Fat so simply copy over the information // FatTime->Time.DoubleSeconds = (USHORT)(TimeFields.Second / 2); FatTime->Time.Minute = (USHORT)(TimeFields.Minute); FatTime->Time.Hour = (USHORT)(TimeFields.Hour); FatTime->Date.Year = (USHORT)(TimeFields.Year - 1980); FatTime->Date.Month = (USHORT)(TimeFields.Month); FatTime->Date.Day = (USHORT)(TimeFields.Day); if (TenMsecs) { if (!Rounding) { // // If the number of seconds was not divisible by two, then there // is another second of time (1 sec, 3 sec, etc.) Note we round down // the number of milleconds onto tens of milleseconds boundaries. // *TenMsecs = (TimeFields.Milliseconds / 10) + ((TimeFields.Second % 2) * 100); } else { // // If we rounded up, we have in effect changed the NT time. Therefore, // it does not differ from the FAT time. // *TenMsecs = 0; } } if (Rounding) { // // Slice off non-FAT boundary time and convert back to 64bit form // TimeFields.Milliseconds = 0; TimeFields.Second -= TimeFields.Second % 2; } else { // // Round down to 10ms boundary // TimeFields.Milliseconds -= TimeFields.Milliseconds % 10; } // // Convert back to NT time // (VOID) RtlTimeFieldsToTime(&TimeFields, NtTime); ExLocalTimeToSystemTime( NtTime, NtTime ); UNREFERENCED_PARAMETER( IrpContext ); return TRUE; }
LARGE_INTEGER FatFatTimeToNtTime ( IN PIRP_CONTEXT IrpContext, IN FAT_TIME_STAMP FatTime, IN UCHAR TenMilliSeconds ) /*++ Routine Description: This routine converts a Fat time value pair to its corresponding Nt GMT Time value. Arguments: FatTime - Supplies the Fat Time to convert from TenMilliSeconds - A 10 Milisecond resolution Return Value: LARGE_INTEGER - Receives the corresponding Nt GMT Time value --*/ { TIME_FIELDS TimeFields; LARGE_INTEGER Time; // // Pack the input time/date into a time field record // TimeFields.Year = (USHORT)(FatTime.Date.Year + 1980); TimeFields.Month = (USHORT)(FatTime.Date.Month); TimeFields.Day = (USHORT)(FatTime.Date.Day); TimeFields.Hour = (USHORT)(FatTime.Time.Hour); TimeFields.Minute = (USHORT)(FatTime.Time.Minute); TimeFields.Second = (USHORT)(FatTime.Time.DoubleSeconds * 2); if (TenMilliSeconds != 0) { TimeFields.Second += (USHORT)(TenMilliSeconds / 100); TimeFields.Milliseconds = (USHORT)((TenMilliSeconds % 100) * 10); } else { TimeFields.Milliseconds = (USHORT)0; } // // If the second value is greater than 59 then we truncate it to 0. // Note that this can't happen with a proper FAT timestamp. // if (TimeFields.Second > 59) { TimeFields.Second = 0; } // // Convert the time field record to Nt LARGE_INTEGER, and set it to zero // if we were given a bogus time. // if (!RtlTimeFieldsToTime( &TimeFields, &Time )) { Time.LowPart = 0; Time.HighPart = 0; } else { ExLocalTimeToSystemTime( &Time, &Time ); } return Time; UNREFERENCED_PARAMETER( IrpContext ); }