timeutil.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: timeutil.c 1.10 2019/02/08 10:51:44 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Meinberg Library module for safe time conversion routines.
 *
 * -----------------------------------------------------------------------
 *  $Log: timeutil.c $
 *  Revision 1.10  2019/02/08 10:51:44  martin
 *  Removed some definitions that are also in the header file.
 *  Fixed a compiler warning.
 *  Revision 1.9  2018/12/18 11:00:48  martin
 *  Implemented setting time on Windows.
 *  Revision 1.8  2018/12/11 15:02:57Z  martin
 *  Cast to avoid build error on Windows.
 *  Revision 1.7  2018/01/30 09:51:35Z  martin
 *  Let snprint_gmtime_error() return an int instead of size_t.
 *  Updated mbg_clock_gettime():
 *  Revision 1.6  2018/01/15 18:31:08Z  martin
 *  Account for renamed library symbol NSEC_PER_SEC.
 *  Moved function snprint_utc_offs() here.
 *  Changed return type of some printing functions to int.
 *  Revision 1.5  2017/11/16 13:34:09  philipp
 *  Extended ISO printing helper functions
 *  Revision 1.4  2017/11/16 11:33:28  philipp
 *  Added functions to print a time_t to ISO format
 *  Revision 1.3  2017/08/24 13:51:48  martin
 *  Fixed a xcompiler warning under Windows (x64).
 *  Revision 1.2  2017/07/05 07:10:48Z  martin
 *  Added mbg_clock_gettime(), mbg_clock_settime(),
 *  and check_precise_time_api() for Windows.
 *  Revision 1.1  2016/07/15 14:14:19Z  martin
 *  Initial revision
 *
 **************************************************************************/

#define _TIMEUTIL
 #include <timeutil.h>
#undef _TIMEUTIL

#include <mbgtime.h>
#include <str_util.h>

#if defined( MBG_TGT_WIN32 )
  #include <stdio.h>
#endif



/*HDR*/
int snprint_gmtime_error( char *s, size_t max_len, int mbg_errno, time_t t, const char *calling_fnc )
{
  size_t n = snprintf_safe( s, max_len, "gmtime() call failed" );

  if ( calling_fnc )
    n += snprintf_safe( &s[n], max_len - n, " in %s", calling_fnc );

  #if defined( MBG_TGT_MISSING_64_BIT_TYPES )
    //### TODO E.g. in VC6 time_t is only 32 bit anyway.
    n += snprintf_safe( &s[n], max_len - n, " for time_t %lu: %s",
                        (unsigned long) t, mbg_strerror( mbg_errno ) );
  #else
    n += snprintf_safe( &s[n], max_len - n, " for time_t %" PRIu64 ": %s",
                        (uint64_t) t, mbg_strerror( mbg_errno ) );
  #endif

  return _int_from_size_t( n );

}  // snprint_gmtime_error



#if defined( MBG_TGT_WIN32 )

/*HDR*/
int mbg_clock_gettime( clockid_t clock_id, struct timespec *tp )
{
  // FIXME TODO Should we return a POSIX-compatible return code
  // with 0 for success and -1 indicating an error?
  //
  // If we'd do we had to set "errno" or the value returned
  // by Windows' GetLastError() to some specific error code
  // that can be retrieved by the application. However, there's
  // a problem when timespec_get() is used to implement this.

  // On success, timespec_get() returns the value of the "base"
  // parameter that has been passed to timespec_get(), e.g.
  // TIME_UTC. On error, it returns 0, but the usual docs for
  // timespec_get() don't mention if there's a way to determine
  // the reason for the failure, e.g. by retrieving a value
  // from"errno" or so.
  //
  // So for now we return 0 on success as usual, and -1
  // on error, but the caller is unable to determine the
  // reason for the fauilure.

  if ( clock_id == CLOCK_REALTIME )
  {
    #if defined( TIME_UTC )  // C11 / VS2015+
      int rc = timespec_get( tp, TIME_UTC );
      return ( rc == 0 ) ? -1 : 0;
    #else
      FILETIME ft;
      unsigned __int64 tmp;
      gstaft_fnc( &ft );
      tmp = ( (__int64) ft.dwHighDateTime << 32 ) | ft.dwLowDateTime;
      tmp -= FILETIME_1970;   // convert to Unix epoch
      tmp *= 100;         // convert to nanoseconds
      tp->tv_sec = (time_t) ( tmp / NSEC_PER_SEC );
      tp->tv_nsec = (long) ( tmp % NSEC_PER_SEC );
      return 0;
    #endif
  }
  else
    return -1;  // TODO this is e.g. in case of CLOCK_MONOTONIC, we could use QPC then.

}  // mbg_clock_gettime



/*HDR*/
int mbg_clock_settime( clockid_t clock_id, const struct timespec *tp )
{
  if ( clock_id == CLOCK_REALTIME )
  {
    SYSTEMTIME st;
    union
    {
      FILETIME ft;
      ULONGLONG ull;
    } t;

    t.ull = FILETIME_1970 +
      (ULONGLONG) tp->tv_sec * HNS_PER_SEC +
      (ULONGLONG) tp->tv_nsec / 100;

    if ( !FileTimeToSystemTime( &t.ft, &st ) )
      goto fail;  // GetLastError() returns the error code

    if ( !SetSystemTime( &st ) )
      goto fail;  // GetLastError() returns the error code

    return 0;
}

fail:
  return -1;    // TODO this is e.g. in case of CLOCK_MONOTONIC, we could use QPC then.

}  // mbg_clock_settime


bool force_legacy_gstaft;


/*HDR*/
void check_precise_time_api( void )
{
  const char *info ="";
  GSTAFT_FNC tmp_fnc;
  HINSTANCE h = LoadLibrary( "kernel32.dll" );

  if ( h == NULL )   // TODO error msg
  {
    info = "Precise system time may not be supported; failed to get handle for kernel32.dll.";
    goto out;
  }

  tmp_fnc = (GSTAFT_FNC) GetProcAddress( h, "GetSystemTimePreciseAsFileTime" );

  if ( tmp_fnc == NULL )
  {
    info = "Precise system time NOT supported";
    goto out;
  }

  if ( force_legacy_gstaft )
  {
    info = "Precise system time is supported, but legacy function used by request";
    goto out;
  }

  gstaft_fnc = tmp_fnc;
  info = "Precise system time is supported and used";

out:
  printf( "%s\n", info );

}  // check_precise_time_api

#endif



/*HDR*/
int snprint_utc_offs( char *s, size_t max_len, const char *info, long utc_offs )
{
  size_t n = 0;

  // utc_offs is in [s]
  char utc_offs_sign = (char) ( ( utc_offs < 0 ) ? '-' : '+' );
  ulong abs_utc_offs = labs( utc_offs );
  ulong utc_offs_hours = abs_utc_offs / SECS_PER_HOUR;
  ulong tmp = abs_utc_offs % SECS_PER_HOUR;
  ulong utc_offs_mins = tmp / MINS_PER_HOUR;
  ulong utc_offs_secs = tmp % MINS_PER_HOUR;

  if ( info )
    n += snprintf_safe( &s[n], max_len - n, "%s", info );

  n += snprintf_safe( &s[n], max_len - n, "%c%lu", utc_offs_sign, utc_offs_hours );

  if ( utc_offs_mins || utc_offs_secs )
    n += snprintf_safe( &s[n], max_len - n, ":%02lu", utc_offs_mins );

  if ( utc_offs_secs )
    n += snprintf_safe( &s[n], max_len - n, ":%02lu", utc_offs_secs );

  n += sn_cpy_str_safe( &s[n], max_len - n, "h" );

  return _int_from_size_t( n );

}  // snprint_utc_offs



/*HDR*/
int snprint_time_t_to_iso( time_t tstamp, int offs_hours, char *buf, size_t len )
{
  struct tm tm = { 0 };
  size_t n;
  int rc;

  if ( offs_hours )
    tstamp += offs_hours * SECS_PER_HOUR;

  rc = mbg_gmtime( &tm, &tstamp );

  if ( mbg_rc_is_error( rc ) )
  {
    // TODO Error: conversion failed.
  }

  n = snprintf_safe( buf, len, "%04d-%02d-%02d, %02d:%02d:%02d",
                     tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
                     tm.tm_hour, tm.tm_min, tm.tm_sec );

  return _int_from_size_t( n );

}  // snprint_time_t_to_iso



static __mbg_inline /*HDR*/
int __to_iso_frac( time_t tstamp, int offset, time_t frac,
                   const char* fmt, char *buf, size_t max_len )
{
  size_t n = snprint_time_t_to_iso( tstamp, offset, buf, max_len );
  n += snprintf_safe( &buf[n], max_len - n, fmt, frac );

  return _int_from_size_t( n );

}  // __to_iso_frac



/*HDR*/
int snprint_time_t_to_iso_ms( time_t tstamp, int offs_hours, time_t frac,
                              char *buf, size_t len )
{
  tstamp += frac / MSEC_PER_SEC;
  frac %= MSEC_PER_SEC;

  return __to_iso_frac( tstamp, offs_hours, frac, ".%03lu", buf, len );

}  // snprint_time_t_to_iso_ms



/*HDR*/
int snprint_time_t_to_iso_us( time_t tstamp, int offs_hours, time_t frac,
                                char *buf, size_t len )
{
  tstamp += frac / USEC_PER_SEC;
  frac %= USEC_PER_SEC;

  return __to_iso_frac( tstamp, offs_hours, frac, ".%06lu", buf, len );

}  // snprint_time_t_to_iso_us



/*HDR*/
int snprint_time_t_to_iso_ns( time_t tstamp, int offs_hours, time_t frac,
                              char *buf, size_t len )
{
  tstamp += frac / NSEC_PER_SEC;
  frac %= NSEC_PER_SEC;

  return __to_iso_frac( tstamp, offs_hours, frac, ".%09lu", buf, len );

}  // snprint_time_t_to_iso_ns



/*HDR*/
int snprint_ntp_tstamp_to_iso_ms( const NTP_TSTAMP *ts, char *buf, size_t len )
{
  time_t secs = cvt_to_time_t( ts->seconds ) - NTP_SEC_BIAS;
  time_t fracs = bin_frac_32_to_msec( ts->fractions );

  return snprint_time_t_to_iso_ms( secs, 0, fracs, buf, len );

}  // snprint_ntp_tstamp_to_iso_ms



/*HDR*/
int snprint_ntp_tstamp_to_iso_us( const NTP_TSTAMP *ts, char *buf, size_t len )
{
  time_t secs = cvt_to_time_t( ts->seconds ) - NTP_SEC_BIAS;
  time_t fracs = bin_frac_32_to_usec( ts->fractions );

  return snprint_time_t_to_iso_us( secs, 0, fracs, buf, len );

}  // snprint_ntp_tstamp_to_iso_us



/*HDR*/
int snprint_ntp_tstamp_to_iso_ns( const NTP_TSTAMP *ts, char *buf, size_t len )
{
  time_t secs = cvt_to_time_t( ts->seconds ) - NTP_SEC_BIAS;
  time_t fracs = bin_frac_32_to_nsec( ts->fractions );

  return snprint_time_t_to_iso_ns( secs, 0, fracs, buf, len );

}  // snprint_ntp_tstamp_to_iso_ns