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