open5gs/lib/core/ogs-time.c

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Copyright 2013 MongoDB, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 *  Copyright Beman Dawes 2008
 *  Copyright 2009-2010 Vicente J. Botet Escriba
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *  See http://www.boost.org/LICENSE_1_0.txt
 */

/*
 * Copyright (C) 2019-2020 by Sukchan Lee <acetcom@gmail.com>
 *
 * This file is part of Open5GS.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifdef __APPLE__
#include <mach/clock.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#endif

#include "core-config-private.h"

#include "ogs-core.h"

/*
 * The following code is stolen from mongodb-c-driver
 * https://github.com/mongodb/mongo-c-driver/blob/master/src/libbson/src/bson/bson-clock.c
 */
int ogs_gettimeofday(struct timeval *tv)
{
#if defined(_WIN32)
#if defined(_MSC_VER)
#define DELTA_EPOCH_IN_MICROSEC 11644473600000000Ui64
#else
#define DELTA_EPOCH_IN_MICROSEC 11644473600000000ULL
#endif
    FILETIME ft;
    uint64_t tmp = 0;

    /*
     * The const value is shamelessy stolen from
     * http://www.boost.org/doc/libs/1_55_0/boost/chrono/detail/inlined/win/chrono.hpp
     *
     * File times are the number of 100 nanosecond intervals elapsed since
     * 12:00 am Jan 1, 1601 UTC.  I haven't check the math particularly hard
     *
     * ...  good luck
     */

    if (tv) {
        GetSystemTimeAsFileTime (&ft);

        /* pull out of the filetime into a 64 bit uint */
        tmp |= ft.dwHighDateTime;
        tmp <<= 32;
        tmp |= ft.dwLowDateTime;

        /* convert from 100's of nanosecs to microsecs */
        tmp /= 10;

        /* adjust to unix epoch */
        tmp -= DELTA_EPOCH_IN_MICROSEC;

        tv->tv_sec = (long) (tmp / 1000000UL);
        tv->tv_usec = (long) (tmp % 1000000UL);
    }

    return 0;
#else
    int rc = gettimeofday(tv, NULL);
    ogs_assert(rc == 0);
    return 0;
#endif
}

ogs_time_t ogs_time_now(void)
{
    int rc;
    struct timeval tv;

    rc = ogs_gettimeofday(&tv);
    ogs_assert(rc == 0);

    return ogs_time_from_sec(tv.tv_sec) + tv.tv_usec;
}

/* The following code is stolen from APR library */
int ogs_time_from_lt(ogs_time_t *t, struct tm *tm, int tm_usec)
{
    ogs_time_t year = tm->tm_year;
    ogs_time_t days;
    static const int dayoffset[12] =
    {306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275};

    if (tm->tm_mon < 0 || tm->tm_mon >= 12)
        return OGS_ERROR;

    /* shift new year to 1st March in order to make leap year calc easy */

    if (tm->tm_mon < 2)
        year--;

    /* Find number of days since 1st March 1900 (in the Gregorian calendar). */

    days = year * 365 + year / 4 - year / 100 + (year / 100 + 3) / 4;
    days += dayoffset[tm->tm_mon] + tm->tm_mday - 1;
    days -= 25508;              /* 1 jan 1970 is 25508 days since 1 mar 1900 */
    days = ((days * 24 + tm->tm_hour) * 60 + tm->tm_min) * 60 + tm->tm_sec;

    if (days < 0) {
        return OGS_ERROR;
    }
    *t = days * OGS_USEC_PER_SEC + tm_usec;

    return OGS_OK;
}

int ogs_time_from_gmt(ogs_time_t *t, struct tm *tm, int tm_usec)
{
    int status = ogs_time_from_lt(t, tm, tm_usec);
    if (status == OGS_OK)
        *t -= (ogs_time_t) tm->tm_gmtoff * OGS_USEC_PER_SEC;
    return status;
}

/* RFC 5905 A.1.1, A.4
 * PFCP entity uses NTP timestamp(1900), but Open5GS uses UNIX(1970).
 *
 * One is the offset between the two epochs.
 * Unix uses an epoch located at 1/1/1970-00:00h (UTC) and
 * NTP uses 1/1/1900-00:00h. This leads to an offset equivalent
 * to 70 years in seconds (there are 17 leap years
 * between the two dates so the offset is
 *
 *  (70*365 + 17)*86400 = 2208988800
 *
 * to be substracted from NTP time to get Unix struct timeval.
 */
uint32_t ogs_time_ntp32_now(void)
{
    int rc;
    struct timeval tv;

    rc = ogs_gettimeofday(&tv);
    ogs_assert(rc == 0);

    return ogs_time_to_ntp32(ogs_time_from_sec(tv.tv_sec) + tv.tv_usec);
}
ogs_time_t ogs_time_from_ntp32(uint32_t ntp_timestamp)
{
    if (ntp_timestamp < OGS_1970_1900_SEC_DIFF)
        return 0;
    return ogs_time_from_sec(ntp_timestamp - OGS_1970_1900_SEC_DIFF);
}
uint32_t ogs_time_to_ntp32(ogs_time_t time)
{
    return (time / OGS_USEC_PER_SEC) + OGS_1970_1900_SEC_DIFF;
}

int ogs_timezone(void)
{
#if defined(_WIN32)
    u_long                 n;
    TIME_ZONE_INFORMATION  tz;

    n = GetTimeZoneInformation(&tz);

    switch (n) {
    case TIME_ZONE_ID_UNKNOWN:
        /* Bias = UTC - local time in minutes
         * tm_gmtoff is seconds east of UTC
         */
        return tz.Bias * -60;
    case TIME_ZONE_ID_STANDARD:
        return (tz.Bias + tz.StandardBias) * -60;
    case TIME_ZONE_ID_DAYLIGHT:
        return (tz.Bias + tz.DaylightBias) * -60;
    default:
        ogs_assert_if_reached();
        return 0;
    }
#else
    struct timeval tv;
    struct tm tm;
    int ret;

    ret = ogs_gettimeofday(&tv);
    ogs_assert(ret == 0);

    ogs_localtime(tv.tv_sec, &tm);

    return tm.tm_gmtoff;
#endif
}

ogs_time_t ogs_get_monotonic_time(void)
{
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ogs_time_from_sec(ts.tv_sec) + ts.tv_nsec / 1000UL;
#elif defined(__APPLE__)
    static mach_timebase_info_data_t info = {0};
    static double ratio = 0.0;

    if (!info.denom) {
        /* the value from mach_absolute_time () * info.numer / info.denom
        * is in nano seconds. So we have to divid by 1000.0 to get micro
        * seconds*/
        mach_timebase_info(&info);
        ratio = (double) info.numer / (double) info.denom / 1000.0;
    }

    return mach_absolute_time() * ratio;
#elif defined(_WIN32)
    /* Despite it's name, this is in milliseconds! */
    ogs_time_t ticks = GetTickCount64();
    return (ticks * 1000L);
#elif defined(__hpux__)
    ogs_time_t nanosec = gethrtime();
    return (nanosec / 1000UL);
#else
#warning "Monotonic clock is not yet supported on your platform."
    struct timeval tv;

    ogs_gettimeofday(&tv);
    return ogs_time_from_sec(tv.tv_sec) + tv.tv_usec;
#endif
}

void ogs_localtime(time_t s, struct tm *tm)
{
    ogs_assert(tm);
    memset(tm, 0, sizeof(*tm));

#if (HAVE_LOCALTIME_R)
    (void)localtime_r(&s, tm);
#else
    struct tm *t;

    t = localtime(&s);
    *tm = *t;
#endif
}

void ogs_gmtime(time_t s, struct tm *tm)
{
    ogs_assert(tm);
    memset(tm, 0, sizeof(*tm));

#if (HAVE_LOCALTIME_R)
    (void)gmtime_r(&s, tm);
#else
    struct tm *t;

    t = gmtime(&s);
    *tm = *t;
#endif
}

void ogs_msleep(time_t msec)
{
#if defined(_WIN32)
    Sleep(msec);
#else
    ogs_usleep(msec * 1000);
#endif
}

void ogs_usleep(time_t usec)
{
#if defined(_WIN32)
    Sleep(usec ? (1 + (usec - 1) / 1000) : 0);
#else
    struct timespec req, rem;
    req.tv_sec = usec / OGS_USEC_PER_SEC;
    req.tv_nsec = (usec % OGS_USEC_PER_SEC) * 1000;
    while (nanosleep(&req, &rem) == -1 && errno == EINTR)
        req = rem;
#endif
}