git.oblomov.eu Git - wine/blob - 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 "config.h"
  26
  27 #define _POSIX_PTHREAD_SEMANTICS /* switch to a 2 arg style asctime_r on Solaris */
  28 #include <time.h>
  29 #ifdef HAVE_SYS_TIMES_H
  30 # include <sys/times.h>
  31 #endif
  32 #include <limits.h>
  33
  34 #include "msvcrt.h"
  35 #include "mtdll.h"
  36 #include "winbase.h"
  37 #include "winnls.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  41
  42 static const int MonthLengths[2][12] =
  43 {
  44     { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  45     { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  46 };
  47
  48 static inline int IsLeapYear(int Year)
  49 {
  50     return Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0);
  51 }
  52
  53 static inline void msvcrt_tm_to_unix( struct tm *dest, const struct MSVCRT_tm *src )
  54 {
  55     memset( dest, 0, sizeof(*dest) );
  56     dest->tm_sec   = src->tm_sec;
  57     dest->tm_min   = src->tm_min;
  58     dest->tm_hour  = src->tm_hour;
  59     dest->tm_mday  = src->tm_mday;
  60     dest->tm_mon   = src->tm_mon;
  61     dest->tm_year  = src->tm_year;
  62     dest->tm_wday  = src->tm_wday;
  63     dest->tm_yday  = src->tm_yday;
  64     dest->tm_isdst = src->tm_isdst;
  65 }
  66
  67 static inline void unix_tm_to_msvcrt( struct MSVCRT_tm *dest, const struct tm *src )
  68 {
  69     memset( dest, 0, sizeof(*dest) );
  70     dest->tm_sec   = src->tm_sec;
  71     dest->tm_min   = src->tm_min;
  72     dest->tm_hour  = src->tm_hour;
  73     dest->tm_mday  = src->tm_mday;
  74     dest->tm_mon   = src->tm_mon;
  75     dest->tm_year  = src->tm_year;
  76     dest->tm_wday  = src->tm_wday;
  77     dest->tm_yday  = src->tm_yday;
  78     dest->tm_isdst = src->tm_isdst;
  79 }
  80
  81 static inline void write_invalid_msvcrt_tm( struct MSVCRT_tm *tm )
  82 {
  83     tm->tm_sec = -1;
  84     tm->tm_min = -1;
  85     tm->tm_hour = -1;
  86     tm->tm_mday = -1;
  87     tm->tm_mon = -1;
  88     tm->tm_year = -1;
  89     tm->tm_wday = -1;
  90     tm->tm_yday = -1;
  91     tm->tm_isdst = -1;
  92 }
  93
  94 #define SECSPERDAY        86400
  95 /* 1601 to 1970 is 369 years plus 89 leap days */
  96 #define SECS_1601_TO_1970  ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
  97 #define TICKSPERSEC       10000000
  98 #define TICKSPERMSEC      10000
  99 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKSPERSEC)
 100
 101 /**********************************************************************
 102  *              _mktime64 (MSVCRT.@)
 103  */
 104 MSVCRT___time64_t CDECL MSVCRT__mktime64(struct MSVCRT_tm *mstm)
 105 {
 106     time_t secs;
 107     struct tm tm;
 108
 109     msvcrt_tm_to_unix( &tm, mstm );
 110     secs = mktime( &tm );
 111     unix_tm_to_msvcrt( mstm, &tm );
 112
 113     return secs < 0 ? -1 : secs;
 114 }
 115
 116 /**********************************************************************
 117  *              _mktime32 (MSVCRT.@)
 118  */
 119 MSVCRT___time32_t CDECL MSVCRT__mktime32(struct MSVCRT_tm *mstm)
 120 {
 121     return MSVCRT__mktime64( mstm );
 122 }
 123
 124 /**********************************************************************
 125  *              mktime (MSVCRT.@)
 126  */
 127 #ifdef _WIN64
 128 MSVCRT___time64_t CDECL MSVCRT_mktime(struct MSVCRT_tm *mstm)
 129 {
 130     return MSVCRT__mktime64( mstm );
 131 }
 132 #else
 133 MSVCRT___time32_t CDECL MSVCRT_mktime(struct MSVCRT_tm *mstm)
 134 {
 135     return MSVCRT__mktime32( mstm );
 136 }
 137 #endif
 138
 139 /**********************************************************************
 140  *              _mkgmtime64 (MSVCRT.@)
 141  *
 142  * time->tm_isdst value is ignored
 143  */
 144 MSVCRT___time64_t CDECL MSVCRT__mkgmtime64(struct MSVCRT_tm *time)
 145 {
 146     SYSTEMTIME st;
 147     FILETIME ft;
 148     MSVCRT___time64_t ret;
 149     int i;
 150
 151     st.wMilliseconds = 0;
 152     st.wSecond = time->tm_sec;
 153     st.wMinute = time->tm_min;
 154     st.wHour = time->tm_hour;
 155     st.wDay = time->tm_mday;
 156     st.wMonth = time->tm_mon+1;
 157     st.wYear = time->tm_year+1900;
 158
 159     if(!SystemTimeToFileTime(&st, &ft))
 160         return -1;
 161
 162     FileTimeToSystemTime(&ft, &st);
 163     time->tm_wday = st.wDayOfWeek;
 164
 165     for(i=time->tm_yday=0; i<st.wMonth-1; i++)
 166         time->tm_yday += MonthLengths[IsLeapYear(st.wYear)][i];
 167     time->tm_yday += st.wDay-1;
 168
 169     ret = ((MSVCRT___time64_t)ft.dwHighDateTime<<32)+ft.dwLowDateTime;
 170     ret = (ret-TICKS_1601_TO_1970)/TICKSPERSEC;
 171     return ret;
 172 }
 173
 174 /**********************************************************************
 175  *              _mkgmtime32 (MSVCRT.@)
 176  */
 177 MSVCRT___time32_t CDECL MSVCRT__mkgmtime32(struct MSVCRT_tm *time)
 178 {
 179     return MSVCRT__mkgmtime64(time);
 180 }
 181
 182 /**********************************************************************
 183  *              _mkgmtime (MSVCRT.@)
 184  */
 185 #ifdef _WIN64
 186 MSVCRT___time64_t CDECL MSVCRT__mkgmtime(struct MSVCRT_tm *time)
 187 {
 188     return MSVCRT__mkgmtime64(time);
 189 }
 190 #else
 191 MSVCRT___time32_t CDECL MSVCRT__mkgmtime(struct MSVCRT_tm *time)
 192 {
 193     return MSVCRT__mkgmtime32(time);
 194 }
 195 #endif
 196
 197 /*********************************************************************
 198  *      _localtime64 (MSVCRT.@)
 199  */
 200 struct MSVCRT_tm* CDECL MSVCRT__localtime64(const MSVCRT___time64_t* secs)
 201 {
 202     struct tm *tm;
 203     thread_data_t *data;
 204     time_t seconds = *secs;
 205
 206     if (seconds < 0) return NULL;
 207
 208     _mlock(_TIME_LOCK);
 209     if (!(tm = localtime( &seconds))) {
 210         _munlock(_TIME_LOCK);
 211         return NULL;
 212     }
 213
 214     data = msvcrt_get_thread_data();
 215     if(!data->time_buffer)
 216         data->time_buffer = MSVCRT_malloc(sizeof(struct MSVCRT_tm));
 217
 218     unix_tm_to_msvcrt( data->time_buffer, tm );
 219     _munlock(_TIME_LOCK);
 220
 221     return data->time_buffer;
 222 }
 223
 224 /*********************************************************************
 225  *      _localtime64_s (MSVCRT.@)
 226  */
 227 int CDECL _localtime64_s(struct MSVCRT_tm *time, const MSVCRT___time64_t *secs)
 228 {
 229     struct tm *tm;
 230     time_t seconds;
 231
 232     if (!time || !secs || *secs < 0 || *secs > _MAX__TIME64_T)
 233     {
 234         if (time)
 235             write_invalid_msvcrt_tm(time);
 236
 237         *MSVCRT__errno() = MSVCRT_EINVAL;
 238         return MSVCRT_EINVAL;
 239     }
 240
 241     seconds = *secs;
 242
 243     _mlock(_TIME_LOCK);
 244     if (!(tm = localtime(&seconds)))
 245     {
 246         _munlock(_TIME_LOCK);
 247         *MSVCRT__errno() = MSVCRT_EINVAL;
 248         return MSVCRT_EINVAL;
 249     }
 250
 251     unix_tm_to_msvcrt(time, tm);
 252     _munlock(_TIME_LOCK);
 253     return 0;
 254 }
 255
 256 /*********************************************************************
 257  *      _localtime32 (MSVCRT.@)
 258  */
 259 struct MSVCRT_tm* CDECL MSVCRT__localtime32(const MSVCRT___time32_t* secs)
 260 {
 261     MSVCRT___time64_t secs64 = *secs;
 262     return MSVCRT__localtime64( &secs64 );
 263 }
 264
 265 /*********************************************************************
 266  *      _localtime32_s (MSVCRT.@)
 267  */
 268 int CDECL _localtime32_s(struct MSVCRT_tm *time, const MSVCRT___time32_t *secs)
 269 {
 270     MSVCRT___time64_t secs64;
 271
 272     if (!time || !secs || *secs < 0)
 273     {
 274         if (time)
 275             write_invalid_msvcrt_tm(time);
 276
 277         *MSVCRT__errno() = MSVCRT_EINVAL;
 278         return MSVCRT_EINVAL;
 279     }
 280
 281     secs64 = *secs;
 282     return _localtime64_s(time, &secs64);
 283 }
 284
 285 /*********************************************************************
 286  *      localtime (MSVCRT.@)
 287  */
 288 #ifdef _WIN64
 289 struct MSVCRT_tm* CDECL MSVCRT_localtime(const MSVCRT___time64_t* secs)
 290 {
 291     return MSVCRT__localtime64( secs );
 292 }
 293 #else
 294 struct MSVCRT_tm* CDECL MSVCRT_localtime(const MSVCRT___time32_t* secs)
 295 {
 296     return MSVCRT__localtime32( secs );
 297 }
 298 #endif
 299
 300 /*********************************************************************
 301  *      _gmtime64 (MSVCRT.@)
 302  */
 303 int CDECL MSVCRT__gmtime64_s(struct MSVCRT_tm *res, const MSVCRT___time64_t *secs)
 304 {
 305     int i;
 306     FILETIME ft;
 307     SYSTEMTIME st;
 308     ULONGLONG time;
 309
 310     if (!res || !secs || *secs < 0) {
 311         if (res) {
 312             write_invalid_msvcrt_tm(res);
 313         }
 314
 315         *MSVCRT__errno() = MSVCRT_EINVAL;
 316         return MSVCRT_EINVAL;
 317     }
 318
 319     time = *secs * (ULONGLONG)TICKSPERSEC + TICKS_1601_TO_1970;
 320
 321     ft.dwHighDateTime = (UINT)(time >> 32);
 322     ft.dwLowDateTime  = (UINT)time;
 323
 324     FileTimeToSystemTime(&ft, &st);
 325
 326     res->tm_sec  = st.wSecond;
 327     res->tm_min  = st.wMinute;
 328     res->tm_hour = st.wHour;
 329     res->tm_mday = st.wDay;
 330     res->tm_year = st.wYear - 1900;
 331     res->tm_mon  = st.wMonth - 1;
 332     res->tm_wday = st.wDayOfWeek;
 333     for (i = res->tm_yday = 0; i < st.wMonth - 1; i++) {
 334         res->tm_yday += MonthLengths[IsLeapYear(st.wYear)][i];
 335     }
 336
 337     res->tm_yday += st.wDay - 1;
 338     res->tm_isdst = 0;
 339
 340     return 0;
 341 }
 342
 343 /*********************************************************************
 344  *      _gmtime64 (MSVCRT.@)
 345  */
 346 struct MSVCRT_tm* CDECL MSVCRT__gmtime64(const MSVCRT___time64_t *secs)
 347 {
 348     thread_data_t * const data = msvcrt_get_thread_data();
 349
 350     if(!data->time_buffer)
 351         data->time_buffer = MSVCRT_malloc(sizeof(struct MSVCRT_tm));
 352
 353     if(MSVCRT__gmtime64_s(data->time_buffer, secs))
 354         return NULL;
 355     return data->time_buffer;
 356 }
 357
 358 /*********************************************************************
 359  *      _gmtime32_s (MSVCRT.@)
 360  */
 361 int CDECL MSVCRT__gmtime32_s(struct MSVCRT_tm *res, const MSVCRT___time32_t *secs)
 362 {
 363     MSVCRT___time64_t secs64;
 364
 365     if(secs) {
 366         secs64 = *secs;
 367         return MSVCRT__gmtime64_s(res, &secs64);
 368     }
 369     return MSVCRT__gmtime64_s(res, NULL);
 370 }
 371
 372 /*********************************************************************
 373  *      _gmtime32 (MSVCRT.@)
 374  */
 375 struct MSVCRT_tm* CDECL MSVCRT__gmtime32(const MSVCRT___time32_t* secs)
 376 {
 377     MSVCRT___time64_t secs64;
 378
 379     if(!secs)
 380         return NULL;
 381
 382     secs64 = *secs;
 383     return MSVCRT__gmtime64( &secs64 );
 384 }
 385
 386 /*********************************************************************
 387  *      gmtime (MSVCRT.@)
 388  */
 389 #ifdef _WIN64
 390 struct MSVCRT_tm* CDECL MSVCRT_gmtime(const MSVCRT___time64_t* secs)
 391 {
 392     return MSVCRT__gmtime64( secs );
 393 }
 394 #else
 395 struct MSVCRT_tm* CDECL MSVCRT_gmtime(const MSVCRT___time32_t* secs)
 396 {
 397     return MSVCRT__gmtime32( secs );
 398 }
 399 #endif
 400
 401 /**********************************************************************
 402  *              _strdate (MSVCRT.@)
 403  */
 404 char* CDECL _strdate(char* date)
 405 {
 406   static const char format[] = "MM'/'dd'/'yy";
 407
 408   GetDateFormatA(LOCALE_NEUTRAL, 0, NULL, format, date, 9);
 409
 410   return date;
 411 }
 412
 413 /**********************************************************************
 414  *              _strdate_s (MSVCRT.@)
 415  */
 416 int CDECL _strdate_s(char* date, MSVCRT_size_t size)
 417 {
 418     if(date && size)
 419         date[0] = '\0';
 420
 421     if(!date) {
 422         *MSVCRT__errno() = MSVCRT_EINVAL;
 423         return MSVCRT_EINVAL;
 424     }
 425
 426     if(size < 9) {
 427         *MSVCRT__errno() = MSVCRT_ERANGE;
 428         return MSVCRT_ERANGE;
 429     }
 430
 431     _strdate(date);
 432     return 0;
 433 }
 434
 435 /**********************************************************************
 436  *              _wstrdate (MSVCRT.@)
 437  */
 438 MSVCRT_wchar_t* CDECL _wstrdate(MSVCRT_wchar_t* date)
 439 {
 440   static const WCHAR format[] = { 'M','M','\'','/','\'','d','d','\'','/','\'','y','y',0 };
 441
 442   GetDateFormatW(LOCALE_NEUTRAL, 0, NULL, format, date, 9);
 443
 444   return date;
 445 }
 446
 447 /**********************************************************************
 448  *              _wstrdate_s (MSVCRT.@)
 449  */
 450 int CDECL _wstrdate_s(MSVCRT_wchar_t* date, MSVCRT_size_t size)
 451 {
 452     if(date && size)
 453         date[0] = '\0';
 454
 455     if(!date) {
 456         *MSVCRT__errno() = MSVCRT_EINVAL;
 457         return MSVCRT_EINVAL;
 458     }
 459
 460     if(size < 9) {
 461         *MSVCRT__errno() = MSVCRT_ERANGE;
 462         return MSVCRT_ERANGE;
 463     }
 464
 465     _wstrdate(date);
 466     return 0;
 467 }
 468
 469 /*********************************************************************
 470  *              _strtime (MSVCRT.@)
 471  */
 472 char* CDECL _strtime(char* time)
 473 {
 474   static const char format[] = "HH':'mm':'ss";
 475
 476   GetTimeFormatA(LOCALE_NEUTRAL, 0, NULL, format, time, 9);
 477
 478   return time;
 479 }
 480
 481 /*********************************************************************
 482  *              _strtime_s (MSVCRT.@)
 483  */
 484 int CDECL _strtime_s(char* time, MSVCRT_size_t size)
 485 {
 486     if(time && size)
 487         time[0] = '\0';
 488
 489     if(!time) {
 490         *MSVCRT__errno() = MSVCRT_EINVAL;
 491         return MSVCRT_EINVAL;
 492     }
 493
 494     if(size < 9) {
 495         *MSVCRT__errno() = MSVCRT_ERANGE;
 496         return MSVCRT_ERANGE;
 497     }
 498
 499     _strtime(time);
 500     return 0;
 501 }
 502
 503 /*********************************************************************
 504  *              _wstrtime (MSVCRT.@)
 505  */
 506 MSVCRT_wchar_t* CDECL _wstrtime(MSVCRT_wchar_t* time)
 507 {
 508   static const WCHAR format[] = { 'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0 };
 509
 510   GetTimeFormatW(LOCALE_NEUTRAL, 0, NULL, format, time, 9);
 511
 512   return time;
 513 }
 514
 515 /*********************************************************************
 516  *              _wstrtime_s (MSVCRT.@)
 517  */
 518 int CDECL _wstrtime_s(MSVCRT_wchar_t* time, MSVCRT_size_t size)
 519 {
 520     if(time && size)
 521         time[0] = '\0';
 522
 523     if(!time) {
 524         *MSVCRT__errno() = MSVCRT_EINVAL;
 525         return MSVCRT_EINVAL;
 526     }
 527
 528     if(size < 9) {
 529         *MSVCRT__errno() = MSVCRT_ERANGE;
 530         return MSVCRT_ERANGE;
 531     }
 532
 533     _wstrtime(time);
 534     return 0;
 535 }
 536
 537 /*********************************************************************
 538  *              clock (MSVCRT.@)
 539  */
 540 MSVCRT_clock_t CDECL MSVCRT_clock(void)
 541 {
 542   FILETIME ftc, fte, ftk, ftu;
 543   ULONGLONG utime, ktime;
 544
 545   MSVCRT_clock_t clock;
 546
 547   GetProcessTimes(GetCurrentProcess(), &ftc, &fte, &ftk, &ftu);
 548
 549   ktime = ((ULONGLONG)ftk.dwHighDateTime << 32) | ftk.dwLowDateTime;
 550   utime = ((ULONGLONG)ftu.dwHighDateTime << 32) | ftu.dwLowDateTime;
 551
 552   clock = (utime + ktime) / (TICKSPERSEC / MSVCRT_CLOCKS_PER_SEC);
 553
 554   return clock;
 555 }
 556
 557 /*********************************************************************
 558  *              _difftime64 (MSVCRT.@)
 559  */
 560 double CDECL MSVCRT__difftime64(MSVCRT___time64_t time1, MSVCRT___time64_t time2)
 561 {
 562   return (double)(time1 - time2);
 563 }
 564
 565 /*********************************************************************
 566  *              _difftime32 (MSVCRT.@)
 567  */
 568 double CDECL MSVCRT__difftime32(MSVCRT___time32_t time1, MSVCRT___time32_t time2)
 569 {
 570   return (double)(time1 - time2);
 571 }
 572
 573 /*********************************************************************
 574  *              difftime (MSVCRT.@)
 575  */
 576 #ifdef _WIN64
 577 double CDECL MSVCRT_difftime(MSVCRT___time64_t time1, MSVCRT___time64_t time2)
 578 {
 579     return MSVCRT__difftime64( time1, time2 );
 580 }
 581 #else
 582 double CDECL MSVCRT_difftime(MSVCRT___time32_t time1, MSVCRT___time32_t time2)
 583 {
 584     return MSVCRT__difftime32( time1, time2 );
 585 }
 586 #endif
 587
 588 /*********************************************************************
 589  *              _ftime64 (MSVCRT.@)
 590  */
 591 void CDECL MSVCRT__ftime64(struct MSVCRT___timeb64 *buf)
 592 {
 593   TIME_ZONE_INFORMATION tzinfo;
 594   FILETIME ft;
 595   ULONGLONG time;
 596
 597   DWORD tzid = GetTimeZoneInformation(&tzinfo);
 598   GetSystemTimeAsFileTime(&ft);
 599
 600   time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
 601
 602   buf->time = time / TICKSPERSEC - SECS_1601_TO_1970;
 603   buf->millitm = (time % TICKSPERSEC) / TICKSPERMSEC;
 604   buf->timezone = tzinfo.Bias +
 605       ( tzid == TIME_ZONE_ID_STANDARD ? tzinfo.StandardBias :
 606       ( tzid == TIME_ZONE_ID_DAYLIGHT ? tzinfo.DaylightBias : 0 ));
 607   buf->dstflag = (tzid == TIME_ZONE_ID_DAYLIGHT?1:0);
 608 }
 609
 610 /*********************************************************************
 611  *              _ftime64_s (MSVCRT.@)
 612  */
 613 int CDECL MSVCRT__ftime64_s(struct MSVCRT___timeb64 *buf)
 614 {
 615     if( !MSVCRT_CHECK_PMT( buf != NULL ) )
 616     {
 617         *MSVCRT__errno() = MSVCRT_EINVAL;
 618         return MSVCRT_EINVAL;
 619     }
 620     MSVCRT__ftime64(buf);
 621     return 0;
 622 }
 623
 624 /*********************************************************************
 625  *              _ftime32 (MSVCRT.@)
 626  */
 627 void CDECL MSVCRT__ftime32(struct MSVCRT___timeb32 *buf)
 628 {
 629     struct MSVCRT___timeb64 buf64;
 630
 631     MSVCRT__ftime64( &buf64 );
 632     buf->time     = buf64.time;
 633     buf->millitm  = buf64.millitm;
 634     buf->timezone = buf64.timezone;
 635     buf->dstflag  = buf64.dstflag;
 636 }
 637
 638 /*********************************************************************
 639  *              _ftime32_s (MSVCRT.@)
 640  */
 641 int CDECL MSVCRT__ftime32_s(struct MSVCRT___timeb32 *buf)
 642 {
 643     if( !MSVCRT_CHECK_PMT( buf != NULL ) )
 644     {
 645         *MSVCRT__errno() = MSVCRT_EINVAL;
 646         return MSVCRT_EINVAL;
 647     }
 648     MSVCRT__ftime32(buf);
 649     return 0;
 650 }
 651
 652 /*********************************************************************
 653  *              _ftime (MSVCRT.@)
 654  */
 655 #ifdef _WIN64
 656 void CDECL MSVCRT__ftime(struct MSVCRT___timeb64 *buf)
 657 {
 658     return MSVCRT__ftime64( buf );
 659 }
 660 #else
 661 void CDECL MSVCRT__ftime(struct MSVCRT___timeb32 *buf)
 662 {
 663     return MSVCRT__ftime32( buf );
 664 }
 665 #endif
 666
 667 /*********************************************************************
 668  *              _time64 (MSVCRT.@)
 669  */
 670 MSVCRT___time64_t CDECL MSVCRT__time64(MSVCRT___time64_t *buf)
 671 {
 672     MSVCRT___time64_t curtime;
 673     struct MSVCRT___timeb64 tb;
 674
 675     MSVCRT__ftime64(&tb);
 676
 677     curtime = tb.time;
 678     return buf ? *buf = curtime : curtime;
 679 }
 680
 681 /*********************************************************************
 682  *              _time32 (MSVCRT.@)
 683  */
 684 MSVCRT___time32_t CDECL MSVCRT__time32(MSVCRT___time32_t *buf)
 685 {
 686     MSVCRT___time32_t curtime;
 687     struct MSVCRT___timeb64 tb;
 688
 689     MSVCRT__ftime64(&tb);
 690
 691     curtime = tb.time;
 692     return buf ? *buf = curtime : curtime;
 693 }
 694
 695 /*********************************************************************
 696  *              time (MSVCRT.@)
 697  */
 698 #ifdef _WIN64
 699 MSVCRT___time64_t CDECL MSVCRT_time(MSVCRT___time64_t* buf)
 700 {
 701     return MSVCRT__time64( buf );
 702 }
 703 #else
 704 MSVCRT___time32_t CDECL MSVCRT_time(MSVCRT___time32_t* buf)
 705 {
 706     return MSVCRT__time32( buf );
 707 }
 708 #endif
 709
 710 /*********************************************************************
 711  *              _daylight (MSVCRT.@)
 712  */
 713 int MSVCRT___daylight = 0;
 714
 715 /*********************************************************************
 716  *              __p_daylight (MSVCRT.@)
 717  */
 718 int * CDECL MSVCRT___p__daylight(void)
 719 {
 720         return &MSVCRT___daylight;
 721 }
 722
 723 /*********************************************************************
 724  *              _dstbias (MSVCRT.@)
 725  */
 726 int MSVCRT__dstbias = 0;
 727
 728 /*********************************************************************
 729  *              __p_dstbias (MSVCRT.@)
 730  */
 731 int * CDECL __p__dstbias(void)
 732 {
 733     return &MSVCRT__dstbias;
 734 }
 735
 736 /*********************************************************************
 737  *              _timezone (MSVCRT.@)
 738  */
 739 MSVCRT_long MSVCRT___timezone = 0;
 740
 741 /*********************************************************************
 742  *              __p_timezone (MSVCRT.@)
 743  */
 744 MSVCRT_long * CDECL MSVCRT___p__timezone(void)
 745 {
 746         return &MSVCRT___timezone;
 747 }
 748
 749 /*********************************************************************
 750  *              _tzname (MSVCRT.@)
 751  * NOTES
 752  *  Some apps (notably Mozilla) insist on writing to these, so the buffer
 753  *  must be large enough.  The size is picked based on observation of
 754  *  Windows XP.
 755  */
 756 static char tzname_std[64] = "PST";
 757 static char tzname_dst[64] = "PDT";
 758 char *MSVCRT__tzname[2] = { tzname_std, tzname_dst };
 759
 760 /*********************************************************************
 761  *              _get_tzname (MSVCRT.@)
 762  */
 763 int CDECL MSVCRT__get_tzname(MSVCRT_size_t *ret, char *buf, MSVCRT_size_t bufsize, int index)
 764 {
 765     char *timezone;
 766
 767     switch(index)
 768     {
 769     case 0:
 770         timezone = tzname_std;
 771         break;
 772     case 1:
 773         timezone = tzname_dst;
 774         break;
 775     default:
 776         *MSVCRT__errno() = MSVCRT_EINVAL;
 777         return MSVCRT_EINVAL;
 778     }
 779
 780     if(!ret || (!buf && bufsize > 0) || (buf && !bufsize))
 781     {
 782         *MSVCRT__errno() = MSVCRT_EINVAL;
 783         return MSVCRT_EINVAL;
 784     }
 785
 786     *ret = strlen(timezone)+1;
 787     if(!buf && !bufsize)
 788         return 0;
 789
 790     strcpy(buf, timezone);
 791     return 0;
 792 }
 793
 794 /*********************************************************************
 795  *              __p_tzname (MSVCRT.@)
 796  */
 797 char ** CDECL __p__tzname(void)
 798 {
 799         return MSVCRT__tzname;
 800 }
 801
 802 /*********************************************************************
 803  *              _tzset (MSVCRT.@)
 804  */
 805 void CDECL MSVCRT__tzset(void)
 806 {
 807     tzset();
 808 #if defined(HAVE_TIMEZONE) && defined(HAVE_DAYLIGHT)
 809     MSVCRT___daylight = daylight;
 810     MSVCRT___timezone = timezone;
 811 #else
 812     {
 813         static const time_t seconds_in_year = (365 * 24 + 6) * 3600;
 814         time_t t;
 815         struct tm *tmp;
 816         int zone_january, zone_july;
 817
 818         _mlock(_TIME_LOCK);
 819         t = (time(NULL) / seconds_in_year) * seconds_in_year;
 820         tmp = localtime(&t);
 821         zone_january = -tmp->tm_gmtoff;
 822         t += seconds_in_year / 2;
 823         tmp = localtime(&t);
 824         zone_july = -tmp->tm_gmtoff;
 825         _munlock(_TIME_LOCK);
 826
 827         MSVCRT___daylight = (zone_january != zone_july);
 828         MSVCRT___timezone = max(zone_january, zone_july);
 829     }
 830 #endif
 831     lstrcpynA(tzname_std, tzname[0], sizeof(tzname_std));
 832     tzname_std[sizeof(tzname_std) - 1] = '\0';
 833     lstrcpynA(tzname_dst, tzname[1], sizeof(tzname_dst));
 834     tzname_dst[sizeof(tzname_dst) - 1] = '\0';
 835 }
 836
 837 /*********************************************************************
 838  *              strftime (MSVCRT.@)
 839  */
 840 MSVCRT_size_t CDECL MSVCRT_strftime( char *str, MSVCRT_size_t max, const char *format,
 841                                      const struct MSVCRT_tm *mstm )
 842 {
 843     struct tm tm;
 844
 845     msvcrt_tm_to_unix( &tm, mstm );
 846     return strftime( str, max, format, &tm );
 847 }
 848
 849 /*********************************************************************
 850  *              wcsftime (MSVCRT.@)
 851  */
 852 MSVCRT_size_t CDECL MSVCRT_wcsftime( MSVCRT_wchar_t *str, MSVCRT_size_t max,
 853                                      const MSVCRT_wchar_t *format, const struct MSVCRT_tm *mstm )
 854 {
 855     char *s, *fmt;
 856     MSVCRT_size_t len;
 857
 858     TRACE("%p %ld %s %p\n", str, max, debugstr_w(format), mstm );
 859
 860     len = WideCharToMultiByte( CP_UNIXCP, 0, format, -1, NULL, 0, NULL, NULL );
 861     if (!(fmt = MSVCRT_malloc( len ))) return 0;
 862     WideCharToMultiByte( CP_UNIXCP, 0, format, -1, fmt, len, NULL, NULL );
 863
 864     if ((s = MSVCRT_malloc( max*4 )))
 865     {
 866         struct tm tm;
 867         msvcrt_tm_to_unix( &tm, mstm );
 868         if (!strftime( s, max*4, fmt, &tm )) s[0] = 0;
 869         len = MultiByteToWideChar( CP_UNIXCP, 0, s, -1, str, max );
 870         if (len) len--;
 871         MSVCRT_free( s );
 872     }
 873     else len = 0;
 874
 875     MSVCRT_free( fmt );
 876     return len;
 877 }
 878
 879 /*********************************************************************
 880  *              asctime (MSVCRT.@)
 881  */
 882 char * CDECL MSVCRT_asctime(const struct MSVCRT_tm *mstm)
 883 {
 884     char bufferA[30];
 885     WCHAR bufferW[30];
 886
 887     thread_data_t *data = msvcrt_get_thread_data();
 888     struct tm tm;
 889
 890     msvcrt_tm_to_unix( &tm, mstm );
 891
 892     if (!data->asctime_buffer)
 893         data->asctime_buffer = MSVCRT_malloc( 30 ); /* ought to be enough */
 894
 895 #ifdef HAVE_ASCTIME_R
 896     asctime_r( &tm, bufferA );
 897 #else
 898     strcpy( bufferA, asctime(&tm) );
 899 #endif
 900     MultiByteToWideChar( CP_UNIXCP, 0, bufferA, -1, bufferW, 30 );
 901     WideCharToMultiByte( CP_ACP, 0, bufferW, -1, data->asctime_buffer, 30, NULL, NULL );
 902     return data->asctime_buffer;
 903 }
 904
 905 /*********************************************************************
 906  *              _wasctime (MSVCRT.@)
 907  */
 908 MSVCRT_wchar_t * CDECL MSVCRT__wasctime(const struct MSVCRT_tm *mstm)
 909 {
 910     thread_data_t *data = msvcrt_get_thread_data();
 911     struct tm tm;
 912     char buffer[30];
 913
 914     msvcrt_tm_to_unix( &tm, mstm );
 915
 916     if (!data->wasctime_buffer)
 917         data->wasctime_buffer = MSVCRT_malloc( 30*sizeof(MSVCRT_wchar_t) ); /* ought to be enough */
 918 #ifdef HAVE_ASCTIME_R
 919     asctime_r( &tm, buffer );
 920 #else
 921     strcpy( buffer, asctime(&tm) );
 922 #endif
 923     MultiByteToWideChar( CP_UNIXCP, 0, buffer, -1, data->wasctime_buffer, 30 );
 924     return data->wasctime_buffer;
 925 }
 926
 927 /*********************************************************************
 928  *              _ctime64 (MSVCRT.@)
 929  */
 930 char * CDECL MSVCRT__ctime64(const MSVCRT___time64_t *time)
 931 {
 932     struct MSVCRT_tm *t;
 933     t = MSVCRT__localtime64( time );
 934     if (!t) return NULL;
 935     return MSVCRT_asctime( t );
 936 }
 937
 938 /*********************************************************************
 939  *              _ctime64_s (MSVCRT.@)
 940  */
 941 int CDECL MSVCRT__ctime64_s(char *res, MSVCRT_size_t len, const MSVCRT___time64_t *time)
 942 {
 943     struct MSVCRT_tm *t;
 944     if( !MSVCRT_CHECK_PMT( res != NULL ) || !MSVCRT_CHECK_PMT( len >= 26 ) )
 945     {
 946         *MSVCRT__errno() = MSVCRT_EINVAL;
 947         return MSVCRT_EINVAL;
 948     }
 949     res[0] = '\0';
 950     if( !MSVCRT_CHECK_PMT( time != NULL ) || !MSVCRT_CHECK_PMT( *time > 0 ) )
 951     {
 952         *MSVCRT__errno() = MSVCRT_EINVAL;
 953         return MSVCRT_EINVAL;
 954     }
 955     t = MSVCRT__localtime64( time );
 956     strcpy( res, MSVCRT_asctime( t ) );
 957     return 0;
 958 }
 959
 960 /*********************************************************************
 961  *              _ctime32 (MSVCRT.@)
 962  */
 963 char * CDECL MSVCRT__ctime32(const MSVCRT___time32_t *time)
 964 {
 965     struct MSVCRT_tm *t;
 966     t = MSVCRT__localtime32( time );
 967     if (!t) return NULL;
 968     return MSVCRT_asctime( t );
 969 }
 970
 971 /*********************************************************************
 972  *              _ctime32_s (MSVCRT.@)
 973  */
 974 int CDECL MSVCRT__ctime32_s(char *res, MSVCRT_size_t len, const MSVCRT___time32_t *time)
 975 {
 976     struct MSVCRT_tm *t;
 977     if( !MSVCRT_CHECK_PMT( res != NULL ) || !MSVCRT_CHECK_PMT( len >= 26 ) )
 978     {
 979         *MSVCRT__errno() = MSVCRT_EINVAL;
 980         return MSVCRT_EINVAL;
 981     }
 982     res[0] = '\0';
 983     if( !MSVCRT_CHECK_PMT( time != NULL ) || !MSVCRT_CHECK_PMT( *time > 0 ) )
 984     {
 985         *MSVCRT__errno() = MSVCRT_EINVAL;
 986         return MSVCRT_EINVAL;
 987     }
 988     t = MSVCRT__localtime32( time );
 989     strcpy( res, MSVCRT_asctime( t ) );
 990     return 0;
 991 }
 992
 993 /*********************************************************************
 994  *              ctime (MSVCRT.@)
 995  */
 996 #ifdef _WIN64
 997 char * CDECL MSVCRT_ctime(const MSVCRT___time64_t *time)
 998 {
 999     return MSVCRT__ctime64( time );
1000 }
1001 #else
1002 char * CDECL MSVCRT_ctime(const MSVCRT___time32_t *time)
1003 {
1004     return MSVCRT__ctime32( time );
1005 }
1006 #endif
1007
1008 /*********************************************************************
1009  *              _wctime64 (MSVCRT.@)
1010  */
1011 MSVCRT_wchar_t * CDECL MSVCRT__wctime64(const MSVCRT___time64_t *time)
1012 {
1013     return MSVCRT__wasctime( MSVCRT__localtime64(time) );
1014 }
1015
1016 /*********************************************************************
1017  *              _wctime32 (MSVCRT.@)
1018  */
1019 MSVCRT_wchar_t * CDECL MSVCRT__wctime32(const MSVCRT___time32_t *time)
1020 {
1021     return MSVCRT__wasctime( MSVCRT__localtime32(time) );
1022 }
1023
1024 /*********************************************************************
1025  *              _wctime (MSVCRT.@)
1026  */
1027 #ifdef _WIN64
1028 MSVCRT_wchar_t * CDECL MSVCRT__wctime(const MSVCRT___time64_t *time)
1029 {
1030     return MSVCRT__wctime64( time );
1031 }
1032 #else
1033 MSVCRT_wchar_t * CDECL MSVCRT__wctime(const MSVCRT___time32_t *time)
1034 {
1035     return MSVCRT__wctime32( time );
1036 }
1037 #endif