Relicense Sortix to the ISC license.
I hereby relicense all my work on Sortix under the ISC license as below.
All Sortix contributions by other people are already under this license,
are not substantial enough to be copyrightable, or have been removed.
All imported code from other projects is compatible with this license.
All GPL licensed code from other projects had previously been removed.
Copyright 2011-2016 Jonas 'Sortie' Termansen and contributors.
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2016-03-02 22:38:16 +00:00
|
|
|
/*
|
2023-03-26 21:56:15 +00:00
|
|
|
* Copyright (c) 2013, 2023 Jonas 'Sortie' Termansen.
|
Relicense Sortix to the ISC license.
I hereby relicense all my work on Sortix under the ISC license as below.
All Sortix contributions by other people are already under this license,
are not substantial enough to be copyrightable, or have been removed.
All imported code from other projects is compatible with this license.
All GPL licensed code from other projects had previously been removed.
Copyright 2011-2016 Jonas 'Sortie' Termansen and contributors.
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2016-03-02 22:38:16 +00:00
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
*
|
|
|
|
* time/gmtime_r.c
|
|
|
|
* Convert a timestamp into a date and time according to UTC.
|
|
|
|
*/
|
2013-05-15 17:09:37 +00:00
|
|
|
|
2016-02-28 11:11:02 +00:00
|
|
|
#include <stdbool.h>
|
2013-05-15 17:09:37 +00:00
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
#define DAYS_JANUARY 31
|
|
|
|
#define DAYS_FEBRUARY 28
|
|
|
|
#define DAYS_MARCH 31
|
|
|
|
#define DAYS_APRIL 30
|
|
|
|
#define DAYS_MAY 31
|
|
|
|
#define DAYS_JUNE 30
|
|
|
|
#define DAYS_JULY 31
|
|
|
|
#define DAYS_AUGUST 31
|
|
|
|
#define DAYS_SEPTEMBER 30
|
|
|
|
#define DAYS_OCTOBER 31
|
|
|
|
#define DAYS_NOVEMBER 30
|
|
|
|
#define DAYS_DECEMBER 31
|
|
|
|
|
|
|
|
#define UNKNOWN 127
|
2013-05-15 17:09:37 +00:00
|
|
|
|
|
|
|
#define DECL_LEAP_SECOND(year, jun, dec) \
|
|
|
|
{0, 0, 0, 0, 0, jun, 0, 0, 0, 0, 0, dec}
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
static const char leap_seconds[][12] =
|
2013-05-15 17:09:37 +00:00
|
|
|
{
|
|
|
|
DECL_LEAP_SECOND(1970, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1971, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1972, 1, 1),
|
|
|
|
DECL_LEAP_SECOND(1973, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1974, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1975, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1976, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1977, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1978, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1979, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1980, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1981, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1982, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1983, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1984, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1985, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1986, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1987, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1988, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1989, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1990, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1991, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1992, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1993, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1994, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1995, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1996, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(1997, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(1998, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(1999, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2000, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2001, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2002, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2003, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2004, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2005, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(2006, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2007, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2008, 0, 1),
|
|
|
|
DECL_LEAP_SECOND(2009, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2010, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2011, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2012, 1, 0),
|
|
|
|
DECL_LEAP_SECOND(2013, 0, 0),
|
2015-01-05 19:33:43 +00:00
|
|
|
DECL_LEAP_SECOND(2014, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2015, 1, 0),
|
2016-10-30 20:20:00 +00:00
|
|
|
DECL_LEAP_SECOND(2016, 0, 1),
|
2023-03-26 21:56:15 +00:00
|
|
|
DECL_LEAP_SECOND(2017, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2018, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2019, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2020, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2021, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2022, 0, 0),
|
|
|
|
DECL_LEAP_SECOND(2023, 0, UNKNOWN),
|
2013-05-15 17:09:37 +00:00
|
|
|
};
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
static const char month_days_list[12] =
|
|
|
|
{
|
|
|
|
DAYS_JANUARY,
|
|
|
|
DAYS_FEBRUARY,
|
|
|
|
DAYS_MARCH,
|
|
|
|
DAYS_APRIL,
|
|
|
|
DAYS_MAY,
|
|
|
|
DAYS_JUNE,
|
|
|
|
DAYS_JULY,
|
|
|
|
DAYS_AUGUST,
|
|
|
|
DAYS_SEPTEMBER,
|
|
|
|
DAYS_OCTOBER,
|
|
|
|
DAYS_NOVEMBER,
|
|
|
|
DAYS_DECEMBER,
|
|
|
|
};
|
|
|
|
|
|
|
|
static time_t get_leap_second_maybe(int year, int month)
|
2013-05-15 17:09:37 +00:00
|
|
|
{
|
|
|
|
const time_t num_years = sizeof(leap_seconds) / sizeof(leap_seconds[0]);
|
|
|
|
if ( year < 1970 )
|
|
|
|
return 0;
|
|
|
|
if ( num_years <= year-1970 )
|
2023-03-26 21:56:15 +00:00
|
|
|
return UNKNOWN;
|
2013-05-15 17:09:37 +00:00
|
|
|
return leap_seconds[year-1970][month];
|
|
|
|
}
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
static time_t get_leap_second(int year, int month)
|
|
|
|
{
|
|
|
|
time_t result = get_leap_second_maybe(year, month);
|
|
|
|
return result == UNKNOWN ? 0 : result;
|
|
|
|
}
|
|
|
|
|
2013-05-15 17:09:37 +00:00
|
|
|
static time_t leap_seconds_in_year(int year)
|
|
|
|
{
|
|
|
|
time_t ret = 0;
|
|
|
|
for ( int i = 0; i < 12; i++ )
|
|
|
|
ret += get_leap_second(year, i);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool is_leap_year(int year)
|
|
|
|
{
|
|
|
|
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static time_t days_in_year(int year)
|
|
|
|
{
|
|
|
|
return DAYS_JANUARY +
|
|
|
|
DAYS_FEBRUARY + (is_leap_year(year) ? 1 : 0) +
|
|
|
|
DAYS_MARCH +
|
|
|
|
DAYS_APRIL +
|
|
|
|
DAYS_MAY +
|
|
|
|
DAYS_JUNE +
|
|
|
|
DAYS_JULY +
|
|
|
|
DAYS_AUGUST +
|
|
|
|
DAYS_SEPTEMBER +
|
|
|
|
DAYS_OCTOBER +
|
|
|
|
DAYS_NOVEMBER +
|
|
|
|
DAYS_DECEMBER;
|
|
|
|
}
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
static int days_in_month(int year, int month)
|
|
|
|
{
|
|
|
|
return month_days_list[month] + (month == 1 && is_leap_year(year));
|
|
|
|
}
|
|
|
|
|
2016-02-28 11:11:02 +00:00
|
|
|
struct tm* gmtime_r(const time_t* time_ptr, struct tm* ret)
|
2013-05-15 17:09:37 +00:00
|
|
|
{
|
|
|
|
time_t left = *time_ptr;
|
|
|
|
|
|
|
|
ret->tm_year = 1970;
|
|
|
|
ret->tm_wday = 4 /* Supposedly, the world began on a Thursday. */;
|
|
|
|
|
|
|
|
// If the timestamp is after the epoch.
|
|
|
|
while ( 0 < left )
|
|
|
|
{
|
|
|
|
time_t year_leaps = leap_seconds_in_year(ret->tm_year);
|
|
|
|
time_t year_days = days_in_year(ret->tm_year);
|
|
|
|
time_t year_seconds = year_days * 24 * 60 * 60 + year_leaps;
|
|
|
|
if ( year_seconds <= left )
|
|
|
|
{
|
|
|
|
left -= year_seconds;
|
|
|
|
ret->tm_wday = (ret->tm_wday + year_days) % 7;
|
|
|
|
ret->tm_year++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the timestamp was before the epoch.
|
|
|
|
while ( left < 0 )
|
|
|
|
{
|
|
|
|
ret->tm_year--;
|
|
|
|
time_t year_leaps = leap_seconds_in_year(ret->tm_year);
|
|
|
|
time_t year_days = days_in_year(ret->tm_year);
|
|
|
|
time_t year_seconds = year_days * 24 * 60 * 60 + year_leaps;
|
|
|
|
left += year_seconds;
|
|
|
|
// We need to avoid taking the modulo of a negative value or the
|
|
|
|
// (broken) C modulo operator gives the wrong result.
|
|
|
|
ret->tm_wday = (ret->tm_wday - year_days + 7*7*7*7) % 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Figure out the correct month.
|
|
|
|
ret->tm_mon = 0;
|
|
|
|
ret->tm_yday = 0;
|
|
|
|
while ( true )
|
|
|
|
{
|
|
|
|
int month_leaps = get_leap_second(ret->tm_year, ret->tm_mon);
|
2023-03-26 21:56:15 +00:00
|
|
|
int month_days = days_in_month(ret->tm_year, ret->tm_mon);
|
2013-05-15 17:09:37 +00:00
|
|
|
int month_seconds = month_days * 24 * 60 * 60 + month_leaps;
|
|
|
|
if ( month_seconds <= left )
|
|
|
|
{
|
|
|
|
left -= month_seconds;
|
|
|
|
ret->tm_mon++;
|
|
|
|
ret->tm_yday += month_days;
|
|
|
|
ret->tm_wday = (ret->tm_wday + month_days) % 7;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret->tm_mday = left / (24 * 60 * 60);
|
|
|
|
left = left % (24 * 60 * 60);
|
|
|
|
|
|
|
|
// If this is a regular timestamp.
|
2023-03-26 21:56:15 +00:00
|
|
|
if ( ret->tm_mday < days_in_month(ret->tm_year, ret->tm_mon) )
|
2013-05-15 17:09:37 +00:00
|
|
|
{
|
|
|
|
ret->tm_yday += ret->tm_mday;
|
|
|
|
|
|
|
|
ret->tm_hour = left / (60 * 60);
|
|
|
|
left = left % (60 * 60);
|
|
|
|
|
|
|
|
ret->tm_min = left / 60;
|
|
|
|
left = left % 60;
|
|
|
|
|
|
|
|
ret->tm_sec = left;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we got the timestamp for an added leap second.
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret->tm_mday--; // Seemingly additional day.
|
|
|
|
ret->tm_yday += ret->tm_mday;
|
|
|
|
ret->tm_hour = 23;
|
|
|
|
ret->tm_min = 59;
|
|
|
|
ret->tm_sec = 60;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret->tm_wday = (ret->tm_wday + ret->tm_mday) % 7;
|
|
|
|
|
|
|
|
// TODO: Support daylight savings and timezones.
|
|
|
|
ret->tm_isdst = -1;
|
|
|
|
|
|
|
|
// Fix the ranges of some of the variables.
|
|
|
|
ret->tm_mday += 1;
|
|
|
|
ret->tm_year -= 1900;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-03-23 01:41:28 +00:00
|
|
|
|
2016-02-28 11:11:02 +00:00
|
|
|
time_t timegm(struct tm* tm)
|
2013-03-23 01:41:28 +00:00
|
|
|
{
|
|
|
|
time_t year = tm->tm_year + 1900;
|
|
|
|
time_t month = tm->tm_mon;
|
|
|
|
time_t day = tm->tm_mday - 1;
|
|
|
|
time_t hour = tm->tm_hour;
|
|
|
|
time_t minute = tm->tm_min;
|
|
|
|
time_t second = tm->tm_sec;
|
|
|
|
|
|
|
|
time_t ret = 0;
|
|
|
|
for ( time_t y = 1970; y < year; y++ )
|
|
|
|
{
|
|
|
|
time_t year_leaps = leap_seconds_in_year(y);
|
|
|
|
time_t year_days = days_in_year(y);
|
|
|
|
time_t year_seconds = year_days * 24 * 60 * 60 + year_leaps;
|
|
|
|
ret += year_seconds;
|
|
|
|
}
|
|
|
|
|
2023-03-26 21:56:15 +00:00
|
|
|
for ( int m = 0; m < month; m++ )
|
2013-03-23 01:41:28 +00:00
|
|
|
{
|
|
|
|
int month_leaps = get_leap_second(year, m);
|
2023-03-26 21:56:15 +00:00
|
|
|
int month_days = days_in_month(year, m);
|
2013-03-23 01:41:28 +00:00
|
|
|
int month_seconds = month_days * 24 * 60 * 60 + month_leaps;
|
|
|
|
ret += month_seconds;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret += (time_t) day * 24 * 60 * 60;
|
|
|
|
ret += (time_t) hour * 60 * 60;
|
|
|
|
ret += (time_t) minute * 60;
|
|
|
|
ret += (time_t) second * 1;
|
|
|
|
|
2014-08-20 11:32:05 +00:00
|
|
|
gmtime_r(&ret, tm);
|
|
|
|
|
2013-03-23 01:41:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2023-03-26 21:56:15 +00:00
|
|
|
|
|
|
|
int sub_leap_seconds(time_t* ptr)
|
|
|
|
{
|
|
|
|
time_t t = *ptr;
|
|
|
|
time_t next = 0;
|
|
|
|
time_t offset = 0;
|
|
|
|
for ( int year = 1970; true; year++ )
|
|
|
|
{
|
|
|
|
for ( int month = 0; month < 12; month++ )
|
|
|
|
{
|
|
|
|
time_t seconds = days_in_month(year, month) * 24 * 60 * 60;
|
|
|
|
time_t leap = get_leap_second_maybe(year, month);
|
|
|
|
next += seconds;
|
|
|
|
if ( leap == UNKNOWN )
|
|
|
|
{
|
|
|
|
*ptr = t - offset;
|
|
|
|
return t < next - 1 ? 1 : -1;
|
|
|
|
}
|
|
|
|
next += leap;
|
|
|
|
if ( t < next )
|
|
|
|
{
|
|
|
|
*ptr = t - offset;
|
|
|
|
return 0 < leap && t + 1 == next ? 0 : 1;
|
|
|
|
}
|
|
|
|
offset += leap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int add_leap_seconds(time_t* ptr)
|
|
|
|
{
|
|
|
|
time_t t = *ptr;
|
|
|
|
time_t next = 0;
|
|
|
|
time_t offset = 0;
|
|
|
|
for ( int year = 1970; true; year++ )
|
|
|
|
{
|
|
|
|
for ( int month = 0; month < 12; month++ )
|
|
|
|
{
|
|
|
|
time_t seconds = days_in_month(year, month) * 24 * 60 * 60;
|
|
|
|
time_t leap = get_leap_second_maybe(year, month);
|
|
|
|
next += seconds;
|
|
|
|
if ( leap == UNKNOWN )
|
|
|
|
{
|
|
|
|
*ptr = t + offset;
|
|
|
|
return t < next - 1 ? 1 : -1;
|
|
|
|
}
|
|
|
|
if ( t < next )
|
|
|
|
{
|
|
|
|
*ptr = t + offset;
|
|
|
|
return leap < 0 && t + 1 == next ? 0 : 1;
|
|
|
|
}
|
|
|
|
offset += leap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|