dlls/msvcrt/time.c

   1 /*
   2  * msvcrt.dll date/time functions
   3  *
   4  * Copyright 1996,1998 Marcus Meissner
   5  * Copyright 1996 Jukka Iivonen
   6  * Copyright 1997,2000 Uwe Bonnes
   7  * Copyright 2000 Jon Griffiths
   8  * Copyright 2004 Hans Leidekker
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <locale.h>
  26 #include <stdlib.h>
  27 #include <time.h>
  28 #include <sys/timeb.h>
  29
  30 #include "msvcrt.h"
  31 #include "mtdll.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  38
  39 #undef _ctime32
  40 #undef _difftime32
  41 #undef _gmtime32
  42 #undef _localtime32
  43 #undef _mktime32
  44 #undef _time32
  45 #undef _wctime32
  46
  47 static LONGLONG init_time;
  48
  49 void msvcrt_init_clock(void)
  50 {
  51     LARGE_INTEGER systime;
  52
  53     NtQuerySystemTime(&systime);
  54     init_time = systime.QuadPart;
  55 }
  56
  57 static const int MonthLengths[2][12] =
  58 {
  59     { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  60     { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  61 };
  62
  63 #if _MSVCR_VER>=140
  64 static const int MAX_SECONDS = 60;
  65 #else
  66 static const int MAX_SECONDS = 59;
  67 #endif
  68
  69 static inline BOOL IsLeapYear(int Year)
  70 {
  71     return Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0);
  72 }
  73
  74 static inline void write_invalid_msvcrt_tm( struct tm *tm )
  75 {
  76     tm->tm_sec = -1;
  77     tm->tm_min = -1;
  78     tm->tm_hour = -1;
  79     tm->tm_mday = -1;
  80     tm->tm_mon = -1;
  81     tm->tm_year = -1;
  82     tm->tm_wday = -1;
  83     tm->tm_yday = -1;
  84     tm->tm_isdst = -1;
  85 }
  86
  87 /*********************************************************************
  88  *              _daylight (MSVCRT.@)
  89  */
  90 int MSVCRT___daylight = 1;
  91
  92 /*********************************************************************
  93  *              _timezone (MSVCRT.@)
  94  */
  95 __msvcrt_long MSVCRT___timezone = 28800;
  96
  97 /*********************************************************************
  98  *              _dstbias (MSVCRT.@)
  99  */
 100 __msvcrt_long MSVCRT__dstbias = -3600;
 101
 102 /*********************************************************************
 103  *              _tzname (MSVCRT.@)
 104  * NOTES
 105  *  Some apps (notably Mozilla) insist on writing to these, so the buffer
 106  *  must be large enough.
 107  */
 108 static char tzname_std[64] = "PST";
 109 static char tzname_dst[64] = "PDT";
 110 char *MSVCRT__tzname[2] = { tzname_std, tzname_dst };
 111
 112 static TIME_ZONE_INFORMATION tzi = {0};
 113 /*********************************************************************
 114  *              _tzset (MSVCRT.@)
 115  */
 116 void CDECL _tzset(void)
 117 {
 118     char *tz = getenv("TZ");
 119     BOOL error;
 120
 121     _lock(_TIME_LOCK);
 122     if(tz && tz[0]) {
 123         BOOL neg_zone = FALSE;
 124
 125         memset(&tzi, 0, sizeof(tzi));
 126
 127         /* Parse timezone information: tzn[+|-]hh[:mm[:ss]][dzn] */
 128         lstrcpynA(MSVCRT__tzname[0], tz, 3);
 129         tz += 3;
 130
 131         if(*tz == '-') {
 132             neg_zone = TRUE;
 133             tz++;
 134         }else if(*tz == '+') {
 135             tz++;
 136         }
 137         MSVCRT___timezone = strtol(tz, &tz, 10)*3600;
 138         if(*tz == ':') {
 139             MSVCRT___timezone += strtol(tz+1, &tz, 10)*60;
 140             if(*tz == ':')
 141                 MSVCRT___timezone += strtol(tz+1, &tz, 10);
 142         }
 143         if(neg_zone)
 144             MSVCRT___timezone = -MSVCRT___timezone;
 145
 146         MSVCRT___daylight = *tz;
 147         lstrcpynA(MSVCRT__tzname[1], tz, 3);
 148     }else if(GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_INVALID) {
 149         MSVCRT___timezone = tzi.Bias*60;
 150         if(tzi.StandardDate.wMonth)
 151             MSVCRT___timezone += tzi.StandardBias*60;
 152
 153         if(tzi.DaylightDate.wMonth) {
 154             MSVCRT___daylight = 1;
 155             MSVCRT__dstbias = (tzi.DaylightBias-tzi.StandardBias)*60;
 156         }else {
 157             MSVCRT___daylight = 0;
 158             MSVCRT__dstbias = 0;
 159         }
 160
 161         if(!WideCharToMultiByte(CP_ACP, 0, tzi.StandardName, -1, MSVCRT__tzname[0],
 162                     sizeof(tzname_std), NULL, &error) || error)
 163             *MSVCRT__tzname[0] = 0;
 164         if(!WideCharToMultiByte(CP_ACP, 0, tzi.DaylightName, -1, MSVCRT__tzname[1],
 165                     sizeof(tzname_dst), NULL, &error) || error)
 166             *MSVCRT__tzname[0] = 0;
 167     }
 168     _unlock(_TIME_LOCK);
 169 }
 170
 171 static void _tzset_init(void)
 172 {
 173     static BOOL init = FALSE;
 174
 175     if(!init) {
 176         _lock(_TIME_LOCK);
 177         if(!init) {
 178             _tzset();
 179             init = TRUE;
 180         }
 181         _unlock(_TIME_LOCK);
 182     }
 183 }
 184
 185 static BOOL is_dst(const SYSTEMTIME *st)
 186 {
 187     TIME_ZONE_INFORMATION tmp;
 188     SYSTEMTIME out;
 189
 190     if(!MSVCRT___daylight)
 191         return FALSE;
 192
 193     if(tzi.DaylightDate.wMonth) {
 194         tmp = tzi;
 195     }else if(st->wYear >= 2007) {
 196         memset(&tmp, 0, sizeof(tmp));
 197         tmp.StandardDate.wMonth = 11;
 198         tmp.StandardDate.wDay = 1;
 199         tmp.StandardDate.wHour = 2;
 200         tmp.DaylightDate.wMonth = 3;
 201         tmp.DaylightDate.wDay = 2;
 202         tmp.DaylightDate.wHour = 2;
 203     }else {
 204         memset(&tmp, 0, sizeof(tmp));
 205         tmp.StandardDate.wMonth = 10;
 206         tmp.StandardDate.wDay = 5;
 207         tmp.StandardDate.wHour = 2;
 208         tmp.DaylightDate.wMonth = 4;
 209         tmp.DaylightDate.wDay = 1;
 210         tmp.DaylightDate.wHour = 2;
 211     }
 212
 213     tmp.Bias = 0;
 214     tmp.StandardBias = 0;
 215     tmp.DaylightBias = MSVCRT__dstbias/60;
 216     if(!SystemTimeToTzSpecificLocalTime(&tmp, st, &out))
 217         return FALSE;
 218
 219     return memcmp(st, &out, sizeof(SYSTEMTIME));
 220 }
 221
 222 #define SECSPERDAY        86400
 223 /* 1601 to 1970 is 369 years plus 89 leap days */
 224 #define SECS_1601_TO_1970  ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
 225 #define TICKSPERSEC       10000000
 226 #define TICKSPERMSEC      10000
 227 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKSPERSEC)
 228
 229 static __time64_t mktime_helper(struct tm *mstm, BOOL local)
 230 {
 231     SYSTEMTIME st;
 232     FILETIME ft;
 233     __time64_t ret = 0;
 234     int i;
 235     BOOL use_dst = FALSE;
 236
 237     ret = mstm->tm_year + mstm->tm_mon/12;
 238     mstm->tm_mon %= 12;
 239     if(mstm->tm_mon < 0) {
 240         mstm->tm_mon += 12;
 241         ret--;
 242     }
 243
 244     if(ret<70 || ret>1100) {
 245         *_errno() = EINVAL;
 246         return -1;
 247     }
 248
 249     memset(&st, 0, sizeof(SYSTEMTIME));
 250     st.wDay = 1;
 251     st.wMonth = mstm->tm_mon+1;
 252     st.wYear = ret+1900;
 253
 254     if(!SystemTimeToFileTime(&st, &ft)) {
 255         *_errno() = EINVAL;
 256         return -1;
 257     }
 258
 259     ret = ((__time64_t)ft.dwHighDateTime<<32)+ft.dwLowDateTime;
 260     ret += (__time64_t)mstm->tm_sec*TICKSPERSEC;
 261     ret += (__time64_t)mstm->tm_min*60*TICKSPERSEC;
 262     ret += (__time64_t)mstm->tm_hour*60*60*TICKSPERSEC;
 263     ret += (__time64_t)(mstm->tm_mday-1)*SECSPERDAY*TICKSPERSEC;
 264
 265     ft.dwLowDateTime = ret & 0xffffffff;
 266     ft.dwHighDateTime = ret >> 32;
 267     FileTimeToSystemTime(&ft, &st);
 268
 269     if(local) {
 270         _tzset_init();
 271         use_dst = is_dst(&st);
 272         if((mstm->tm_isdst<=-1 && use_dst) || (mstm->tm_isdst>=1)) {
 273             SYSTEMTIME tmp;
 274
 275             ret += (__time64_t)MSVCRT__dstbias*TICKSPERSEC;
 276
 277             ft.dwLowDateTime = ret & 0xffffffff;
 278             ft.dwHighDateTime = ret >> 32;
 279             FileTimeToSystemTime(&ft, &tmp);
 280
 281             if(!is_dst(&tmp)) {
 282                 st = tmp;
 283                 use_dst = FALSE;
 284             }else {
 285                 use_dst = TRUE;
 286             }
 287         }else if(mstm->tm_isdst==0 && use_dst) {
 288             ret -= (__time64_t)MSVCRT__dstbias*TICKSPERSEC;
 289             ft.dwLowDateTime = ret & 0xffffffff;
 290             ft.dwHighDateTime = ret >> 32;
 291             FileTimeToSystemTime(&ft, &st);
 292             ret += (__time64_t)MSVCRT__dstbias*TICKSPERSEC;
 293         }
 294         ret += (__time64_t)MSVCRT___timezone*TICKSPERSEC;
 295     }
 296
 297     mstm->tm_sec = st.wSecond;
 298     mstm->tm_min = st.wMinute;
 299     mstm->tm_hour = st.wHour;
 300     mstm->tm_mday = st.wDay;
 301     mstm->tm_mon = st.wMonth-1;
 302     mstm->tm_year = st.wYear-1900;
 303     mstm->tm_wday = st.wDayOfWeek;
 304     for(i=mstm->tm_yday=0; i<st.wMonth-1; i++)
 305         mstm->tm_yday += MonthLengths[IsLeapYear(st.wYear)][i];
 306     mstm->tm_yday += st.wDay-1;
 307     mstm->tm_isdst = use_dst ? 1 : 0;
 308
 309     if(ret < TICKS_1601_TO_1970) {
 310         *_errno() = EINVAL;
 311         return -1;
 312     }
 313     ret = (ret-TICKS_1601_TO_1970)/TICKSPERSEC;
 314     return ret;
 315 }
 316
 317 /**********************************************************************
 318  *              _mktime64 (MSVCRT.@)
 319  */
 320 __time64_t CDECL _mktime64(struct tm *mstm)
 321 {
 322     return mktime_helper(mstm, TRUE);
 323 }
 324
 325 /**********************************************************************
 326  *              _mktime32 (MSVCRT.@)
 327  */
 328 __time32_t CDECL _mktime32(struct tm *mstm)
 329 {
 330     __time64_t ret = _mktime64( mstm );
 331     return ret == (__time32_t)ret ? ret : -1;
 332 }
 333
 334 /**********************************************************************
 335  *              _mkgmtime64 (MSVCRT.@)
 336  *
 337  * time->tm_isdst value is ignored
 338  */
 339 __time64_t CDECL _mkgmtime64(struct tm *time)
 340 {
 341     return mktime_helper(time, FALSE);
 342 }
 343
 344 /**********************************************************************
 345  *              _mkgmtime32 (MSVCRT.@)
 346  */
 347 __time32_t CDECL _mkgmtime32(struct tm *time)
 348 {
 349     __time64_t ret = _mkgmtime64(time);
 350     return ret == (__time32_t)ret ? ret : -1;
 351 }
 352
 353 /*********************************************************************
 354  *      _localtime64_s (MSVCRT.@)
 355  */
 356 int CDECL _localtime64_s(struct tm *res, const __time64_t *secs)
 357 {
 358     int i;
 359     FILETIME ft;
 360     SYSTEMTIME st;
 361     ULONGLONG time;
 362
 363     if (!res || !secs || *secs < 0 || *secs > _MAX__TIME64_T)
 364     {
 365         if (res)
 366             write_invalid_msvcrt_tm(res);
 367
 368         *_errno() = EINVAL;
 369         return EINVAL;
 370     }
 371
 372     _tzset_init();
 373     time = (*secs - MSVCRT___timezone) * (ULONGLONG)TICKSPERSEC + TICKS_1601_TO_1970;
 374
 375     ft.dwHighDateTime = (UINT)(time >> 32);
 376     ft.dwLowDateTime  = (UINT)time;
 377     FileTimeToSystemTime(&ft, &st);
 378
 379     res->tm_isdst = is_dst(&st) ? 1 : 0;
 380     if(res->tm_isdst) {
 381         time -= MSVCRT__dstbias * (ULONGLONG)TICKSPERSEC;
 382         ft.dwHighDateTime = (UINT)(time >> 32);
 383         ft.dwLowDateTime  = (UINT)time;
 384         FileTimeToSystemTime(&ft, &st);
 385     }
 386
 387     res->tm_sec  = st.wSecond;
 388     res->tm_min  = st.wMinute;
 389     res->tm_hour = st.wHour;
 390     res->tm_mday = st.wDay;
 391     res->tm_year = st.wYear - 1900;
 392     res->tm_mon  = st.wMonth - 1;
 393     res->tm_wday = st.wDayOfWeek;
 394     for (i = res->tm_yday = 0; i < st.wMonth - 1; i++)
 395         res->tm_yday += MonthLengths[IsLeapYear(st.wYear)][i];
 396     res->tm_yday += st.wDay - 1;
 397
 398     return 0;
 399 }
 400
 401 /*********************************************************************
 402  *      _localtime64 (MSVCRT.@)
 403  */
 404 struct tm* CDECL _localtime64(const __time64_t* secs)
 405 {
 406     thread_data_t *data = msvcrt_get_thread_data();
 407
 408     if(!data->time_buffer)
 409         data->time_buffer = malloc(sizeof(struct tm));
 410
 411     if(_localtime64_s(data->time_buffer, secs))
 412         return NULL;
 413     return data->time_buffer;
 414 }
 415
 416 /*********************************************************************
 417  *      _localtime32 (MSVCRT.@)
 418  */
 419 struct tm* CDECL _localtime32(const __time32_t* secs)
 420 {
 421     __time64_t secs64;
 422
 423     if(!secs)
 424         return NULL;
 425
 426     secs64 = *secs;
 427     return _localtime64( &secs64 );
 428 }
 429
 430 /*********************************************************************
 431  *      _localtime32_s (MSVCRT.@)
 432  */
 433 int CDECL _localtime32_s(struct tm *time, const __time32_t *secs)
 434 {
 435     __time64_t secs64;
 436
 437     if (!time || !secs || *secs < 0)
 438     {
 439         if (time)
 440             write_invalid_msvcrt_tm(time);
 441
 442         *_errno() = EINVAL;
 443         return EINVAL;
 444     }
 445
 446     secs64 = *secs;
 447     return _localtime64_s(time, &secs64);
 448 }
 449
 450 /*********************************************************************
 451  *      _gmtime64 (MSVCRT.@)
 452  */
 453 int CDECL _gmtime64_s(struct tm *res, const __time64_t *secs)
 454 {
 455     int i;
 456     FILETIME ft;
 457     SYSTEMTIME st;
 458     ULONGLONG time;
 459
 460     if (!res || !secs || *secs < 0 || *secs > _MAX__TIME64_T) {
 461         if (res) {
 462             write_invalid_msvcrt_tm(res);
 463         }
 464
 465         *_errno() = EINVAL;
 466         return EINVAL;
 467     }
 468
 469     time = *secs * (ULONGLONG)TICKSPERSEC + TICKS_1601_TO_1970;
 470
 471     ft.dwHighDateTime = (UINT)(time >> 32);
 472     ft.dwLowDateTime  = (UINT)time;
 473
 474     FileTimeToSystemTime(&ft, &st);
 475
 476     res->tm_sec  = st.wSecond;
 477     res->tm_min  = st.wMinute;
 478     res->tm_hour = st.wHour;
 479     res->tm_mday = st.wDay;
 480     res->tm_year = st.wYear - 1900;
 481     res->tm_mon  = st.wMonth - 1;
 482     res->tm_wday = st.wDayOfWeek;
 483     for (i = res->tm_yday = 0; i < st.wMonth - 1; i++) {
 484         res->tm_yday += MonthLengths[IsLeapYear(st.wYear)][i];
 485     }
 486
 487     res->tm_yday += st.wDay - 1;
 488     res->tm_isdst = 0;
 489
 490     return 0;
 491 }
 492
 493 /*********************************************************************
 494  *      _gmtime64 (MSVCRT.@)
 495  */
 496 struct tm* CDECL _gmtime64(const __time64_t *secs)
 497 {
 498     thread_data_t * const data = msvcrt_get_thread_data();
 499
 500     if(!data->time_buffer)
 501         data->time_buffer = malloc(sizeof(struct tm));
 502
 503     if(_gmtime64_s(data->time_buffer, secs))
 504         return NULL;
 505     return data->time_buffer;
 506 }
 507
 508 /*********************************************************************
 509  *      _gmtime32_s (MSVCRT.@)
 510  */
 511 int CDECL _gmtime32_s(struct tm *res, const __time32_t *secs)
 512 {
 513     __time64_t secs64;
 514
 515     if(secs) {
 516         secs64 = *secs;
 517         return _gmtime64_s(res, &secs64);
 518     }
 519     return _gmtime64_s(res, NULL);
 520 }
 521
 522 /*********************************************************************
 523  *      _gmtime32 (MSVCRT.@)
 524  */
 525 struct tm* CDECL _gmtime32(const __time32_t* secs)
 526 {
 527     __time64_t secs64;
 528
 529     if(!secs)
 530         return NULL;
 531
 532     secs64 = *secs;
 533     return _gmtime64( &secs64 );
 534 }
 535
 536 /**********************************************************************
 537  *              _strdate (MSVCRT.@)
 538  */
 539 char* CDECL _strdate(char* date)
 540 {
 541     SYSTEMTIME st;
 542
 543     GetLocalTime(&st);
 544     date[0] = '0' + st.wMonth / 10;
 545     date[1] = '0' + st.wMonth % 10;
 546     date[2] = '/';
 547     date[3] = '0' + st.wDay / 10;
 548     date[4] = '0' + st.wDay % 10;
 549     date[5] = '/';
 550     date[6] = '0' + st.wYear / 10 % 10;
 551     date[7] = '0' + st.wYear % 10;
 552     date[8] = 0;
 553     return date;
 554 }
 555
 556 /**********************************************************************
 557  *              _strdate_s (MSVCRT.@)
 558  */
 559 int CDECL _strdate_s(char* date, size_t size)
 560 {
 561     if(date && size)
 562         date[0] = '\0';
 563
 564     if(!date) {
 565         *_errno() = EINVAL;
 566         return EINVAL;
 567     }
 568
 569     if(size < 9) {
 570         *_errno() = ERANGE;
 571         return ERANGE;
 572     }
 573
 574     _strdate(date);
 575     return 0;
 576 }
 577
 578 /**********************************************************************
 579  *              _wstrdate (MSVCRT.@)
 580  */
 581 wchar_t* CDECL _wstrdate(wchar_t* date)
 582 {
 583     GetDateFormatW(LOCALE_NEUTRAL, 0, NULL, L"MM'/'dd'/'yy", date, 9);
 584     return date;
 585 }
 586
 587 /**********************************************************************
 588  *              _wstrdate_s (MSVCRT.@)
 589  */
 590 int CDECL _wstrdate_s(wchar_t* date, size_t size)
 591 {
 592     if(date && size)
 593         date[0] = '\0';
 594
 595     if(!date) {
 596         *_errno() = EINVAL;
 597         return EINVAL;
 598     }
 599
 600     if(size < 9) {
 601         *_errno() = ERANGE;
 602         return ERANGE;
 603     }
 604
 605     _wstrdate(date);
 606     return 0;
 607 }
 608
 609 /*********************************************************************
 610  *              _strtime (MSVCRT.@)
 611  */
 612 char* CDECL _strtime(char* time)
 613 {
 614     SYSTEMTIME st;
 615
 616     GetLocalTime(&st);
 617     time[0] = '0' + st.wHour / 10;
 618     time[1] = '0' + st.wHour % 10;
 619     time[2] = ':';
 620     time[3] = '0' + st.wMinute / 10;
 621     time[4] = '0' + st.wMinute % 10;
 622     time[5] = ':';
 623     time[6] = '0' + st.wSecond / 10;
 624     time[7] = '0' + st.wSecond % 10;
 625     time[8] = 0;
 626     return time;
 627 }
 628
 629 /*********************************************************************
 630  *              _strtime_s (MSVCRT.@)
 631  */
 632 int CDECL _strtime_s(char* time, size_t size)
 633 {
 634     if(time && size)
 635         time[0] = '\0';
 636
 637     if(!time) {
 638         *_errno() = EINVAL;
 639         return EINVAL;
 640     }
 641
 642     if(size < 9) {
 643         *_errno() = ERANGE;
 644         return ERANGE;
 645     }
 646
 647     _strtime(time);
 648     return 0;
 649 }
 650
 651 /*********************************************************************
 652  *              _wstrtime (MSVCRT.@)
 653  */
 654 wchar_t* CDECL _wstrtime(wchar_t* time)
 655 {
 656     GetTimeFormatW(LOCALE_NEUTRAL, 0, NULL, L"HH':'mm':'ss", time, 9);
 657     return time;
 658 }
 659
 660 /*********************************************************************
 661  *              _wstrtime_s (MSVCRT.@)
 662  */
 663 int CDECL _wstrtime_s(wchar_t* time, size_t size)
 664 {
 665     if(time && size)
 666         time[0] = '\0';
 667
 668     if(!time) {
 669         *_errno() = EINVAL;
 670         return EINVAL;
 671     }
 672
 673     if(size < 9) {
 674         *_errno() = ERANGE;
 675         return ERANGE;
 676     }
 677
 678     _wstrtime(time);
 679     return 0;
 680 }
 681
 682 /*********************************************************************
 683  *              clock (MSVCRT.@)
 684  */
 685 clock_t CDECL clock(void)
 686 {
 687     LARGE_INTEGER systime;
 688
 689     NtQuerySystemTime(&systime);
 690     return (systime.QuadPart - init_time) / (TICKSPERSEC / CLOCKS_PER_SEC);
 691 }
 692
 693 /*********************************************************************
 694  *              _difftime64 (MSVCRT.@)
 695  */
 696 double CDECL _difftime64(__time64_t time1, __time64_t time2)
 697 {
 698   return (double)(time1 - time2);
 699 }
 700
 701 /*********************************************************************
 702  *              _difftime32 (MSVCRT.@)
 703  */
 704 double CDECL _difftime32(__time32_t time1, __time32_t time2)
 705 {
 706   return (double)(time1 - time2);
 707 }
 708
 709 /*********************************************************************
 710  *              _ftime64 (MSVCRT.@)
 711  */
 712 void CDECL _ftime64(struct __timeb64 *buf)
 713 {
 714   TIME_ZONE_INFORMATION tzinfo;
 715   FILETIME ft;
 716   ULONGLONG time;
 717
 718   _tzset_init();
 719
 720   GetSystemTimeAsFileTime(&ft);
 721
 722   time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
 723
 724   buf->time = time / TICKSPERSEC - SECS_1601_TO_1970;
 725   buf->millitm = (time % TICKSPERSEC) / TICKSPERMSEC;
 726   buf->timezone = MSVCRT___timezone / 60;
 727   buf->dstflag = GetTimeZoneInformation( &tzinfo) == TIME_ZONE_ID_DAYLIGHT;
 728 }
 729
 730 /*********************************************************************
 731  *              _ftime64_s (MSVCRT.@)
 732  */
 733 int CDECL _ftime64_s(struct __timeb64 *buf)
 734 {
 735     if (!MSVCRT_CHECK_PMT( buf != NULL )) return EINVAL;
 736     _ftime64(buf);
 737     return 0;
 738 }
 739
 740 /*********************************************************************
 741  *              _ftime32 (MSVCRT.@)
 742  */
 743 void CDECL _ftime32(struct __timeb32 *buf)
 744 {
 745     struct __timeb64 buf64;
 746
 747     _ftime64( &buf64 );
 748     buf->time     = buf64.time;
 749     buf->millitm  = buf64.millitm;
 750     buf->timezone = buf64.timezone;
 751     buf->dstflag  = buf64.dstflag;
 752 }
 753
 754 /*********************************************************************
 755  *              _ftime32_s (MSVCRT.@)
 756  */
 757 int CDECL _ftime32_s(struct __timeb32 *buf)
 758 {
 759     if (!MSVCRT_CHECK_PMT( buf != NULL )) return EINVAL;
 760     _ftime32(buf);
 761     return 0;
 762 }
 763
 764 /*********************************************************************
 765  *              _time64 (MSVCRT.@)
 766  */
 767 __time64_t CDECL _time64(__time64_t *buf)
 768 {
 769     __time64_t curtime;
 770     struct __timeb64 tb;
 771
 772     _ftime64(&tb);
 773
 774     curtime = tb.time;
 775     return buf ? *buf = curtime : curtime;
 776 }
 777
 778 /*********************************************************************
 779  *              _time32 (MSVCRT.@)
 780  */
 781 __time32_t CDECL _time32(__time32_t *buf)
 782 {
 783     __time32_t curtime;
 784     struct __timeb64 tb;
 785
 786     _ftime64(&tb);
 787
 788     curtime = tb.time;
 789     return buf ? *buf = curtime : curtime;
 790 }
 791
 792 /*********************************************************************
 793  *              __p__daylight (MSVCRT.@)
 794  */
 795 int * CDECL __p__daylight(void)
 796 {
 797         return &MSVCRT___daylight;
 798 }
 799
 800 /*********************************************************************
 801  *              __p__dstbias (MSVCRT.@)
 802  */
 803 __msvcrt_long * CDECL __p__dstbias(void)
 804 {
 805     return &MSVCRT__dstbias;
 806 }
 807
 808 #if _MSVCR_VER >= 80
 809 /*********************************************************************
 810  *              _get_dstbias (MSVCR80.@)
 811  */
 812 int CDECL  _get_dstbias(int *seconds)
 813 {
 814     if (!MSVCRT_CHECK_PMT(seconds != NULL)) return EINVAL;
 815     *seconds = MSVCRT__dstbias;
 816     return 0;
 817 }
 818 #endif
 819
 820 /*********************************************************************
 821  *              __p__timezone (MSVCRT.@)
 822  */
 823 __msvcrt_long * CDECL __p__timezone(void)
 824 {
 825         return &MSVCRT___timezone;
 826 }
 827
 828 /*********************************************************************
 829  *              _get_tzname (MSVCRT.@)
 830  */
 831 int CDECL _get_tzname(size_t *ret, char *buf, size_t bufsize, int index)
 832 {
 833     char *timezone;
 834
 835     switch(index)
 836     {
 837     case 0:
 838         timezone = tzname_std;
 839         break;
 840     case 1:
 841         timezone = tzname_dst;
 842         break;
 843     default:
 844         *_errno() = EINVAL;
 845         return EINVAL;
 846     }
 847
 848     if(!ret || (!buf && bufsize > 0) || (buf && !bufsize))
 849     {
 850         *_errno() = EINVAL;
 851         return EINVAL;
 852     }
 853
 854     *ret = strlen(timezone)+1;
 855     if(!buf && !bufsize)
 856         return 0;
 857     if(*ret > bufsize)
 858     {
 859         buf[0] = 0;
 860         return ERANGE;
 861     }
 862
 863     strcpy(buf, timezone);
 864     return 0;
 865 }
 866
 867 /*********************************************************************
 868  *              __p_tzname (MSVCRT.@)
 869  */
 870 char ** CDECL __p__tzname(void)
 871 {
 872         return MSVCRT__tzname;
 873 }
 874
 875 #if _MSVCR_VER <= 90
 876 #define STRFTIME_CHAR char
 877 #define STRFTIME_TD(td, name) td->str.names.name
 878 #else
 879 #define STRFTIME_CHAR wchar_t
 880 #define STRFTIME_TD(td, name) td->wstr.names.name
 881 #endif
 882
 883 #define strftime_str(a,b,c,d) strftime_nstr(a,b,c,d,SIZE_MAX)
 884 static inline BOOL strftime_nstr(STRFTIME_CHAR *str, size_t *pos,
 885         size_t max, const STRFTIME_CHAR *src, size_t len)
 886 {
 887     while(*src && len)
 888     {
 889         if(*pos >= max) {
 890             *str = 0;
 891             *_errno() = ERANGE;
 892             return FALSE;
 893         }
 894
 895         str[*pos] = *src;
 896         src++;
 897         *pos += 1;
 898         len--;
 899     }
 900     return TRUE;
 901 }
 902
 903 static inline BOOL strftime_int(STRFTIME_CHAR *str, size_t *pos, size_t max,
 904         int src, int prec, int l, int h)
 905 {
 906     size_t len;
 907
 908     if(!MSVCRT_CHECK_PMT(src>=l && src<=h)) {
 909         *str = 0;
 910         return FALSE;
 911     }
 912
 913 #if _MSVCR_VER <= 90
 914     len = _snprintf(str+*pos, max-*pos, "%0*d", prec, src);
 915 #else
 916     len = _snwprintf(str+*pos, max-*pos, L"%0*d", prec, src);
 917 #endif
 918     if(len == -1) {
 919         *str = 0;
 920         *_errno() = ERANGE;
 921         return FALSE;
 922     }
 923
 924     *pos += len;
 925     return TRUE;
 926 }
 927
 928 static inline BOOL strftime_format(STRFTIME_CHAR *str, size_t *pos, size_t max,
 929         const struct tm *mstm, __lc_time_data *time_data, const STRFTIME_CHAR *format)
 930 {
 931     size_t count;
 932     BOOL ret = TRUE;
 933
 934     while(*format && ret)
 935     {
 936         count = 1;
 937         while(format[0] == format[count]) count++;
 938
 939         switch(*format) {
 940         case '\'':
 941             if(count % 2 == 0) break;
 942
 943             format += count;
 944             count = 0;
 945             while(format[count] && format[count] != '\'') count++;
 946
 947             ret = strftime_nstr(str, pos, max, format, count);
 948             if(!ret) return FALSE;
 949             if(format[count] == '\'') count++;
 950             break;
 951         case 'd':
 952             if(count > 2)
 953             {
 954                 if(!MSVCRT_CHECK_PMT(mstm->tm_wday>=0 && mstm->tm_wday<=6))
 955                 {
 956                     *str = 0;
 957                     return FALSE;
 958                 }
 959             }
 960             switch(count) {
 961             case 1:
 962             case 2:
 963                 ret = strftime_int(str, pos, max, mstm->tm_mday, count==1 ? 0 : 2, 1, 31);
 964                 break;
 965             case 3:
 966                 ret = strftime_str(str, pos, max, STRFTIME_TD(time_data, short_wday)[mstm->tm_wday]);
 967                 break;
 968             default:
 969                 ret = strftime_nstr(str, pos, max, format, count-4);
 970                 if(ret)
 971                     ret = strftime_str(str, pos, max, STRFTIME_TD(time_data, wday)[mstm->tm_wday]);
 972                 break;
 973             }
 974             break;
 975         case 'M':
 976             if(count > 2)
 977             {
 978                 if(!MSVCRT_CHECK_PMT(mstm->tm_mon>=0 && mstm->tm_mon<=11))
 979                 {
 980                     *str = 0;
 981                     return FALSE;
 982                 }
 983             }
 984             switch(count) {
 985             case 1:
 986             case 2:
 987                 ret = strftime_int(str, pos, max, mstm->tm_mon+1, count==1 ? 0 : 2, 1, 12);
 988                 break;
 989             case 3:
 990                 ret = strftime_str(str, pos, max, STRFTIME_TD(time_data, short_mon)[mstm->tm_mon]);
 991                 break;
 992             default:
 993                 ret = strftime_nstr(str, pos, max, format, count-4);
 994                 if(ret)
 995                     ret = strftime_str(str, pos, max, STRFTIME_TD(time_data, mon)[mstm->tm_mon]);
 996                 break;
 997             }
 998             break;
 999         case 'y':
1000             if(count > 1)
1001             {
1002 #if _MSVCR_VER>=140
1003                 if(!MSVCRT_CHECK_PMT(mstm->tm_year >= -1900 && mstm->tm_year <= 8099))
1004 #else
1005                 if(!MSVCRT_CHECK_PMT(mstm->tm_year >= 0))
1006 #endif
1007                 {
1008                     *str = 0;
1009                     return FALSE;
1010                 }
1011             }
1012
1013             switch(count) {
1014             case 1:
1015                 ret = strftime_nstr(str, pos, max, format, 1);
1016                 break;
1017             case 2:
1018             case 3:
1019                 ret = strftime_nstr(str, pos, max, format, count-2);
1020                 if(ret)
1021                     ret = strftime_int(str, pos, max, (mstm->tm_year+1900)%100, 2, 0, 99);
1022                 break;
1023             default:
1024                 ret = strftime_nstr(str, pos, max, format, count-4);
1025                 if(ret)
1026                     ret = strftime_int(str, pos, max, mstm->tm_year+1900, 4, 0, 9999);
1027                 break;
1028             }
1029             break;
1030         case 'h':
1031             if(!MSVCRT_CHECK_PMT(mstm->tm_hour>=0 && mstm->tm_hour<=23))
1032             {
1033                 *str = 0;
1034                 return FALSE;
1035             }
1036             if(count > 2)
1037                 ret = strftime_nstr(str, pos, max, format, count-2);
1038             if(ret)
1039                 ret = strftime_int(str, pos, max, (mstm->tm_hour + 11) % 12 + 1,
1040                         count == 1 ? 0 : 2, 1, 12);
1041             break;
1042         case 'H':
1043             if(count > 2)
1044                 ret = strftime_nstr(str, pos, max, format, count-2);
1045             if(ret)
1046                 ret = strftime_int(str, pos, max, mstm->tm_hour, count == 1 ? 0 : 2, 0, 23);
1047             break;
1048         case 'm':
1049             if(count > 2)
1050                 ret = strftime_nstr(str, pos, max, format, count-2);
1051             if(ret)
1052                 ret = strftime_int(str, pos, max, mstm->tm_min, count == 1 ? 0 : 2, 0, 59);
1053             break;
1054         case 's':
1055             if(count > 2)
1056                 ret = strftime_nstr(str, pos, max, format, count-2);
1057             if(ret)
1058                 ret = strftime_int(str, pos, max, mstm->tm_sec, count == 1 ? 0 : 2, 0, MAX_SECONDS);
1059             break;
1060         case 'a':
1061         case 'A':
1062         case 't':
1063             if(!MSVCRT_CHECK_PMT(mstm->tm_hour>=0 && mstm->tm_hour<=23))
1064             {
1065                 *str = 0;
1066                 return FALSE;
1067             }
1068             ret = strftime_nstr(str, pos, max,
1069                     mstm->tm_hour < 12 ? STRFTIME_TD(time_data, am) : STRFTIME_TD(time_data, pm),
1070                     (*format == 't' && count == 1) ? 1 : SIZE_MAX);
1071             break;
1072         default:
1073             ret = strftime_nstr(str, pos, max, format, count);
1074             break;
1075         }
1076         format += count;
1077     }
1078
1079     return ret;
1080 }
1081
1082 #if _MSVCR_VER>=140
1083 static inline BOOL strftime_tzdiff(STRFTIME_CHAR *str, size_t *pos, size_t max, BOOL is_dst)
1084 {
1085     __msvcrt_long tz = MSVCRT___timezone + (is_dst ? MSVCRT__dstbias : 0);
1086     char sign;
1087
1088     if(tz < 0) {
1089         sign = '+';
1090         tz = -tz;
1091     }else {
1092         sign = '-';
1093     }
1094
1095     if(*pos < max)
1096         str[(*pos)++] = sign;
1097     if(!strftime_int(str, pos, max, tz/60/60, 2, 0, 99))
1098         return FALSE;
1099     return strftime_int(str, pos, max, tz/60%60, 2, 0, 59);
1100 }
1101 #endif
1102
1103 static size_t strftime_impl(STRFTIME_CHAR *str, size_t max,
1104         const STRFTIME_CHAR *format, const struct tm *mstm,
1105         __lc_time_data *time_data, _locale_t loc)
1106 {
1107     size_t ret, tmp;
1108     BOOL alternate;
1109     int year = mstm ? mstm->tm_year + 1900 : -1;
1110
1111     if(!str || !format) {
1112         if(str && max)
1113             *str = 0;
1114         *_errno() = EINVAL;
1115         return 0;
1116     }
1117
1118     if(!time_data)
1119         time_data = loc ? loc->locinfo->lc_time_curr : get_locinfo()->lc_time_curr;
1120
1121     for(ret=0; *format && ret<max; format++) {
1122         if(*format != '%') {
1123             if(_isleadbyte_l((unsigned char)*format, loc)) {
1124                 str[ret++] = *(format++);
1125                 if(ret == max) continue;
1126                 if(!MSVCRT_CHECK_PMT(str[ret]))
1127                     goto einval_error;
1128             }
1129             str[ret++] = *format;
1130             continue;
1131         }
1132
1133         format++;
1134         if(*format == '#') {
1135             alternate = TRUE;
1136             format++;
1137         }else {
1138             alternate = FALSE;
1139         }
1140
1141         if(!MSVCRT_CHECK_PMT(mstm))
1142             goto einval_error;
1143
1144         switch(*format) {
1145         case 'c':
1146 #if _MSVCR_VER>=140
1147             if(time_data == &cloc_time_data && !alternate)
1148             {
1149                 tmp = strftime_impl(str+ret, max-ret, L"%a %b %e %T %Y", mstm, time_data, loc);
1150                 if(!tmp)
1151                     return 0;
1152                 ret += tmp;
1153                 break;
1154             }
1155 #endif
1156             if(!strftime_format(str, &ret, max, mstm, time_data,
1157                     alternate ? STRFTIME_TD(time_data, date) : STRFTIME_TD(time_data, short_date)))
1158                 return 0;
1159             if(ret < max)
1160                 str[ret++] = ' ';
1161             if(!strftime_format(str, &ret, max, mstm, time_data, STRFTIME_TD(time_data, time)))
1162                 return 0;
1163             break;
1164         case 'x':
1165             if(!strftime_format(str, &ret, max, mstm, time_data,
1166                     alternate ? STRFTIME_TD(time_data, date) : STRFTIME_TD(time_data, short_date)))
1167                 return 0;
1168             break;
1169         case 'X':
1170             if(!strftime_format(str, &ret, max, mstm, time_data, STRFTIME_TD(time_data, time)))
1171                 return 0;
1172             break;
1173         case 'a':
1174             if(!MSVCRT_CHECK_PMT(mstm->tm_wday>=0 && mstm->tm_wday<=6))
1175                 goto einval_error;
1176             if(!strftime_str(str, &ret, max, STRFTIME_TD(time_data, short_wday)[mstm->tm_wday]))
1177                 return 0;
1178             break;
1179         case 'A':
1180             if(!MSVCRT_CHECK_PMT(mstm->tm_wday>=0 && mstm->tm_wday<=6))
1181                 goto einval_error;
1182             if(!strftime_str(str, &ret, max, STRFTIME_TD(time_data, wday)[mstm->tm_wday]))
1183                 return 0;
1184             break;
1185         case 'b':
1186 #if _MSVCR_VER>=140
1187         case 'h':
1188 #endif
1189             if(!MSVCRT_CHECK_PMT(mstm->tm_mon>=0 && mstm->tm_mon<=11))
1190                 goto einval_error;
1191             if(!strftime_str(str, &ret, max, STRFTIME_TD(time_data, short_mon)[mstm->tm_mon]))
1192                 return 0;
1193             break;
1194         case 'B':
1195             if(!MSVCRT_CHECK_PMT(mstm->tm_mon>=0 && mstm->tm_mon<=11))
1196                 goto einval_error;
1197             if(!strftime_str(str, &ret, max, STRFTIME_TD(time_data, mon)[mstm->tm_mon]))
1198                 return 0;
1199             break;
1200 #if _MSVCR_VER>=140
1201         case 'C':
1202             if(!MSVCRT_CHECK_PMT(year>=0 && year<=9999))
1203                 goto einval_error;
1204             if(!strftime_int(str, &ret, max, year/100, alternate ? 0 : 2, 0, 99))
1205                 return 0;
1206             break;
1207 #endif
1208         case 'd':
1209             if(!strftime_int(str, &ret, max, mstm->tm_mday, alternate ? 0 : 2, 1, 31))
1210                 return 0;
1211             break;
1212 #if _MSVCR_VER>=140
1213         case 'D':
1214             if(!MSVCRT_CHECK_PMT(year>=0 && year<=9999))
1215                 goto einval_error;
1216             if(!strftime_int(str, &ret, max, mstm->tm_mon+1, alternate ? 0 : 2, 1, 12))
1217                 return 0;
1218             if(ret < max)
1219                 str[ret++] = '/';
1220             if(!strftime_int(str, &ret, max, mstm->tm_mday, alternate ? 0 : 2, 1, 31))
1221                 return 0;
1222             if(ret < max)
1223                 str[ret++] = '/';
1224             if(!strftime_int(str, &ret, max, year%100, alternate ? 0 : 2, 0, 99))
1225                 return 0;
1226             break;
1227         case 'e':
1228             if(!strftime_int(str, &ret, max, mstm->tm_mday, alternate ? 0 : 2, 1, 31))
1229                 return 0;
1230             if(!alternate && str[ret-2] == '0')
1231                 str[ret-2] = ' ';
1232             break;
1233         case 'F':
1234             if(!strftime_int(str, &ret, max, year, alternate ? 0 : 4, 0, 9999))
1235                 return 0;
1236             if(ret < max)
1237                 str[ret++] = '-';
1238             if(!strftime_int(str, &ret, max, mstm->tm_mon+1, alternate ? 0 : 2, 1, 12))
1239                 return 0;
1240             if(ret < max)
1241                 str[ret++] = '-';
1242             if(!strftime_int(str, &ret, max, mstm->tm_mday, alternate ? 0 : 2, 1, 31))
1243                 return 0;
1244             break;
1245         case 'g':
1246         case 'G':
1247             if(!MSVCRT_CHECK_PMT(year>=0 && year<=9999))
1248                 goto einval_error;
1249             /* fall through */
1250         case 'V':
1251         {
1252             int iso_year = year;
1253             int iso_days = mstm->tm_yday - (mstm->tm_wday ? mstm->tm_wday : 7) + 4;
1254             if (iso_days < 0)
1255                 iso_days += 365 + IsLeapYear(--iso_year);
1256             else if(iso_days >= 365 + IsLeapYear(iso_year))
1257                 iso_days -= 365 + IsLeapYear(iso_year++);
1258
1259             if(*format == 'G') {
1260                 if(!strftime_int(str, &ret, max, iso_year, 4, 0, 9999))
1261                     return 0;
1262             } else if(*format == 'g') {
1263                 if(!strftime_int(str, &ret, max, iso_year%100, 2, 0, 99))
1264                     return 0;
1265             } else {
1266                 if(!strftime_int(str, &ret, max, iso_days/7 + 1, alternate ? 0 : 2, 0, 53))
1267                     return 0;
1268             }
1269             break;
1270         }
1271 #endif
1272         case 'H':
1273             if(!strftime_int(str, &ret, max, mstm->tm_hour, alternate ? 0 : 2, 0, 23))
1274                 return 0;
1275             break;
1276         case 'I':
1277             if(!MSVCRT_CHECK_PMT(mstm->tm_hour>=0 && mstm->tm_hour<=23))
1278                 goto einval_error;
1279             if(!strftime_int(str, &ret, max, (mstm->tm_hour + 11) % 12 + 1,
1280                         alternate ? 0 : 2, 1, 12))
1281                 return 0;
1282             break;
1283         case 'j':
1284             if(!strftime_int(str, &ret, max, mstm->tm_yday+1, alternate ? 0 : 3, 1, 366))
1285                 return 0;
1286             break;
1287         case 'm':
1288             if(!strftime_int(str, &ret, max, mstm->tm_mon+1, alternate ? 0 : 2, 1, 12))
1289                 return 0;
1290             break;
1291         case 'M':
1292             if(!strftime_int(str, &ret, max, mstm->tm_min, alternate ? 0 : 2, 0, 59))
1293                 return 0;
1294             break;
1295 #if _MSVCR_VER>=140
1296         case 'n':
1297             str[ret++] = '\n';
1298             break;
1299 #endif
1300         case 'p':
1301             if(!MSVCRT_CHECK_PMT(mstm->tm_hour>=0 && mstm->tm_hour<=23))
1302                 goto einval_error;
1303             if(!strftime_str(str, &ret, max, mstm->tm_hour<12 ?
1304                         STRFTIME_TD(time_data, am) : STRFTIME_TD(time_data, pm)))
1305                 return 0;
1306             break;
1307 #if _MSVCR_VER>=140
1308         case 'r':
1309             if(time_data == &cloc_time_data)
1310             {
1311                 if(!MSVCRT_CHECK_PMT(mstm->tm_hour>=0 && mstm->tm_hour<=23))
1312                     goto einval_error;
1313                 if(!strftime_int(str, &ret, max, (mstm->tm_hour + 11) % 12 + 1,
1314                             alternate ? 0 : 2, 1, 12))
1315                     return 0;
1316                 if(ret < max)
1317                     str[ret++] = ':';
1318                 if(!strftime_int(str, &ret, max, mstm->tm_min, alternate ? 0 : 2, 0, 59))
1319                     return 0;
1320                 if(ret < max)
1321                     str[ret++] = ':';
1322                 if(!strftime_int(str, &ret, max, mstm->tm_sec, alternate ? 0 : 2, 0, MAX_SECONDS))
1323                     return 0;
1324                 if(ret < max)
1325                     str[ret++] = ' ';
1326                 if(!strftime_str(str, &ret, max, mstm->tm_hour<12 ?
1327                             STRFTIME_TD(time_data, am) : STRFTIME_TD(time_data, pm)))
1328                     return 0;
1329             }
1330             else
1331             {
1332                 if(!strftime_format(str, &ret, max, mstm, time_data, STRFTIME_TD(time_data, time)))
1333                     return 0;
1334             }
1335             break;
1336         case 'R':
1337             if(!strftime_int(str, &ret, max, mstm->tm_hour, alternate ? 0 : 2, 0, 23))
1338                 return 0;
1339             if(ret < max)
1340                 str[ret++] = ':';
1341             if(!strftime_int(str, &ret, max, mstm->tm_min, alternate ? 0 : 2, 0, 59))
1342                 return 0;
1343             break;
1344 #endif
1345         case 'S':
1346             if(!strftime_int(str, &ret, max, mstm->tm_sec, alternate ? 0 : 2, 0, MAX_SECONDS))
1347                 return 0;
1348             break;
1349 #if _MSVCR_VER>=140
1350         case 't':
1351             str[ret++] = '\t';
1352             break;
1353         case 'T':
1354             if(!strftime_int(str, &ret, max, mstm->tm_hour, alternate ? 0 : 2, 0, 23))
1355                 return 0;
1356             if(ret < max)
1357                 str[ret++] = ':';
1358             if(!strftime_int(str, &ret, max, mstm->tm_min, alternate ? 0 : 2, 0, 59))
1359                 return 0;
1360             if(ret < max)
1361                 str[ret++] = ':';
1362             if(!strftime_int(str, &ret, max, mstm->tm_sec, alternate ? 0 : 2, 0, MAX_SECONDS))
1363                 return 0;
1364             break;
1365         case 'u':
1366             if(!MSVCRT_CHECK_PMT(mstm->tm_wday>=0 && mstm->tm_wday<=6))
1367                 goto einval_error;
1368             tmp = mstm->tm_wday ? mstm->tm_wday : 7;
1369             if(!strftime_int(str, &ret, max, tmp, 0, 1, 7))
1370                 return 0;
1371             break;
1372 #endif
1373         case 'w':
1374             if(!strftime_int(str, &ret, max, mstm->tm_wday, 0, 0, 6))
1375                 return 0;
1376             break;
1377         case 'y':
1378 #if _MSVCR_VER>=140
1379             if(!MSVCRT_CHECK_PMT(year>=0 && year<=9999))
1380 #else
1381             if(!MSVCRT_CHECK_PMT(year>=1900))
1382 #endif
1383                 goto einval_error;
1384             if(!strftime_int(str, &ret, max, year%100, alternate ? 0 : 2, 0, 99))
1385                 return 0;
1386             break;
1387         case 'Y':
1388             if(!strftime_int(str, &ret, max, year, alternate ? 0 : 4, 0, 9999))
1389                 return 0;
1390             break;
1391         case 'z':
1392 #if _MSVCR_VER>=140
1393             _tzset();
1394             if(!strftime_tzdiff(str, &ret, max, mstm->tm_isdst))
1395                 return 0;
1396             break;
1397 #endif
1398         case 'Z':
1399             _tzset();
1400 #if _MSVCR_VER <= 90
1401             if(_get_tzname(&tmp, str+ret, max-ret, mstm->tm_isdst ? 1 : 0))
1402                 return 0;
1403 #else
1404                 if(_mbstowcs_s_l(&tmp, str+ret, max-ret,
1405                             mstm->tm_isdst ? tzname_dst : tzname_std,
1406                             _TRUNCATE, loc) == STRUNCATE)
1407                     ret = max;
1408 #endif
1409             ret += tmp-1;
1410             break;
1411         case 'U':
1412         case 'W':
1413             if(!MSVCRT_CHECK_PMT(mstm->tm_wday>=0 && mstm->tm_wday<=6))
1414                 goto einval_error;
1415             if(!MSVCRT_CHECK_PMT(mstm->tm_yday>=0 && mstm->tm_yday<=365))
1416                 goto einval_error;
1417             if(*format == 'U')
1418                 tmp = mstm->tm_wday;
1419             else if(!mstm->tm_wday)
1420                 tmp = 6;
1421             else
1422                 tmp = mstm->tm_wday-1;
1423
1424             tmp = mstm->tm_yday/7 + (tmp<=mstm->tm_yday%7);
1425             if(!strftime_int(str, &ret, max, tmp, alternate ? 0 : 2, 0, 53))
1426                 return 0;
1427             break;
1428         case '%':
1429             str[ret++] = '%';
1430             break;
1431         default:
1432             WARN("unknown format %c\n", *format);
1433             MSVCRT_INVALID_PMT("unknown format", EINVAL);
1434             goto einval_error;
1435         }
1436     }
1437
1438     if(ret == max) {
1439         if(max)
1440             *str = 0;
1441         *_errno() = ERANGE;
1442         return 0;
1443     }
1444
1445     str[ret] = 0;
1446     return ret;
1447
1448 einval_error:
1449     *str = 0;
1450     return 0;
1451 }
1452
1453 static size_t strftime_helper(char *str, size_t max, const char *format,
1454         const struct tm *mstm, __lc_time_data *time_data, _locale_t loc)
1455 {
1456 #if _MSVCR_VER <= 90
1457     TRACE("(%p %Iu %s %p %p %p)\n", str, max, format, mstm, time_data, loc);
1458     return strftime_impl(str, max, format, mstm, time_data, loc);
1459 #else
1460     wchar_t *s, *fmt;
1461     size_t len;
1462     int cp;
1463
1464     TRACE("(%p %Iu %s %p %p %p)\n", str, max, format, mstm, time_data, loc);
1465
1466     if (!MSVCRT_CHECK_PMT(str != NULL)) return 0;
1467     if (!MSVCRT_CHECK_PMT(max != 0)) return 0;
1468     *str = 0;
1469     if (!MSVCRT_CHECK_PMT(format != NULL)) return 0;
1470
1471     cp = (loc ? loc->locinfo : get_locinfo())->lc_id[LC_TIME].wCodePage;
1472
1473     len = MultiByteToWideChar( cp, 0, format, -1, NULL, 0 );
1474     if (!len)
1475     {
1476         *_errno() = EILSEQ;
1477         return 0;
1478     }
1479     fmt = malloc( len*sizeof(wchar_t) );
1480     if (!fmt) return 0;
1481     MultiByteToWideChar( cp, 0, format, -1, fmt, len );
1482
1483     if ((s = malloc( max*sizeof(wchar_t) )))
1484     {
1485         len = strftime_impl( s, max, fmt, mstm, time_data, loc );
1486         if (len)
1487         {
1488             len = WideCharToMultiByte( cp, 0, s, -1, str, max, NULL, NULL );
1489             if (len) len--;
1490             else *_errno() = EILSEQ;
1491         }
1492         free( s );
1493     }
1494     else len = 0;
1495
1496     free( fmt );
1497     return len;
1498 #endif
1499 }
1500
1501 #if _MSVCR_VER >= 80
1502 /********************************************************************
1503  *     _strftime_l (MSVCR80.@)
1504  */
1505 size_t CDECL _strftime_l( char *str, size_t max, const char *format,
1506         const struct tm *mstm, _locale_t loc )
1507 {
1508     return strftime_helper(str, max, format, mstm, NULL, loc);
1509 }
1510 #endif
1511
1512 /*********************************************************************
1513  *              _Strftime (MSVCRT.@)
1514  */
1515 size_t CDECL _Strftime(char *str, size_t max, const char *format,
1516         const struct tm *mstm, void *time_data)
1517 {
1518     return strftime_helper(str, max, format, mstm, time_data, NULL);
1519 }
1520
1521 /*********************************************************************
1522  *              strftime (MSVCRT.@)
1523  */
1524 size_t CDECL strftime( char *str, size_t max, const char *format,
1525                                      const struct tm *mstm )
1526 {
1527     return strftime_helper(str, max, format, mstm, NULL, NULL);
1528 }
1529
1530 static size_t wcsftime_helper( wchar_t *str, size_t max,
1531         const wchar_t *format, const struct tm *mstm,
1532         __lc_time_data *time_data, _locale_t loc )
1533 {
1534 #if _MSVCR_VER <= 90
1535     char *s, *fmt;
1536     size_t len;
1537
1538     TRACE("%p %Iu %s %p %p %p\n", str, max, debugstr_w(format), mstm, time_data, loc);
1539
1540     len = _wcstombs_l( NULL, format, 0, loc ) + 1;
1541     if (!(fmt = malloc( len ))) return 0;
1542     _wcstombs_l(fmt, format, len, loc);
1543
1544     if ((s = malloc( max*4 )))
1545     {
1546         if (!strftime_impl( s, max*4, fmt, mstm, time_data, loc )) s[0] = 0;
1547         len = _mbstowcs_l( str, s, max, loc );
1548         free( s );
1549     }
1550     else len = 0;
1551
1552     free( fmt );
1553     return len;
1554 #else
1555     TRACE("%p %Iu %s %p %p %p\n", str, max, debugstr_w(format), mstm, time_data, loc);
1556     return strftime_impl(str, max, format, mstm, time_data, loc);
1557 #endif
1558 }
1559
1560 /*********************************************************************
1561  *              _wcsftime_l (MSVCRT.@)
1562  */
1563 size_t CDECL _wcsftime_l( wchar_t *str, size_t max,
1564         const wchar_t *format, const struct tm *mstm, _locale_t loc )
1565 {
1566     return wcsftime_helper(str, max, format, mstm, NULL, loc);
1567 }
1568
1569 /*********************************************************************
1570  *     wcsftime (MSVCRT.@)
1571  */
1572 size_t CDECL wcsftime( wchar_t *str, size_t max,
1573                                      const wchar_t *format, const struct tm *mstm )
1574 {
1575     return wcsftime_helper(str, max, format, mstm, NULL, NULL);
1576 }
1577
1578 #if _MSVCR_VER >= 110
1579 /*********************************************************************
1580  *              _Wcsftime (MSVCR110.@)
1581  */
1582 size_t CDECL _Wcsftime(wchar_t *str, size_t max,
1583         const wchar_t *format, const struct tm *mstm,
1584         __lc_time_data *time_data)
1585 {
1586     return wcsftime_helper(str, max, format, mstm, time_data, NULL);
1587 }
1588 #endif
1589
1590 static char* asctime_buf(char *buf, const struct tm *mstm)
1591 {
1592     static const char wday[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
1593     static const char month[12][4] = {"Jan", "Feb", "Mar", "Apr", "May",
1594         "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
1595
1596     if (!mstm || mstm->tm_sec<0 || mstm->tm_sec>59
1597             || mstm->tm_min<0 || mstm->tm_min>59
1598             || mstm->tm_hour<0 || mstm->tm_hour>23
1599             || mstm->tm_mon<0 || mstm->tm_mon>11
1600             || mstm->tm_wday<0 || mstm->tm_wday>6
1601             || mstm->tm_year<0 || mstm->tm_mday<0
1602             || mstm->tm_mday>MonthLengths[IsLeapYear(1900+mstm->tm_year)][mstm->tm_mon]) {
1603         *_errno() = EINVAL;
1604         return NULL;
1605     }
1606
1607 #if _MSVCR_VER>=140
1608     /* C89 (4.12.3.1) uses space-padding for day of month. */
1609     _snprintf(buf, 26, "%s %s %2d %02d:%02d:%02d %c%03d\n", wday[mstm->tm_wday],
1610             month[mstm->tm_mon], mstm->tm_mday, mstm->tm_hour, mstm->tm_min,
1611             mstm->tm_sec, '1'+(mstm->tm_year+900)/1000, (900+mstm->tm_year)%1000);
1612 #else
1613     _snprintf(buf, 26, "%s %s %02d %02d:%02d:%02d %c%03d\n", wday[mstm->tm_wday],
1614             month[mstm->tm_mon], mstm->tm_mday, mstm->tm_hour, mstm->tm_min,
1615             mstm->tm_sec, '1'+(mstm->tm_year+900)/1000, (900+mstm->tm_year)%1000);
1616 #endif
1617     return buf;
1618 }
1619
1620 /*********************************************************************
1621  *              asctime (MSVCRT.@)
1622  */
1623 char * CDECL asctime(const struct tm *mstm)
1624 {
1625     thread_data_t *data = msvcrt_get_thread_data();
1626
1627     /* asctime returns date in format that always has exactly 26 characters */
1628     if (!data->asctime_buffer) {
1629         data->asctime_buffer = malloc(26);
1630         if (!data->asctime_buffer) {
1631             *_errno() = ENOMEM;
1632             return NULL;
1633         }
1634     }
1635
1636     return asctime_buf(data->asctime_buffer, mstm);
1637 }
1638
1639 /*********************************************************************
1640  *      asctime_s (MSVCRT.@)
1641  */
1642 int CDECL asctime_s(char* time, size_t size, const struct tm *mstm)
1643 {
1644     if (!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
1645     if (size) time[0] = 0;
1646     if (!MSVCRT_CHECK_PMT(size >= 26)) return EINVAL;
1647     if (!MSVCRT_CHECK_PMT(mstm != NULL)) return EINVAL;
1648     if (!MSVCRT_CHECK_PMT(mstm->tm_sec >= 0 && mstm->tm_sec < 60)) return EINVAL;
1649     if (!MSVCRT_CHECK_PMT(mstm->tm_min >= 0 && mstm->tm_min < 60)) return EINVAL;
1650     if (!MSVCRT_CHECK_PMT(mstm->tm_hour >= 0 && mstm->tm_hour < 24)) return EINVAL;
1651     if (!MSVCRT_CHECK_PMT(mstm->tm_mon >= 0 && mstm->tm_mon < 12)) return EINVAL;
1652     if (!MSVCRT_CHECK_PMT(mstm->tm_wday >= 0 && mstm->tm_wday < 7)) return EINVAL;
1653     if (!MSVCRT_CHECK_PMT(mstm->tm_year >= 0)) return EINVAL;
1654     if (!MSVCRT_CHECK_PMT(mstm->tm_mday >= 0)) return EINVAL;
1655     if (!MSVCRT_CHECK_PMT(mstm->tm_mday <= MonthLengths[IsLeapYear(1900+mstm->tm_year)][mstm->tm_mon])) return EINVAL;
1656
1657     asctime_buf(time, mstm);
1658     return 0;
1659 }
1660
1661 /*********************************************************************
1662  *              _wasctime (MSVCRT.@)
1663  */
1664 wchar_t * CDECL _wasctime(const struct tm *mstm)
1665 {
1666     thread_data_t *data = msvcrt_get_thread_data();
1667     char buffer[26];
1668
1669     if(!data->wasctime_buffer) {
1670         data->wasctime_buffer = malloc(26*sizeof(wchar_t));
1671         if(!data->wasctime_buffer) {
1672             *_errno() = ENOMEM;
1673             return NULL;
1674         }
1675     }
1676
1677     if(!asctime_buf(buffer, mstm))
1678         return NULL;
1679
1680     MultiByteToWideChar(CP_ACP, 0, buffer, -1, data->wasctime_buffer, 26);
1681     return data->wasctime_buffer;
1682 }
1683
1684 /*********************************************************************
1685  *      _wasctime_s (MSVCRT.@)
1686  */
1687 int CDECL _wasctime_s(wchar_t* time, size_t size, const struct tm *mstm)
1688 {
1689     char buffer[26];
1690     int ret;
1691
1692     if (!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
1693     if (size) time[0] = 0;
1694     if (!MSVCRT_CHECK_PMT(size >= 26)) return EINVAL;
1695     if (!MSVCRT_CHECK_PMT(mstm != NULL)) return EINVAL;
1696
1697     ret = asctime_s(buffer, sizeof(buffer), mstm);
1698     if(ret)
1699         return ret;
1700     MultiByteToWideChar(CP_ACP, 0, buffer, -1, time, size);
1701     return 0;
1702 }
1703
1704 /*********************************************************************
1705  *              _ctime64 (MSVCRT.@)
1706  */
1707 char * CDECL _ctime64(const __time64_t *time)
1708 {
1709     struct tm *t;
1710     t = _localtime64( time );
1711     if (!t) return NULL;
1712     return asctime( t );
1713 }
1714
1715 /*********************************************************************
1716  *              _ctime64_s (MSVCRT.@)
1717  */
1718 int CDECL _ctime64_s(char *res, size_t len, const __time64_t *time)
1719 {
1720     struct tm *t;
1721
1722     if (!MSVCRT_CHECK_PMT( res != NULL )) return EINVAL;
1723     if (!MSVCRT_CHECK_PMT( len >= 26 )) return EINVAL;
1724     res[0] = '\0';
1725     if (!MSVCRT_CHECK_PMT( time != NULL )) return EINVAL;
1726     if (!MSVCRT_CHECK_PMT( *time > 0 )) return EINVAL;
1727
1728     t = _localtime64( time );
1729     strcpy( res, asctime( t ) );
1730     return 0;
1731 }
1732
1733 /*********************************************************************
1734  *              _ctime32 (MSVCRT.@)
1735  */
1736 char * CDECL _ctime32(const __time32_t *time)
1737 {
1738     struct tm *t;
1739     t = _localtime32( time );
1740     if (!t) return NULL;
1741     return asctime( t );
1742 }
1743
1744 /*********************************************************************
1745  *              _ctime32_s (MSVCRT.@)
1746  */
1747 int CDECL _ctime32_s(char *res, size_t len, const __time32_t *time)
1748 {
1749     struct tm *t;
1750
1751     if (!MSVCRT_CHECK_PMT( res != NULL )) return EINVAL;
1752     if (!MSVCRT_CHECK_PMT( len >= 26 )) return EINVAL;
1753     res[0] = '\0';
1754     if (!MSVCRT_CHECK_PMT( time != NULL )) return EINVAL;
1755     if (!MSVCRT_CHECK_PMT( *time > 0 )) return EINVAL;
1756
1757     t = _localtime32( time );
1758     strcpy( res, asctime( t ) );
1759     return 0;
1760 }
1761
1762 /*********************************************************************
1763  *              _wctime64 (MSVCRT.@)
1764  */
1765 wchar_t * CDECL _wctime64(const __time64_t *time)
1766 {
1767     return _wasctime( _localtime64(time) );
1768 }
1769
1770 /*********************************************************************
1771  *              _wctime32 (MSVCRT.@)
1772  */
1773 wchar_t * CDECL _wctime32(const __time32_t *time)
1774 {
1775     return _wasctime( _localtime32(time) );
1776 }
1777
1778 /*********************************************************************
1779  *              _wctime64_s (MSVCRT.@)
1780  */
1781 int CDECL _wctime64_s(wchar_t *buf,
1782         size_t size, const __time64_t *time)
1783 {
1784     struct tm tm;
1785     int ret;
1786
1787     if(!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
1788     if(!MSVCRT_CHECK_PMT(size != 0)) return EINVAL;
1789     buf[0] = 0;
1790     if(!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
1791     if(!MSVCRT_CHECK_PMT(*time >= 0)) return EINVAL;
1792     if(!MSVCRT_CHECK_PMT(*time <= _MAX__TIME64_T)) return EINVAL;
1793
1794     ret = _localtime64_s(&tm, time);
1795     if(ret != 0)
1796         return ret;
1797
1798     return _wasctime_s(buf, size, &tm);
1799 }
1800
1801 /*********************************************************************
1802  *              _wctime32_s (MSVCRT.@)
1803  */
1804 int CDECL _wctime32_s(wchar_t *buf, size_t size,
1805         const __time32_t *time)
1806 {
1807     struct tm tm;
1808     int ret;
1809
1810     if(!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
1811     if(!MSVCRT_CHECK_PMT(size != 0)) return EINVAL;
1812     buf[0] = 0;
1813     if(!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
1814     if(!MSVCRT_CHECK_PMT(*time >= 0)) return EINVAL;
1815
1816     ret = _localtime32_s(&tm, time);
1817     if(ret != 0)
1818         return ret;
1819
1820     return _wasctime_s(buf, size, &tm);
1821 }
1822
1823 #if _MSVCR_VER >= 80
1824
1825 /*********************************************************************
1826  * _get_timezone (MSVCR80.@)
1827  */
1828 int CDECL _get_timezone(LONG *timezone)
1829 {
1830     if(!MSVCRT_CHECK_PMT(timezone != NULL)) return EINVAL;
1831
1832     *timezone = MSVCRT___timezone;
1833     return 0;
1834 }
1835
1836 /*********************************************************************
1837  * _get_daylight (MSVCR80.@)
1838  */
1839 int CDECL _get_daylight(int *hours)
1840 {
1841     if(!MSVCRT_CHECK_PMT(hours != NULL)) return EINVAL;
1842
1843     *hours = MSVCRT___daylight;
1844     return 0;
1845 }
1846
1847 #endif /* _MSVCR_VER >= 80 */
1848
1849 #if _MSVCR_VER >= 140
1850
1851 #define TIME_UTC 1
1852
1853 struct _timespec32
1854 {
1855     __time32_t tv_sec;
1856     LONG tv_nsec;
1857 };
1858
1859 struct _timespec64
1860 {
1861     __time64_t tv_sec;
1862     LONG tv_nsec;
1863 };
1864
1865 /*********************************************************************
1866  * _timespec64_get (UCRTBASE.@)
1867  */
1868 int CDECL _timespec64_get(struct _timespec64 *ts, int base)
1869 {
1870     ULONGLONG time;
1871     FILETIME ft;
1872
1873     if(!MSVCRT_CHECK_PMT(ts != NULL)) return 0;
1874     if(base != TIME_UTC) return 0;
1875
1876     GetSystemTimePreciseAsFileTime(&ft);
1877     time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
1878
1879     ts->tv_sec = time / TICKSPERSEC - SECS_1601_TO_1970;
1880     ts->tv_nsec = time % TICKSPERSEC * 100;
1881     return base;
1882 }
1883
1884 /*********************************************************************
1885  * _timespec32_get (UCRTBASE.@)
1886  */
1887 int CDECL _timespec32_get(struct _timespec32 *ts, int base)
1888 {
1889     struct _timespec64 ts64;
1890
1891     if(!MSVCRT_CHECK_PMT(ts != NULL)) return 0;
1892     if(base != TIME_UTC) return 0;
1893
1894     if(_timespec64_get(&ts64, base) != base)
1895         return 0;
1896     if(ts64.tv_sec != (__time32_t)ts64.tv_sec)
1897         return 0;
1898
1899     ts->tv_sec = ts64.tv_sec;
1900     ts->tv_nsec = ts64.tv_nsec;
1901     return base;
1902 }
1903 #endif /* _MSVCR_VER >= 140 */