git.oblomov.eu Git - wine/blob - dlls/kernel/time.c

   1 /*
   2  * Win32 kernel time functions
   3  *
   4  * Copyright 1995 Martin von Loewis and Cameron Heide
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #ifdef HAVE_UNISTD_H
  25 # include <unistd.h>
  26 #endif
  27 #include <stdlib.h>
  28 #ifdef HAVE_SYS_TIME_H
  29 # include <sys/time.h>
  30 #endif
  31 #ifdef HAVE_SYS_TIMES_H
  32 # include <sys/times.h>
  33 #endif
  34
  35 #define NONAMELESSUNION
  36 #define NONAMELESSSTRUCT
  37 #include "file.h"
  38 #include "winternl.h"
  39 #include "winerror.h"
  40 #include "winnls.h"
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(win32);
  45
  46 /* maximum time adjustment in seconds for SetLocalTime and SetSystemTime */
  47 #define SETTIME_MAX_ADJUST 120
  48 #define CALINFO_MAX_YEAR 2029
  49
  50
  51 /***********************************************************************
  52  *              SetLocalTime            (KERNEL32.@)
  53  *
  54  *  Sets the local time using current time zone and daylight
  55  *  savings settings.
  56  *
  57  * RETURNS
  58  *
  59  *  True if the time was set, false if the time was invalid or the
  60  *  necessary permissions were not held.
  61  */
  62 BOOL WINAPI SetLocalTime(
  63     const SYSTEMTIME *systime) /* [in] The desired local time. */
  64 {
  65     FILETIME ft;
  66     LARGE_INTEGER st, st2;
  67     NTSTATUS status;
  68
  69     SystemTimeToFileTime( systime, &ft );
  70     st.s.LowPart = ft.dwLowDateTime;
  71     st.s.HighPart = ft.dwHighDateTime;
  72     RtlLocalTimeToSystemTime( &st, &st2 );
  73
  74     if ((status = NtSetSystemTime(&st2, NULL)))
  75         SetLastError( RtlNtStatusToDosError(status) );
  76     return !status;
  77 }
  78
  79
  80 /***********************************************************************
  81  *           GetSystemTimeAdjustment     (KERNEL32.@)
  82  *
  83  *  Indicates the period between clock interrupt and the amount the clock
  84  *  is adjusted each interrupt so as to keep it insync with an external source.
  85  *
  86  * RETURNS
  87  *
  88  *  Always returns true.
  89  *
  90  * BUGS
  91  *
  92  *  Only the special case of disabled time adjustments is supported.
  93  */
  94 BOOL WINAPI GetSystemTimeAdjustment(
  95     PDWORD lpTimeAdjustment,         /* [out] The clock adjustment per interupt in 100's of nanoseconds. */
  96     PDWORD lpTimeIncrement,          /* [out] The time between clock interupts in 100's of nanoseconds. */
  97     PBOOL  lpTimeAdjustmentDisabled) /* [out] The clock synchonisation has been disabled. */
  98 {
  99     *lpTimeAdjustment = 0;
 100     *lpTimeIncrement = 0;
 101     *lpTimeAdjustmentDisabled = TRUE;
 102     return TRUE;
 103 }
 104
 105
 106 /***********************************************************************
 107  *              SetSystemTime            (KERNEL32.@)
 108  *
 109  *  Sets the system time (utc).
 110  *
 111  * RETURNS
 112  *
 113  *  True if the time was set, false if the time was invalid or the
 114  *  necessary permissions were not held.
 115  */
 116 BOOL WINAPI SetSystemTime(
 117     const SYSTEMTIME *systime) /* [in] The desired system time. */
 118 {
 119     FILETIME ft;
 120     LARGE_INTEGER t;
 121     NTSTATUS status;
 122
 123     SystemTimeToFileTime( systime, &ft );
 124     t.s.LowPart = ft.dwLowDateTime;
 125     t.s.HighPart = ft.dwHighDateTime;
 126     if ((status = NtSetSystemTime(&t, NULL)))
 127         SetLastError( RtlNtStatusToDosError(status) );
 128     return !status;
 129 }
 130
 131
 132 /***********************************************************************
 133  *              GetTimeZoneInformation  (KERNEL32.@)
 134  *
 135  *  Fills in the a time zone information structure with values based on
 136  *  the current local time.
 137  *
 138  * RETURNS
 139  *
 140  *  The daylight savings time standard or TIME_ZONE_ID_INVALID if the call failed.
 141  */
 142 DWORD WINAPI GetTimeZoneInformation(
 143     LPTIME_ZONE_INFORMATION tzinfo) /* [out] The time zone structure to be filled in. */
 144 {
 145     NTSTATUS status;
 146     if ((status = RtlQueryTimeZoneInformation(tzinfo)))
 147         SetLastError( RtlNtStatusToDosError(status) );
 148     return TIME_ZONE_ID_STANDARD;
 149 }
 150
 151
 152 /***********************************************************************
 153  *              SetTimeZoneInformation  (KERNEL32.@)
 154  *
 155  *  Set the local time zone with values based on the time zone structure.
 156  *
 157  * RETURNS
 158  *
 159  *  True on successful setting of the time zone.
 160  */
 161 BOOL WINAPI SetTimeZoneInformation(
 162     const LPTIME_ZONE_INFORMATION tzinfo) /* [in] The new time zone. */
 163 {
 164     NTSTATUS status;
 165     if ((status = RtlSetTimeZoneInformation(tzinfo)))
 166         SetLastError( RtlNtStatusToDosError(status) );
 167     return !status;
 168 }
 169
 170
 171 /***********************************************************************
 172  *  _DayLightCompareDate
 173  *
 174  *  Compares two dates without looking at the year
 175  *
 176  * RETURNS
 177  *
 178  *  -1 if date < compareDate
 179  *   0 if date == compareDate
 180  *   1 if date > compareDate
 181  *  -2 if an error occures
 182  */
 183
 184 static int _DayLightCompareDate(
 185     const LPSYSTEMTIME date,                       /* [in] The date to compare. */
 186     const LPSYSTEMTIME compareDate)                /* [in] The daylight saving begin or end date */
 187 {
 188     int limit_day;
 189
 190     if (compareDate->wYear != 0)
 191     {
 192         if (date->wMonth < compareDate->wMonth)
 193             return -1; /* We are in a year before the date limit. */
 194
 195         if (date->wMonth > compareDate->wMonth)
 196             return 1; /* We are in a year after the date limit. */
 197     }
 198
 199     if (date->wMonth < compareDate->wMonth)
 200         return -1; /* We are in a month before the date limit. */
 201
 202     if (date->wMonth > compareDate->wMonth)
 203         return 1; /* We are in a month after the date limit. */
 204
 205     if (compareDate->wDayOfWeek <= 6)
 206     {
 207        SYSTEMTIME tmp;
 208        FILETIME tmp_ft;
 209
 210        /* compareDate->wDay is interpreted as number of the week in the month. */
 211        /* 5 means: the last week in the month */
 212        int weekofmonth = compareDate->wDay;
 213
 214          /* calculate day of week for the first day in the month */
 215         memcpy(&tmp, date, sizeof(SYSTEMTIME));
 216         tmp.wDay = 1;
 217         tmp.wDayOfWeek = -1;
 218
 219         if (weekofmonth == 5)
 220         {
 221              /* Go to the beginning of the next month. */
 222             if (++tmp.wMonth > 12)
 223             {
 224                 tmp.wMonth = 1;
 225                 ++tmp.wYear;
 226             }
 227         }
 228
 229         if (!SystemTimeToFileTime(&tmp, &tmp_ft))
 230             return -2;
 231
 232         if (weekofmonth == 5)
 233         {
 234           LONGLONG t, one_day;
 235
 236           t = tmp_ft.dwHighDateTime;
 237           t <<= 32;
 238           t += (UINT)tmp_ft.dwLowDateTime;
 239
 240           /* substract one day */
 241           one_day = 24*60*60;
 242           one_day *= 10000000;
 243           t -= one_day;
 244
 245           tmp_ft.dwLowDateTime  = (UINT)t;
 246           tmp_ft.dwHighDateTime = (UINT)(t >> 32);
 247         }
 248
 249         if (!FileTimeToSystemTime(&tmp_ft, &tmp))
 250             return -2;
 251
 252        if (weekofmonth == 5)
 253        {
 254           /* calculate the last matching day of the week in this month */
 255           int dif = tmp.wDayOfWeek - compareDate->wDayOfWeek;
 256           if (dif < 0)
 257              dif += 7;
 258
 259           limit_day = tmp.wDay - dif;
 260        }
 261        else
 262        {
 263           /* calulcate the matching day of the week in the given week */
 264           int dif = compareDate->wDayOfWeek - tmp.wDayOfWeek;
 265           if (dif < 0)
 266              dif += 7;
 267
 268           limit_day = tmp.wDay + 7*(weekofmonth-1) + dif;
 269        }
 270     }
 271     else
 272     {
 273        limit_day = compareDate->wDay;
 274     }
 275
 276     if (date->wDay < limit_day)
 277         return -1;
 278
 279     if (date->wDay > limit_day)
 280         return 1;
 281
 282     return 0;   /* date is equal to the date limit. */
 283 }
 284
 285
 286 /***********************************************************************
 287  *  _GetTimezoneBias
 288  *
 289  *  Calculates the local time bias for a given time zone
 290  *
 291  * RETURNS
 292  *
 293  *  Returns TRUE when the time zone bias was calculated.
 294  */
 295
 296 static BOOL _GetTimezoneBias(
 297     const LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The time zone data.            */
 298     LPSYSTEMTIME                  lpSystemTime,          /* [in] The system time.               */
 299     LONG*                         pBias)                 /* [out] The calulated bias in minutes */
 300 {
 301     int ret;
 302     BOOL beforedaylightsaving, afterdaylightsaving;
 303     BOOL daylightsaving = FALSE;
 304     LONG bias = lpTimeZoneInformation->Bias;
 305
 306     if (lpTimeZoneInformation->DaylightDate.wMonth != 0)
 307     {
 308         if (lpTimeZoneInformation->StandardDate.wMonth == 0 ||
 309             lpTimeZoneInformation->StandardDate.wDay<1 ||
 310             lpTimeZoneInformation->StandardDate.wDay>5 ||
 311             lpTimeZoneInformation->DaylightDate.wDay<1 ||
 312             lpTimeZoneInformation->DaylightDate.wDay>5)
 313         {
 314             SetLastError(ERROR_INVALID_PARAMETER);
 315             return FALSE;
 316         }
 317
 318          /* check for daylight saving */
 319        ret = _DayLightCompareDate(lpSystemTime, &lpTimeZoneInformation->StandardDate);
 320        if (ret == -2)
 321           return FALSE;
 322
 323         beforedaylightsaving = ret < 0;
 324
 325        _DayLightCompareDate(lpSystemTime, &lpTimeZoneInformation->DaylightDate);
 326        if (ret == -2)
 327           return FALSE;
 328
 329         afterdaylightsaving = ret >= 0;
 330
 331         if (!beforedaylightsaving && !afterdaylightsaving)
 332             daylightsaving = TRUE;
 333     }
 334
 335     if (daylightsaving)
 336         bias += lpTimeZoneInformation->DaylightBias;
 337     else if (lpTimeZoneInformation->StandardDate.wMonth != 0)
 338         bias += lpTimeZoneInformation->StandardBias;
 339
 340     *pBias = bias;
 341
 342     return TRUE;
 343 }
 344
 345
 346 /***********************************************************************
 347  *              SystemTimeToTzSpecificLocalTime  (KERNEL32.@)
 348  *
 349  *  Converts the system time (utc) to the local time in the specified time zone.
 350  *
 351  * RETURNS
 352  *
 353  *  Returns true when the local time was calculated.
 354  *  Returns TRUE when the local time was calculated.
 355  *
 356  */
 357
 358 BOOL WINAPI SystemTimeToTzSpecificLocalTime(
 359     LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The desired time zone. */
 360     LPSYSTEMTIME            lpUniversalTime,       /* [in] The utc time to base local time on. */
 361     LPSYSTEMTIME            lpLocalTime)           /* [out] The local time in the time zone. */
 362 {
 363     FILETIME ft;
 364     LONG lBias;
 365     LONGLONG t, bias;
 366     TIME_ZONE_INFORMATION tzinfo;
 367
 368     if (lpTimeZoneInformation != NULL)
 369     {
 370         memcpy(&tzinfo, lpTimeZoneInformation, sizeof(TIME_ZONE_INFORMATION));
 371     }
 372     else
 373     {
 374         if (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_INVALID)
 375             return FALSE;
 376     }
 377
 378     if (!SystemTimeToFileTime(lpUniversalTime, &ft))
 379         return FALSE;
 380
 381     t = ft.dwHighDateTime;
 382     t <<= 32;
 383     t += (UINT)ft.dwLowDateTime;
 384
 385     if (!_GetTimezoneBias(&tzinfo, lpUniversalTime, &lBias))
 386         return FALSE;
 387
 388     bias = lBias * 600000000; /* 60 seconds per minute, 100000 [100-nanoseconds-ticks] per second */
 389     t += bias;
 390
 391     ft.dwLowDateTime  = (UINT)t;
 392     ft.dwHighDateTime = (UINT)(t >> 32);
 393
 394     return FileTimeToSystemTime(&ft, lpLocalTime);
 395 }
 396
 397
 398 /***********************************************************************
 399  *              TzSpecificLocalTimeToSystemTime  (KERNEL32.@)
 400  *
 401  *  Converts a local time to a time in Coordinated Universal Time (UTC).
 402  *
 403  * RETURNS
 404  *
 405  *  Returns TRUE when the utc time was calculated.
 406  */
 407
 408 BOOL WINAPI TzSpecificLocalTimeToSystemTime(
 409     LPTIME_ZONE_INFORMATION lpTimeZoneInformation, /* [in] The desired time zone. */
 410     LPSYSTEMTIME            lpLocalTime,           /* [in] The local time. */
 411     LPSYSTEMTIME            lpUniversalTime)       /* [out] The calculated utc time. */
 412 {
 413     FILETIME ft;
 414     LONG lBias;
 415     LONGLONG t, bias;
 416     TIME_ZONE_INFORMATION tzinfo;
 417
 418     if (lpTimeZoneInformation != NULL)
 419     {
 420         memcpy(&tzinfo, lpTimeZoneInformation, sizeof(TIME_ZONE_INFORMATION));
 421     }
 422     else
 423     {
 424         if (GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_INVALID)
 425             return FALSE;
 426     }
 427
 428     if (!SystemTimeToFileTime(lpLocalTime, &ft))
 429         return FALSE;
 430
 431     t = ft.dwHighDateTime;
 432     t <<= 32;
 433     t += (UINT)ft.dwLowDateTime;
 434
 435     if (!_GetTimezoneBias(&tzinfo, lpUniversalTime, &lBias))
 436         return FALSE;
 437
 438     bias = lBias * 600000000; /* 60 seconds per minute, 100000 [100-nanoseconds-ticks] per second */
 439     t -= bias;
 440
 441     ft.dwLowDateTime  = (UINT)t;
 442     ft.dwHighDateTime = (UINT)(t >> 32);
 443
 444     return FileTimeToSystemTime(&ft, lpUniversalTime);
 445 }
 446
 447
 448
 449
 450 /***********************************************************************
 451  *              GetSystemTimeAsFileTime  (KERNEL32.@)
 452  *
 453  *  Fills in a file time structure with the current time in UTC format.
 454  */
 455 VOID WINAPI GetSystemTimeAsFileTime(
 456     LPFILETIME time) /* [out] The file time struct to be filled with the system time. */
 457 {
 458     LARGE_INTEGER t;
 459     NtQuerySystemTime( &t );
 460     time->dwLowDateTime = t.s.LowPart;
 461     time->dwHighDateTime = t.s.HighPart;
 462 }
 463
 464
 465 /*********************************************************************
 466  *      TIME_ClockTimeToFileTime    (olorin@fandra.org, 20-Sep-1998)
 467  *
 468  *  Used by GetProcessTimes to convert clock_t into FILETIME.
 469  *
 470  *      Differences to UnixTimeToFileTime:
 471  *          1) Divided by CLK_TCK
 472  *          2) Time is relative. There is no 'starting date', so there is
 473  *             no need in offset correction, like in UnixTimeToFileTime
 474  */
 475 static void TIME_ClockTimeToFileTime(clock_t unix_time, LPFILETIME filetime)
 476 {
 477     ULONGLONG secs = RtlEnlargedUnsignedMultiply( unix_time, 10000000 );
 478     secs = RtlExtendedLargeIntegerDivide( secs, CLK_TCK, NULL );
 479     filetime->dwLowDateTime  = (DWORD)secs;
 480     filetime->dwHighDateTime = (DWORD)(secs >> 32);
 481 }
 482
 483 /*********************************************************************
 484  *      GetProcessTimes                         (KERNEL32.@)
 485  *
 486  *  Returns the user and kernel execution times of a process,
 487  *  along with the creation and exit times if known.
 488  *
 489  *  olorin@fandra.org:
 490  *  Would be nice to subtract the cpu time, used by Wine at startup.
 491  *  Also, there is a need to separate times used by different applications.
 492  *
 493  * RETURNS
 494  *
 495  *  Always returns true.
 496  *
 497  * BUGS
 498  *
 499  *  lpCreationTime, lpExitTime are NOT INITIALIZED.
 500  */
 501 BOOL WINAPI GetProcessTimes(
 502     HANDLE     hprocess,       /* [in] The process to be queried (obtained from PROCESS_QUERY_INFORMATION). */
 503     LPFILETIME lpCreationTime, /* [out] The creation time of the process. */
 504     LPFILETIME lpExitTime,     /* [out] The exit time of the process if exited. */
 505     LPFILETIME lpKernelTime,   /* [out] The time spent in kernal routines in 100's of nanoseconds. */
 506     LPFILETIME lpUserTime)     /* [out] The time spent in user routines in 100's of nanoseconds. */
 507 {
 508     struct tms tms;
 509
 510     times(&tms);
 511     TIME_ClockTimeToFileTime(tms.tms_utime,lpUserTime);
 512     TIME_ClockTimeToFileTime(tms.tms_stime,lpKernelTime);
 513     return TRUE;
 514 }
 515
 516 /*********************************************************************
 517  *      GetCalendarInfoA                                (KERNEL32.@)
 518  *
 519  */
 520 int WINAPI GetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType,
 521                             LPSTR lpCalData, int cchData, LPDWORD lpValue)
 522 {
 523     int ret;
 524     LPWSTR lpCalDataW = NULL;
 525
 526     FIXME("(%08lx,%08lx,%08lx,%p,%d,%p): quarter-stub\n",
 527           Locale, Calendar, CalType, lpCalData, cchData, lpValue);
 528     /* FIXME: Should verify if Locale is allowable in ANSI, as per MSDN */
 529
 530     if(cchData)
 531       if(!(lpCalDataW = HeapAlloc(GetProcessHeap(), 0, cchData*sizeof(WCHAR)))) return 0;
 532
 533     ret = GetCalendarInfoW(Locale, Calendar, CalType, lpCalDataW, cchData, lpValue);
 534     if(ret && lpCalDataW && lpCalData)
 535       WideCharToMultiByte(CP_ACP, 0, lpCalDataW, cchData, lpCalData, cchData, NULL, NULL);
 536     if(lpCalDataW)
 537       HeapFree(GetProcessHeap(), 0, lpCalDataW);
 538
 539     return ret;
 540 }
 541
 542 /*********************************************************************
 543  *      GetCalendarInfoW                                (KERNEL32.@)
 544  *
 545  */
 546 int WINAPI GetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType,
 547                             LPWSTR lpCalData, int cchData, LPDWORD lpValue)
 548 {
 549     FIXME("(%08lx,%08lx,%08lx,%p,%d,%p): quarter-stub\n",
 550           Locale, Calendar, CalType, lpCalData, cchData, lpValue);
 551
 552     if (CalType & CAL_NOUSEROVERRIDE)
 553         FIXME("flag CAL_NOUSEROVERRIDE used, not fully implemented\n");
 554     if (CalType & CAL_USE_CP_ACP)
 555         FIXME("flag CAL_USE_CP_ACP used, not fully implemented\n");
 556
 557     if (CalType & CAL_RETURN_NUMBER) {
 558         if (lpCalData != NULL)
 559             WARN("lpCalData not NULL (%p) when it should!\n", lpCalData);
 560         if (cchData != 0)
 561             WARN("cchData not 0 (%d) when it should!\n", cchData);
 562     } else {
 563         if (lpValue != NULL)
 564             WARN("lpValue not NULL (%p) when it should!\n", lpValue);
 565     }
 566
 567     /* FIXME: No verification is made yet wrt Locale
 568      * for the CALTYPES not requiring GetLocaleInfoA */
 569     switch (CalType & ~(CAL_NOUSEROVERRIDE|CAL_RETURN_NUMBER|CAL_USE_CP_ACP)) {
 570         case CAL_ICALINTVALUE:
 571             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 572             return E_FAIL;
 573         case CAL_SCALNAME:
 574             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 575             return E_FAIL;
 576         case CAL_IYEAROFFSETRANGE:
 577             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 578             return E_FAIL;
 579         case CAL_SERASTRING:
 580             FIXME("Unimplemented caltype %ld\n", CalType & 0xffff);
 581             return E_FAIL;
 582         case CAL_SSHORTDATE:
 583             return GetLocaleInfoW(Locale, LOCALE_SSHORTDATE, lpCalData, cchData);
 584         case CAL_SLONGDATE:
 585             return GetLocaleInfoW(Locale, LOCALE_SLONGDATE, lpCalData, cchData);
 586         case CAL_SDAYNAME1:
 587             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME1, lpCalData, cchData);
 588         case CAL_SDAYNAME2:
 589             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME2, lpCalData, cchData);
 590         case CAL_SDAYNAME3:
 591             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME3, lpCalData, cchData);
 592         case CAL_SDAYNAME4:
 593             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME4, lpCalData, cchData);
 594         case CAL_SDAYNAME5:
 595             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME5, lpCalData, cchData);
 596         case CAL_SDAYNAME6:
 597             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME6, lpCalData, cchData);
 598         case CAL_SDAYNAME7:
 599             return GetLocaleInfoW(Locale, LOCALE_SDAYNAME7, lpCalData, cchData);
 600         case CAL_SABBREVDAYNAME1:
 601             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME1, lpCalData, cchData);
 602         case CAL_SABBREVDAYNAME2:
 603             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME2, lpCalData, cchData);
 604         case CAL_SABBREVDAYNAME3:
 605             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME3, lpCalData, cchData);
 606         case CAL_SABBREVDAYNAME4:
 607             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME4, lpCalData, cchData);
 608         case CAL_SABBREVDAYNAME5:
 609             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME5, lpCalData, cchData);
 610         case CAL_SABBREVDAYNAME6:
 611             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME6, lpCalData, cchData);
 612         case CAL_SABBREVDAYNAME7:
 613             return GetLocaleInfoW(Locale, LOCALE_SABBREVDAYNAME7, lpCalData, cchData);
 614         case CAL_SMONTHNAME1:
 615             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME1, lpCalData, cchData);
 616         case CAL_SMONTHNAME2:
 617             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME2, lpCalData, cchData);
 618         case CAL_SMONTHNAME3:
 619             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME3, lpCalData, cchData);
 620         case CAL_SMONTHNAME4:
 621             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME4, lpCalData, cchData);
 622         case CAL_SMONTHNAME5:
 623             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME5, lpCalData, cchData);
 624         case CAL_SMONTHNAME6:
 625             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME6, lpCalData, cchData);
 626         case CAL_SMONTHNAME7:
 627             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME7, lpCalData, cchData);
 628         case CAL_SMONTHNAME8:
 629             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME8, lpCalData, cchData);
 630         case CAL_SMONTHNAME9:
 631             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME9, lpCalData, cchData);
 632         case CAL_SMONTHNAME10:
 633             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME10, lpCalData, cchData);
 634         case CAL_SMONTHNAME11:
 635             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME11, lpCalData, cchData);
 636         case CAL_SMONTHNAME12:
 637             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME12, lpCalData, cchData);
 638         case CAL_SMONTHNAME13:
 639             return GetLocaleInfoW(Locale, LOCALE_SMONTHNAME13, lpCalData, cchData);
 640         case CAL_SABBREVMONTHNAME1:
 641             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME1, lpCalData, cchData);
 642         case CAL_SABBREVMONTHNAME2:
 643             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME2, lpCalData, cchData);
 644         case CAL_SABBREVMONTHNAME3:
 645             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME3, lpCalData, cchData);
 646         case CAL_SABBREVMONTHNAME4:
 647             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME4, lpCalData, cchData);
 648         case CAL_SABBREVMONTHNAME5:
 649             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME5, lpCalData, cchData);
 650         case CAL_SABBREVMONTHNAME6:
 651             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME6, lpCalData, cchData);
 652         case CAL_SABBREVMONTHNAME7:
 653             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME7, lpCalData, cchData);
 654         case CAL_SABBREVMONTHNAME8:
 655             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME8, lpCalData, cchData);
 656         case CAL_SABBREVMONTHNAME9:
 657             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME9, lpCalData, cchData);
 658         case CAL_SABBREVMONTHNAME10:
 659             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME10, lpCalData, cchData);
 660         case CAL_SABBREVMONTHNAME11:
 661             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME11, lpCalData, cchData);
 662         case CAL_SABBREVMONTHNAME12:
 663             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME12, lpCalData, cchData);
 664         case CAL_SABBREVMONTHNAME13:
 665             return GetLocaleInfoW(Locale, LOCALE_SABBREVMONTHNAME13, lpCalData, cchData);
 666         case CAL_SYEARMONTH:
 667             return GetLocaleInfoW(Locale, LOCALE_SYEARMONTH, lpCalData, cchData);
 668         case CAL_ITWODIGITYEARMAX:
 669             if (lpValue) *lpValue = CALINFO_MAX_YEAR;
 670             break;
 671         default: MESSAGE("Unknown caltype %ld\n",CalType & 0xffff);
 672                  return E_FAIL;
 673     }
 674     return 0;
 675 }
 676
 677 /*********************************************************************
 678  *      SetCalendarInfoA                                (KERNEL32.@)
 679  *
 680  */
 681 int WINAPI      SetCalendarInfoA(LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData)
 682 {
 683     FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
 684           Locale, Calendar, CalType, debugstr_a(lpCalData));
 685     return 0;
 686 }
 687
 688 /*********************************************************************
 689  *      SetCalendarInfoW                                (KERNEL32.@)
 690  *
 691  */
 692 int WINAPI      SetCalendarInfoW(LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData)
 693 {
 694     FIXME("(%08lx,%08lx,%08lx,%s): stub\n",
 695           Locale, Calendar, CalType, debugstr_w(lpCalData));
 696     return 0;
 697 }
 698
 699 /*********************************************************************
 700  *      LocalFileTimeToFileTime                         (KERNEL32.@)
 701  */
 702 BOOL WINAPI LocalFileTimeToFileTime( const FILETIME *localft, LPFILETIME utcft )
 703 {
 704     NTSTATUS status;
 705     LARGE_INTEGER local, utc;
 706
 707     local.s.LowPart = localft->dwLowDateTime;
 708     local.s.HighPart = localft->dwHighDateTime;
 709     if (!(status = RtlLocalTimeToSystemTime( &local, &utc )))
 710     {
 711         utcft->dwLowDateTime = utc.s.LowPart;
 712         utcft->dwHighDateTime = utc.s.HighPart;
 713     }
 714     else SetLastError( RtlNtStatusToDosError(status) );
 715
 716     return !status;
 717 }
 718
 719 /*********************************************************************
 720  *      FileTimeToLocalFileTime                         (KERNEL32.@)
 721  */
 722 BOOL WINAPI FileTimeToLocalFileTime( const FILETIME *utcft, LPFILETIME localft )
 723 {
 724     NTSTATUS status;
 725     LARGE_INTEGER local, utc;
 726
 727     utc.s.LowPart = utcft->dwLowDateTime;
 728     utc.s.HighPart = utcft->dwHighDateTime;
 729     if (!(status = RtlSystemTimeToLocalTime( &utc, &local )))
 730     {
 731         localft->dwLowDateTime = local.s.LowPart;
 732         localft->dwHighDateTime = local.s.HighPart;
 733     }
 734     else SetLastError( RtlNtStatusToDosError(status) );
 735
 736     return !status;
 737 }
 738
 739 /*********************************************************************
 740  *      FileTimeToSystemTime                            (KERNEL32.@)
 741  */
 742 BOOL WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
 743 {
 744     TIME_FIELDS tf;
 745     LARGE_INTEGER t;
 746
 747     t.s.LowPart = ft->dwLowDateTime;
 748     t.s.HighPart = ft->dwHighDateTime;
 749     RtlTimeToTimeFields(&t, &tf);
 750
 751     syst->wYear = tf.Year;
 752     syst->wMonth = tf.Month;
 753     syst->wDay = tf.Day;
 754     syst->wHour = tf.Hour;
 755     syst->wMinute = tf.Minute;
 756     syst->wSecond = tf.Second;
 757     syst->wMilliseconds = tf.Milliseconds;
 758     syst->wDayOfWeek = tf.Weekday;
 759     return TRUE;
 760 }
 761
 762 /*********************************************************************
 763  *      SystemTimeToFileTime                            (KERNEL32.@)
 764  */
 765 BOOL WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
 766 {
 767     TIME_FIELDS tf;
 768     LARGE_INTEGER t;
 769
 770     tf.Year = syst->wYear;
 771     tf.Month = syst->wMonth;
 772     tf.Day = syst->wDay;
 773     tf.Hour = syst->wHour;
 774     tf.Minute = syst->wMinute;
 775     tf.Second = syst->wSecond;
 776     tf.Milliseconds = syst->wMilliseconds;
 777
 778     RtlTimeFieldsToTime(&tf, &t);
 779     ft->dwLowDateTime = t.s.LowPart;
 780     ft->dwHighDateTime = t.s.HighPart;
 781     return TRUE;
 782 }
 783
 784 /*********************************************************************
 785  *      CompareFileTime                                 (KERNEL32.@)
 786  */
 787 INT WINAPI CompareFileTime( const FILETIME *x, const FILETIME *y )
 788 {
 789     if (!x || !y) return -1;
 790
 791     if (x->dwHighDateTime > y->dwHighDateTime)
 792         return 1;
 793     if (x->dwHighDateTime < y->dwHighDateTime)
 794         return -1;
 795     if (x->dwLowDateTime > y->dwLowDateTime)
 796         return 1;
 797     if (x->dwLowDateTime < y->dwLowDateTime)
 798         return -1;
 799     return 0;
 800 }
 801
 802 /*********************************************************************
 803  *      GetLocalTime                                    (KERNEL32.@)
 804  */
 805 VOID WINAPI GetLocalTime(LPSYSTEMTIME systime)
 806 {
 807     FILETIME lft;
 808     LARGE_INTEGER ft, ft2;
 809
 810     NtQuerySystemTime(&ft);
 811     RtlSystemTimeToLocalTime(&ft, &ft2);
 812     lft.dwLowDateTime = ft2.s.LowPart;
 813     lft.dwHighDateTime = ft2.s.HighPart;
 814     FileTimeToSystemTime(&lft, systime);
 815 }
 816
 817 /*********************************************************************
 818  *      GetSystemTime                                   (KERNEL32.@)
 819  */
 820 VOID WINAPI GetSystemTime(LPSYSTEMTIME systime)
 821 {
 822     FILETIME ft;
 823     LARGE_INTEGER t;
 824
 825     NtQuerySystemTime(&t);
 826     ft.dwLowDateTime = t.s.LowPart;
 827     ft.dwHighDateTime = t.s.HighPart;
 828     FileTimeToSystemTime(&ft, systime);
 829 }