sal/osl/unx/time.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "system.h"
  22
  23 #include <osl/diagnose.h>
  24 #include <osl/time.h>
  25 #include <time.h>
  26
  27 /* FIXME: detection should be done in configure script */
  28 #if defined(MACOSX) || defined(FREEBSD) || defined(NETBSD) || \
  29     defined(LINUX) || defined(OPENBSD) || defined(DRAGONFLY)
  30 #define STRUCT_TM_HAS_GMTOFF 1
  31
  32 #elif defined(SOLARIS)
  33 #define HAS_ALTZONE 1
  34 #endif
  35
  36 /*--------------------------------------------------
  37  * osl_getSystemTime
  38  *-------------------------------------------------*/
  39
  40 sal_Bool SAL_CALL osl_getSystemTime(TimeValue* tv)
  41 {
  42     int res;
  43 #if defined(LINUX)
  44     struct timespec tp;
  45
  46     res = clock_gettime(CLOCK_REALTIME, &tp);
  47 #else
  48     struct timeval tp;
  49
  50     res = gettimeofday(&tp, NULL);
  51 #endif
  52
  53     if (res != 0)
  54     {
  55         return sal_False;
  56     }
  57
  58     tv->Seconds = tp.tv_sec;
  59     #if defined(LINUX)
  60     tv->Nanosec = tp.tv_nsec;
  61     #else
  62     tv->Nanosec = tp.tv_usec * 1000;
  63     #endif
  64
  65     return sal_True;
  66 }
  67
  68
  69 /*--------------------------------------------------
  70  * osl_getDateTimeFromTimeValue
  71  *-------------------------------------------------*/
  72
  73 sal_Bool SAL_CALL osl_getDateTimeFromTimeValue( const TimeValue* pTimeVal, oslDateTime* pDateTime )
  74 {
  75     struct tm *pSystemTime;
  76     struct tm tmBuf;
  77     time_t atime;
  78
  79     atime = (time_t)pTimeVal->Seconds;
  80
  81     /* Convert time from type time_t to struct tm */
  82     pSystemTime = gmtime_r( &atime, &tmBuf );
  83
  84
  85     /* Convert struct tm to struct oslDateTime */
  86     if ( pSystemTime != NULL )
  87     {
  88         pDateTime->NanoSeconds  =   pTimeVal->Nanosec;
  89         pDateTime->Seconds      =   pSystemTime->tm_sec;
  90         pDateTime->Minutes      =   pSystemTime->tm_min;
  91         pDateTime->Hours        =   pSystemTime->tm_hour;
  92         pDateTime->Day          =   pSystemTime->tm_mday;
  93         pDateTime->DayOfWeek    =   pSystemTime->tm_wday;
  94         pDateTime->Month        =   pSystemTime->tm_mon + 1;
  95         pDateTime->Year         =   pSystemTime->tm_year  + 1900;
  96
  97         return sal_True;
  98     }
  99
 100     return sal_False;
 101 }
 102
 103 /*--------------------------------------------------
 104  * osl_getTimeValueFromDateTime
 105  *--------------------------------------------------*/
 106
 107 sal_Bool SAL_CALL osl_getTimeValueFromDateTime( const oslDateTime* pDateTime, TimeValue* pTimeVal )
 108 {
 109     struct tm   aTime;
 110     time_t      nSeconds;
 111
 112     /* Convert struct oslDateTime to struct tm */
 113     aTime.tm_sec  = pDateTime->Seconds;
 114     aTime.tm_min  = pDateTime->Minutes;
 115     aTime.tm_hour = pDateTime->Hours;
 116     aTime.tm_mday = pDateTime->Day;
 117     aTime.tm_wday = pDateTime->DayOfWeek;
 118
 119     if ( pDateTime->Month > 0 )
 120         aTime.tm_mon = pDateTime->Month - 1;
 121     else
 122         return sal_False;
 123
 124     if ( pDateTime->Year >= 1900 )
 125         aTime.tm_year = pDateTime->Year - 1900;
 126     else
 127         return sal_False;
 128
 129     aTime.tm_isdst = -1;
 130     aTime.tm_wday  = 0;
 131     aTime.tm_yday  = 0;
 132
 133     /* Convert time to calendar value */
 134     nSeconds = mktime( &aTime );
 135
 136     /*
 137      * mktime expects the struct tm to be in local timezone, so we have to adjust
 138      * the returned value to be timezone neutral.
 139      */
 140
 141     if ( nSeconds != (time_t) -1 )
 142     {
 143         time_t bias;
 144
 145         /* timezone corrections */
 146         tzset();
 147
 148 #if defined(STRUCT_TM_HAS_GMTOFF)
 149         /* members of struct tm are corrected by mktime */
 150         bias = 0 - aTime.tm_gmtoff;
 151
 152 #elif defined(HAS_ALTZONE)
 153         /* check if daylight saving time is in effect */
 154         bias = aTime.tm_isdst > 0 ? altzone : timezone;
 155 #else
 156         /* exspect daylight saving time to be one hour */
 157         bias = aTime.tm_isdst > 0 ? timezone - 3600 : timezone;
 158 #endif
 159
 160         pTimeVal->Seconds = nSeconds;
 161         pTimeVal->Nanosec = pDateTime->NanoSeconds;
 162
 163         if ( nSeconds > bias )
 164             pTimeVal->Seconds -= bias;
 165
 166         return sal_True;
 167     }
 168
 169     return sal_False;
 170 }
 171
 172
 173 /*--------------------------------------------------
 174  * osl_getLocalTimeFromSystemTime
 175  *--------------------------------------------------*/
 176
 177 sal_Bool SAL_CALL osl_getLocalTimeFromSystemTime( const TimeValue* pSystemTimeVal, TimeValue* pLocalTimeVal )
 178 {
 179     struct tm *pLocalTime;
 180     struct tm tmBuf;
 181     time_t bias;
 182     time_t atime;
 183
 184     atime = (time_t) pSystemTimeVal->Seconds;
 185     pLocalTime = localtime_r( &atime, &tmBuf );
 186
 187 #if defined(STRUCT_TM_HAS_GMTOFF)
 188     /* members of struct tm are corrected by mktime */
 189     bias = 0 - pLocalTime->tm_gmtoff;
 190
 191 #elif defined(HAS_ALTZONE)
 192     /* check if daylight saving time is in effect */
 193     bias = pLocalTime->tm_isdst > 0 ? altzone : timezone;
 194 #else
 195     /* exspect daylight saving time to be one hour */
 196     bias = pLocalTime->tm_isdst > 0 ? timezone - 3600 : timezone;
 197 #endif
 198
 199     if ( (sal_Int64) pSystemTimeVal->Seconds > bias )
 200     {
 201         pLocalTimeVal->Seconds = pSystemTimeVal->Seconds - bias;
 202         pLocalTimeVal->Nanosec = pSystemTimeVal->Nanosec;
 203
 204         return sal_True;
 205     }
 206
 207     return sal_False;
 208 }
 209
 210 /*--------------------------------------------------
 211  * osl_getSystemTimeFromLocalTime
 212  *--------------------------------------------------*/
 213
 214 sal_Bool SAL_CALL osl_getSystemTimeFromLocalTime( const TimeValue* pLocalTimeVal, TimeValue* pSystemTimeVal )
 215 {
 216     struct tm *pLocalTime;
 217     struct tm tmBuf;
 218     time_t bias;
 219     time_t atime;
 220
 221     atime = (time_t) pLocalTimeVal->Seconds;
 222
 223     /* Convert atime, which is a local time, to it's GMT equivalent. Then, get
 224      * the timezone offset for the local time for the GMT equivalent time. Note
 225      * that we cannot directly use local time to determine the timezone offset
 226      * because GMT is the only reliable time that we can determine timezone
 227      * offset from.
 228      */
 229
 230     atime = mktime( gmtime_r( &atime, &tmBuf ) );
 231     pLocalTime = localtime_r( &atime, &tmBuf );
 232
 233 #if defined(STRUCT_TM_HAS_GMTOFF)
 234     /* members of struct tm are corrected by mktime */
 235     bias = 0 - pLocalTime->tm_gmtoff;
 236
 237 #elif defined(HAS_ALTZONE)
 238     /* check if daylight saving time is in effect */
 239     bias = pLocalTime->tm_isdst > 0 ? altzone : timezone;
 240 #else
 241     /* exspect daylight saving time to be one hour */
 242     bias = pLocalTime->tm_isdst > 0 ? timezone - 3600 : timezone;
 243 #endif
 244
 245     if ( (sal_Int64) pLocalTimeVal->Seconds + bias > 0 )
 246     {
 247         pSystemTimeVal->Seconds = pLocalTimeVal->Seconds + bias;
 248         pSystemTimeVal->Nanosec = pLocalTimeVal->Nanosec;
 249
 250         return sal_True;
 251     }
 252
 253     return sal_False;
 254 }
 255
 256
 257
 258 static struct timeval startTime;
 259 static sal_Bool bGlobalTimer = sal_False;
 260
 261 sal_uInt32 SAL_CALL osl_getGlobalTimer()
 262 {
 263   struct timeval currentTime;
 264   sal_uInt32 nSeconds;
 265
 266   // FIXME: not thread safe !!
 267   if ( bGlobalTimer == sal_False )
 268   {
 269       gettimeofday( &startTime, NULL );
 270       bGlobalTimer=sal_True;
 271   }
 272
 273   gettimeofday( &currentTime, NULL );
 274
 275   nSeconds = (sal_uInt32)( currentTime.tv_sec - startTime.tv_sec );
 276
 277   return ( nSeconds * 1000 ) + (long) (( currentTime.tv_usec - startTime.tv_usec) / 1000 );
 278 }
 279
 280 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */