#include "asterisk.h"
#include <signal.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <float.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include "private.h"
#include "tzfile.h"
#include "asterisk/_private.h"
#include "asterisk/lock.h"
#include "asterisk/localtime.h"
#include "asterisk/strings.h"
#include "asterisk/linkedlists.h"
#include "asterisk/utils.h"
#include "asterisk/test.h"

Include dependency graph for localtime.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	locale_entry

struct	localelist

struct	lsinfo
	leap second information More...

struct	rule

struct	state

struct	ttinfo
	time type information More...

struct	zonelist

Macros
#define	BIGGEST(a, b) (((a) > (b)) ? (a) : (b))

#define	DAY_OF_YEAR 1 /* n - day of year */

#define	JULIAN_DAY 0 /* Jn - Julian day */

#define	MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */

#define	MY_TZNAME_MAX 255

#define	OPEN_MODE O_RDONLY

#define	SP_HEAP_FREE(sp) do {} while (0)

#define	SP_HEAP_INIT(sp)

#define	SP_STACK_CHECK(sp) ((sp)->wd[0] == SP_STACK_FLAG)

#define	SP_STACK_FLAG INT_MIN

#define	SP_STACK_INIT(sp)

#define	TZ_ABBR_CHAR_SET "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"

#define	TZ_ABBR_ERR_CHAR '_'

#define	TZ_ABBR_MAX_LEN 16

#define	TZ_STRLEN_MAX 255

#define	TZDEFRULESTRING ",M4.1.0,M10.5.0"

Functions
static void	add_notify (struct state sp, const char path)

void	ast_get_dst_info (const time_t const timep, int dst_enabled, time_t dst_start, time_t dst_end, int gmt_off, const char const zone)

struct ast_tm *	ast_localtime (const struct timeval timep, struct ast_tm tmp, const char *zone)
	Timezone-independent version of localtime_r(3). More...

void	ast_localtime_wakeup_monitor (struct ast_test *info)

struct timeval	ast_mktime (struct ast_tm tmp, const char zone)
	Timezone-independent version of mktime(3). More...

const char *	ast_setlocale (const char *locale)
	Set the thread-local representation of the current locale. More...

int	ast_strftime (char buf, size_t len, const char tmp, const struct ast_tm *tm)
	Special version of strftime(3) that handles fractions of a second. Takes the same arguments as strftime(3), with the addition of q, which specifies microseconds. More...

int	ast_strftime_locale (char buf, size_t len, const char tmp, const struct ast_tm tm, const char locale)

char *	ast_strptime (const char s, const char format, struct ast_tm *tm)
	Special version of strptime(3) which places the answer in the common structure ast_tm. Also, unlike strptime(3), ast_strptime() initializes its memory prior to use. More...

char *	ast_strptime_locale (const char s, const char format, struct ast_tm tm, const char locale)

static const struct state *	ast_tzset (const char *zone)

void	clean_time_zones (void)

static void	common_startup (void)

static long	detzcode (const char *const codep)

static time_t	detzcode64 (const char *const codep)

static int	differ_by_repeat (const time_t t1, const time_t t0)

static struct locale_entry *	find_by_locale (locale_t locale)

static struct locale_entry *	find_by_name (const char *name)

static const char *	getnum (const char strp, int nump, const int min, const int max)
	Given a pointer into a time zone string, extract a number from that string. Check that the number is within a specified range; if it is not, return NULL. Otherwise, return a pointer to the first character not part of the number. More...

static const char *	getoffset (const char strp, long offsetp)
	Given a pointer into a time zone string, extract an offset, in [+-]hh[:mm[:ss]] form, from the string. If any error occurs, return NULL. Otherwise, return a pointer to the first character not part of the time. More...

static const char *	getqzname (const char *strp, const int delim)
	Given a pointer into an extended time zone string, scan until the ending delimiter of the zone name is located. Return a pointer to the delimiter. More...

static const char *	getrule (const char strp, struct rule rulep)
	Given a pointer into a time zone string, extract a rule in the form date[/time]. See POSIX section 8 for the format of "date" and "time". If a valid rule is not found, return NULL. Otherwise, return a pointer to the first character not part of the rule. More...

static const char *	getsecs (const char strp, long const secsp)
	Given a pointer into a time zone string, extract a number of seconds, in hh[:mm[:ss]] form, from the string. If any error occurs, return NULL. Otherwise, return a pointer to the first character not part of the number of seconds. More...

static const char *	getzname (const char *strp)
	Given a pointer into a time zone string, scan until a character that is not a valid character in a zone name is found. Return a pointer to that character. More...

static int	gmtload (struct state *sp)

static struct ast_tm *	gmtsub (const struct timeval timep, const long offset, struct ast_tm tmp)

static int	increment_overflow (int *number, int delta)
	Simplified normalize logic courtesy Paul Eggert. More...

static void *	inotify_daemon (void *data)

static int	leaps_thru_end_of (const int y)
	Return the number of leap years through the end of the given year where, to make the math easy, the answer for year zero is defined as zero. More...

static struct ast_tm *	localsub (const struct timeval timep, const long offset, struct ast_tm tmp, const struct state *sp)

static int	long_increment_overflow (long *number, int delta)

static int	long_normalize_overflow (long tensptr, int unitsptr, const int base)

static int	normalize_overflow (int tensptr, int unitsptr, const int base)

static long detzcode	P ((const char *codep))

static int tzload	P ((const char name, struct state sp, int doextend))

static int tzparse	P ((const char name, struct state sp, int lastditch))

static const char *getzname	P ((const char *strp))

static const char *getqzname	P ((const char *strp, const int delim))

static const char *getnum	P ((const char strp, int nump, int min, int max))

static const char *getoffset	P ((const char strp, long offsetp))

static const char *getsecs	P ((const char strp, long secsp))

static const char *getrule	P ((const char strp, struct rule rulep))

static int tmcomp	P ((const struct ast_tm atmp, const struct ast_tm btmp))

static struct ast_tm *timesub	P ((const struct timeval timep, long offset, const struct state sp, struct ast_tm *tmp))

static struct ast_tm *gmtsub	P ((const struct timeval timep, long offset, struct ast_tm tmp))

static struct ast_tm *localsub	P ((const struct timeval timep, long offset, struct ast_tm tmp, const struct state *sp))

static int increment_overflow	P ((int *number, int delta))

static int normalize_overflow	P ((int tensptr, int unitsptr, const int base))

static int leaps_thru_end_of	P ((int y))

static int long_increment_overflow	P ((long *number, int delta))

static int long_normalize_overflow	P ((long tensptr, int unitsptr, const int base))

static struct timeval time1	P ((struct ast_tm tmp, struct ast_tm (funcp) P((const struct timeval , long, struct ast_tm , const struct state sp)), long offset, const struct state *sp))

static struct timeval time2	P ((struct ast_tm tmp, struct ast_tm (funcp) P((const struct timeval , long, struct ast_tm , const struct state sp)), long offset, int okayp, const struct state sp))

static struct timeval time2sub	P ((struct ast_tm tmp, struct ast_tm (funcp)(const struct timeval , long, struct ast_tm , const struct state sp), long offset, int okayp, int do_norm_secs, const struct state sp))

static int gmtload	P ((struct state *sp))

static time_t transtime	P ((time_t janfirst, int year, const struct rule *rulep, long offset))

static int differ_by_repeat	P ((time_t t1, time_t t0))

static struct state *	sstate_alloc (void)

static void	sstate_free (struct state *p)

static const char *	store_by_locale (locale_t prevlocale)

static struct timeval	time1 (struct ast_tm tmp, struct ast_tm (const funcp)(const struct timeval , long, struct ast_tm , const struct state ), const long offset, const struct state *sp)

static struct timeval	time2 (struct ast_tm tmp, struct ast_tm (const funcp)(const struct timeval , long, struct ast_tm , const struct state sp), const long offset, int okayp, const struct state sp)

static struct timeval	time2sub (struct ast_tm tmp, struct ast_tm (const funcp)(const struct timeval , long, struct ast_tm , const struct state ), const long offset, int okayp, const int do_norm_secs, const struct state sp)

static struct ast_tm *	timesub (const struct timeval timep, const long offset, const struct state sp, struct ast_tm *tmp)

static int	tmcomp (const struct ast_tm atmp, const struct ast_tm btmp)

static time_t	transtime (const time_t janfirst, const int year, const struct rule *rulep, const long offset)
	Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the year, a rule, and the offset from UTC at the time that rule takes effect, calculate the Epoch-relative time that rule takes effect. More...

static int	tzload (const char name, struct state const sp, const int doextend)

static int	tzparse (const char name, struct state sp, const int lastditch)

Variables
static char	elsieid [] = "@(#)localtime.c 8.5"

static const char	gmt [] = "GMT"

static ast_cond_t	initialization

static ast_mutex_t	initialization_lock

static int	inotify_fd = -1

static pthread_t	inotify_thread = AST_PTHREADT_NULL

static struct localelist	localelist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static const int	mon_lengths [2][MONSPERYEAR]

static const struct timeval	WRONG = { 0, 0 }

static const int	year_lengths [2]

static struct zonelist	zonelist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

Detailed Description

Multi-timezone Localtime code

The original source from this file may be obtained from ftp://elsie.nci.nih.gov/pub/

Definition in file localtime.c.

Macro Definition Documentation

◆ BIGGEST

#define BIGGEST	(	a,
		b
	)	(((a) > (b)) ? (a) : (b))

Definition at line 146 of file localtime.c.

◆ DAY_OF_YEAR

#define DAY_OF_YEAR 1 /* n - day of year */

Definition at line 257 of file localtime.c.

◆ JULIAN_DAY

#define JULIAN_DAY 0 /* Jn - Julian day */

Definition at line 256 of file localtime.c.

◆ MONTH_NTH_DAY_OF_WEEK

#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */

Definition at line 258 of file localtime.c.

◆ MY_TZNAME_MAX

#define MY_TZNAME_MAX 255

Definition at line 152 of file localtime.c.

◆ OPEN_MODE

#define OPEN_MODE O_RDONLY

Definition at line 107 of file localtime.c.

◆ SP_HEAP_FREE

#define SP_HEAP_FREE ( sp ) do {} while (0)

Definition at line 199 of file localtime.c.

◆ SP_HEAP_INIT

#define SP_HEAP_INIT ( sp )

Value:

        do { \
        (sp)->wd[0] = -1; \
        (sp)->wd[1] = -1; \
    } while (0)

Definition at line 195 of file localtime.c.

◆ SP_STACK_CHECK

#define SP_STACK_CHECK ( sp ) ((sp)->wd[0] == SP_STACK_FLAG)

Definition at line 194 of file localtime.c.

◆ SP_STACK_FLAG

#define SP_STACK_FLAG INT_MIN

Definition at line 189 of file localtime.c.

◆ SP_STACK_INIT

#define SP_STACK_INIT ( sp )

Value:

        do { \
        (sp).wd[0] = SP_STACK_FLAG; \
    } while (0)

Definition at line 191 of file localtime.c.

◆ TZ_ABBR_CHAR_SET

#define TZ_ABBR_CHAR_SET "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"

Definition at line 91 of file localtime.c.

◆ TZ_ABBR_ERR_CHAR

#define TZ_ABBR_ERR_CHAR '_'

Definition at line 96 of file localtime.c.

◆ TZ_ABBR_MAX_LEN

#define TZ_ABBR_MAX_LEN 16

Definition at line 87 of file localtime.c.

◆ TZ_STRLEN_MAX

#define TZ_STRLEN_MAX 255

Definition at line 155 of file localtime.c.

◆ TZDEFRULESTRING

#define TZDEFRULESTRING ",M4.1.0,M10.5.0"

Note: The DST rules to use if TZ has no rules and we can't load TZDEFRULES. We default to US rules as of 1999-08-17. POSIX 1003.1 section 8.1.1 says that the default DST rules are implementation dependent; for historical reasons, US rules are a common default.

Definition at line 128 of file localtime.c.

Function Documentation

◆ add_notify()

static void add_notify	(	struct state *	sp,
		const char *	path
	)

static

Definition at line 411 of file localtime.c.

{
    /* watch for flag indicating stack automatic sp,
     * should not be added to watch
     */
    if (SP_STACK_CHECK(sp)) {
        return;
    }
 
    if (inotify_thread == AST_PTHREADT_NULL) {
        ast_cond_init(&initialization, NULL);
        ast_mutex_init(&initialization_lock);
        ast_mutex_lock(&initialization_lock);
        if (!(ast_pthread_create_background(&inotify_thread, NULL, inotify_daemon, NULL))) {
            /* Give the thread a chance to initialize */
            ast_cond_wait(&initialization, &initialization_lock);
        } else {
            fprintf(stderr, "Unable to start notification thread\n");
            ast_mutex_unlock(&initialization_lock);
            return;
        }
        ast_mutex_unlock(&initialization_lock);
    }
 
    if (inotify_fd > -1) {
        char fullpath[FILENAME_MAX + 1] = "";
        if (readlink(path, fullpath, sizeof(fullpath) - 1) != -1) {
            /* If file the symlink points to changes */
            sp->wd[1] = inotify_add_watch(inotify_fd, fullpath, IN_ATTRIB | IN_DELETE_SELF | IN_MODIFY | IN_MOVE_SELF | IN_CLOSE_WRITE );
        } else {
            sp->wd[1] = -1;
        }
        /* or if the symlink itself changes (or the real file is here, if path is not a symlink) */
        sp->wd[0] = inotify_add_watch(inotify_fd, path, IN_ATTRIB | IN_DELETE_SELF | IN_MODIFY | IN_MOVE_SELF | IN_CLOSE_WRITE
#ifdef IN_DONT_FOLLOW   /* Only defined in glibc 2.5 and above */
            | IN_DONT_FOLLOW
#endif
        );
    }
}

References ast_cond_init, ast_cond_wait, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_background, AST_PTHREADT_NULL, FILENAME_MAX, initialization, initialization_lock, inotify_daemon(), inotify_fd, inotify_thread, NULL, SP_STACK_CHECK, and state::wd.

Referenced by common_startup(), and tzload().

◆ ast_get_dst_info()

void ast_get_dst_info	(	const time_t *const	timep,
		int *	dst_enabled,
		time_t *	dst_start,
		time_t *	dst_end,
		int *	gmt_off,
		const char *const	zone
	)

Definition at line 1754 of file localtime.c.

{
    int i;
    int transition1 = -1;
    int transition2 = -1;
    time_t      seconds;
    int  bounds_exceeded = 0;
    time_t  t = *timep;
    const struct state *sp;
 
    if (NULL == dst_enabled)
        return;
    *dst_enabled = 0;
 
    if (NULL == dst_start || NULL == dst_end || NULL == gmt_off)
        return;
 
    *gmt_off = 0;
 
    sp = ast_tzset(zone);
    if (NULL == sp)
        return;
 
    /* If the desired time exceeds the bounds of the defined time transitions
    * then give up on determining DST info and simply look for gmt offset
    * This requires that I adjust the given time using increments of Gregorian
    * repeats to place the time within the defined time transitions in the
    * timezone structure.
    */
    if ((sp->goback && t < sp->ats[0]) ||
            (sp->goahead && t > sp->ats[sp->timecnt - 1])) {
        time_t      tcycles;
        int_fast64_t    icycles;
 
        if (t < sp->ats[0])
            seconds = sp->ats[0] - t;
        else    seconds = t - sp->ats[sp->timecnt - 1];
        --seconds;
        tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
        ++tcycles;
        icycles = tcycles;
        if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
            return;
        seconds = icycles;
        seconds *= YEARSPERREPEAT;
        seconds *= AVGSECSPERYEAR;
        if (t < sp->ats[0])
            t += seconds;
        else
            t -= seconds;
 
        if (t < sp->ats[0] || t > sp->ats[sp->timecnt - 1])
            return; /* "cannot happen" */
 
        bounds_exceeded = 1;
    }
 
    if (sp->timecnt == 0 || t < sp->ats[0]) {
        /* I have no transition times or I'm before time */
        *dst_enabled = 0;
        /* Find where I can get gmtoff */
        i = 0;
        while (sp->ttis[i].tt_isdst) {
            if (++i >= sp->typecnt) {
                i = 0;
                break;
            }
        }
        *gmt_off = sp->ttis[i].tt_gmtoff;
        return;
    }
 
    for (i = 1; i < sp->timecnt; ++i) {
        if (t < sp->ats[i]) {
            transition1 = sp->types[i - 1];
            transition2 = sp->types[i];
            break;
        }
    }
    /* if I found transition times that do not bounded the given time and these correspond to
        or the bounding zones do not reflect a changes in day light savings, then I do not have dst active */
    if (i >= sp->timecnt || 0 > transition1 || 0 > transition2 ||
            (sp->ttis[transition1].tt_isdst == sp->ttis[transition2].tt_isdst)) {
        *dst_enabled = 0;
        *gmt_off = sp->ttis[sp->types[sp->timecnt -1]].tt_gmtoff;
    } else {
        /* I have valid daylight savings information. */
        if(sp->ttis[transition2].tt_isdst)
            *gmt_off = sp->ttis[transition1].tt_gmtoff;
        else
            *gmt_off = sp->ttis[transition2].tt_gmtoff;
 
        /* If I adjusted the time earlier, indicate that the dst is invalid */
        if (!bounds_exceeded) {
            *dst_enabled = 1;
            /* Determine which of the bounds is the start of daylight savings and which is the end */
            if(sp->ttis[transition2].tt_isdst) {
                *dst_start = sp->ats[i];
                *dst_end = sp->ats[i -1];
            } else {
                *dst_start = sp->ats[i -1];
                *dst_end = sp->ats[i];
            }
        }
    }
    return;
}

References ast_tzset(), state::ats, AVGSECSPERYEAR, state::goahead, state::goback, int_fast64_t, NULL, state::timecnt, ttinfo::tt_gmtoff, ttinfo::tt_isdst, state::ttis, state::typecnt, state::types, and YEARSPERREPEAT.

Referenced by set_timezone_variables().

◆ ast_localtime()

struct ast_tm * ast_localtime	(	const struct timeval *	timep,
		struct ast_tm *	p_tm,
		const char *	zone
	)

Timezone-independent version of localtime_r(3).

Parameters

timep	Current time, including microseconds
p_tm	Pointer to memory where the broken-out time will be stored
zone	Text string of a standard system zoneinfo file. If NULL, the system localtime will be used.

Return values

p_tm	is returned for convenience

Definition at line 1739 of file localtime.c.

{
    const struct state *sp = ast_tzset(zone);
    memset(tmp, 0, sizeof(*tmp));
    return sp ? localsub(timep, 0L, tmp, sp) : NULL;
}

References ast_tzset(), localsub(), NULL, and tmp().

◆ ast_localtime_wakeup_monitor()

void ast_localtime_wakeup_monitor ( struct ast_test * info )

Definition at line 795 of file localtime.c.

{
    struct timeval wait_now = ast_tvnow();
    struct timespec wait_time = { .tv_sec = wait_now.tv_sec + 2, .tv_nsec = wait_now.tv_usec * 1000 };
 
    if (inotify_thread != AST_PTHREADT_NULL) {
        AST_LIST_LOCK(&zonelist);
#ifdef TEST_FRAMEWORK
        test = info;
#endif
        pthread_kill(inotify_thread, SIGURG);
        ast_cond_timedwait(&initialization, &(&zonelist)->lock, &wait_time);
#ifdef TEST_FRAMEWORK
        test = NULL;
#endif
        AST_LIST_UNLOCK(&zonelist);
    }
}

References ast_cond_timedwait, AST_LIST_LOCK, AST_LIST_UNLOCK, AST_PTHREADT_NULL, ast_tvnow(), sip_to_pjsip::info(), initialization, inotify_thread, lock, and NULL.

Referenced by AST_TEST_DEFINE().

◆ ast_mktime()

struct timeval ast_mktime	(	struct ast_tm *const	tmp,
		const char *	zone
	)

Timezone-independent version of mktime(3).

Parameters

tmp	Current broken-out time, including microseconds
zone	Text string of a standard system zoneinfo file. If NULL, the system localtime will be used.

Return values

A	structure containing both seconds and fractional thereof since January 1st, 1970 UTC

Definition at line 2357 of file localtime.c.

{
    const struct state *sp;
    if (!(sp = ast_tzset(zone)))
        return WRONG;
    return time1(tmp, localsub, 0L, sp);
}

References ast_tzset(), localsub(), time1(), tmp(), and WRONG.

Referenced by acf_strptime(), add_cert_expiration_to_astdb(), check_date_header(), conf_run(), find_conf_realtime(), icalfloat_to_timet(), mstime_to_time_t(), rt_extend_conf(), sms_handleincoming_proto2(), sms_readfile(), testtime_write(), and unpackdate().

◆ ast_setlocale()

const char * ast_setlocale ( const char * locale )

Set the thread-local representation of the current locale.

Definition at line 2420 of file localtime.c.

{
    struct locale_entry *cur;
    locale_t prevlocale = LC_GLOBAL_LOCALE;
 
    if (locale == NULL) {
        return store_by_locale(uselocale(LC_GLOBAL_LOCALE));
    }
 
    AST_LIST_LOCK(&localelist);
    if ((cur = find_by_name(locale))) {
        prevlocale = uselocale(cur->locale);
    }
 
    if (!cur) {
        if ((cur = ast_calloc(1, sizeof(*cur) + strlen(locale) + 1))) {
            cur->locale = newlocale(LC_ALL_MASK, locale, NULL);
            strcpy(cur->name, locale); /* SAFE */
            AST_LIST_INSERT_TAIL(&localelist, cur, list);
            prevlocale = uselocale(cur->locale);
        }
    }
    AST_LIST_UNLOCK(&localelist);
    return store_by_locale(prevlocale);
}

References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, find_by_name(), locale_entry::list, locale, locale_entry::locale, locale_entry::name, NULL, and store_by_locale().

Referenced by ast_strftime_locale(), ast_strptime_locale(), and handle_cli_test_locales().

◆ ast_strftime()

int ast_strftime	(	char *	buf,
		size_t	len,
		const char *	format,
		const struct ast_tm *	tm
	)

Special version of strftime(3) that handles fractions of a second. Takes the same arguments as strftime(3), with the addition of q, which specifies microseconds.

Parameters

buf	Address in memory where the resulting string will be stored.
len	Size of the chunk of memory buf.
format	A string specifying the format of time to be placed into buf.
tm	Pointer to the broken out time to be used for the format.

Return values

An	integer value specifying the number of bytes placed into buf or -1 on error.

Definition at line 2524 of file localtime.c.

{
    return ast_strftime_locale(buf, len, tmp, tm, NULL);
}

References ast_strftime_locale(), buf, len(), NULL, and tmp().

Referenced by acf_strftime(), action_corestatus(), append_date(), ast_cel_fabricate_channel_from_event(), ast_http_send(), ast_json_timeval(), ast_queue_log(), beanstalk_put(), build_radius_record(), cdr_get_tv(), cdr_read_callback(), cel_bs_put(), cli_prompt(), cli_show_tasks(), conf_run(), dump_datetime(), epoch_to_string(), exchangecal_get_events_between(), execute_cb(), find_conf_realtime(), format_log_message_ap(), get_date(), get_ewscal_ids_for(), handle_cli_odbc_show(), handle_cli_test_locales(), handle_minivm_show_stats(), handle_show_settings(), http_callback(), isodate(), leave_voicemail(), make_email_file(), make_logchannel(), manager_log(), mstime(), odbc_log(), pgsql_log(), prometheus_show_status(), rt_extend_conf(), sendmail(), sendpage(), set_header(), static_callback(), timeout_write(), and write_metadata().

◆ ast_strftime_locale()

int ast_strftime_locale	(	char *	buf,
		size_t	len,
		const char *	tmp,
		const struct ast_tm *	tm,
		const char *	locale
	)

Definition at line 2452 of file localtime.c.

{
    size_t fmtlen = strlen(tmp) + 1;
    char *format = ast_calloc(1, fmtlen), *fptr = format, *newfmt;
    int decimals = -1, i, res;
    long fraction;
    const char *prevlocale;
 
    buf[0] = '\0';/* Ensure the buffer is initialized. */
    if (!format) {
        return -1;
    }
    for (; *tmp; tmp++) {
        if (*tmp == '%') {
            switch (tmp[1]) {
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
                if (tmp[2] != 'q') {
                    goto defcase;
                }
                decimals = tmp[1] - '0';
                tmp++;
                /* Fall through */
            case 'q': /* Milliseconds */
                if (decimals == -1) {
                    decimals = 3;
                }
 
                /* Juggle some memory to fit the item */
                newfmt = ast_realloc(format, fmtlen + decimals);
                if (!newfmt) {
                    ast_free(format);
                    return -1;
                }
                fptr = fptr - format + newfmt;
                format = newfmt;
                fmtlen += decimals;
 
                /* Reduce the fraction of time to the accuracy needed */
                for (i = 6, fraction = tm->tm_usec; i > decimals; i--) {
                    fraction /= 10;
                }
                fptr += sprintf(fptr, "%0*ld", decimals, fraction);
 
                /* Reset, in case more than one 'q' specifier exists */
                decimals = -1;
                tmp++;
                break;
            default:
                goto defcase;
            }
        } else {
defcase:    *fptr++ = *tmp;
        }
    }
    *fptr = '\0';
#undef strftime
    if (locale) {
        prevlocale = ast_setlocale(locale);
    }
    res = (int)strftime(buf, len, format, (struct tm *)tm);
    if (locale) {
        ast_setlocale(prevlocale);
    }
    ast_free(format);
    return res;
}

References ast_calloc, ast_free, ast_realloc, ast_setlocale(), buf, len(), locale, ast_tm::tm_usec, and tmp().

Referenced by ast_strftime(), make_email_file(), prep_email_sub_vars(), and sendpage().

◆ ast_strptime()

char * ast_strptime	(	const char *	s,
		const char *	format,
		struct ast_tm *	tm
	)

Special version of strptime(3) which places the answer in the common structure ast_tm. Also, unlike strptime(3), ast_strptime() initializes its memory prior to use.

Parameters

s	A string specifying some portion of a date and time.
format	The format in which the string, s, is expected.
tm	The broken-out time structure into which the parsed data is expected.

Return values

A	pointer to the first character within s not used to parse the date and time.

Definition at line 2550 of file localtime.c.

{
    return ast_strptime_locale(s, format, tm, NULL);
}

References ast_strptime_locale(), and NULL.

Referenced by acf_strptime(), add_cert_expiration_to_astdb(), check_date_header(), conf_run(), find_conf_realtime(), mstime_to_time_t(), rt_extend_conf(), and testtime_write().

◆ ast_strptime_locale()

char * ast_strptime_locale	(	const char *	s,
		const char *	format,
		struct ast_tm *	tm,
		const char *	locale
	)

Definition at line 2529 of file localtime.c.

{
    struct tm tm2 = { 0, };
    char *res;
    const char *prevlocale;
 
    prevlocale = ast_setlocale(locale);
    res = strptime(s, format, &tm2);
    ast_setlocale(prevlocale);
    /* ast_time and tm are not the same size - tm is a subset of
     * ast_time.  Hence, the size of tm needs to be used for the
     * memcpy
     */
    memcpy(tm, &tm2, sizeof(tm2));
    tm->tm_usec = 0;
    /* strptime(3) doesn't set .tm_isdst correctly, so to force ast_mktime(3)
     * to deal with it correctly, we set it to -1. */
    tm->tm_isdst = -1;
    return res;
}

References ast_setlocale(), locale, ast_tm::tm_isdst, and ast_tm::tm_usec.

Referenced by ast_strptime().

◆ ast_tzset()

static const struct state * ast_tzset ( const char * zone )

static

Definition at line 1601 of file localtime.c.

{
    struct state *sp;
 
    if (ast_strlen_zero(zone)) {
#ifdef SOLARIS
        zone = getenv("TZ");
        if (ast_strlen_zero(zone)) {
            zone = "GMT";
        }
#else
        zone = "/etc/localtime";
#endif
    }
 
    AST_LIST_LOCK(&zonelist);
    AST_LIST_TRAVERSE(&zonelist, sp, list) {
        if (!strcmp(sp->name, zone)) {
            AST_LIST_UNLOCK(&zonelist);
            return sp;
        }
    }
 
    if (!(sp = sstate_alloc())) {
        AST_LIST_UNLOCK(&zonelist);
        return NULL;
    }
 
    if (tzload(zone, sp, TRUE) != 0) {
        if (zone[0] == ':' || tzparse(zone, sp, FALSE) != 0)
            (void) gmtload(sp);
    }
    ast_copy_string(sp->name, zone, sizeof(sp->name));
    AST_LIST_INSERT_TAIL(&zonelist, sp, list);
    AST_LIST_UNLOCK(&zonelist);
    return sp;
}

References ast_copy_string(), AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), FALSE, gmtload(), state::list, state::name, NULL, sstate_alloc(), TRUE, tzload(), and tzparse().

Referenced by ast_get_dst_info(), ast_localtime(), and ast_mktime().

◆ clean_time_zones()

void clean_time_zones ( void )

Provided by localtime.c

Definition at line 1590 of file localtime.c.

{
    struct state *sp;
 
    AST_LIST_LOCK(&zonelist);
    while ((sp = AST_LIST_REMOVE_HEAD(&zonelist, list))) {
        sstate_free(sp);
    }
    AST_LIST_UNLOCK(&zonelist);
}

References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, state::list, and sstate_free().

Referenced by really_quit().

◆ common_startup()

static void common_startup ( void )

static

Start a notification for every entry already in the list.

Definition at line 328 of file localtime.c.

                                 {
    struct state *sp;
    AST_LIST_LOCK(&zonelist);
    AST_LIST_TRAVERSE(&zonelist, sp, list) {
        /* ensure sp->name is not relative -- it
         * often is -- otherwise add_notify() fails
         */
        char name[FILENAME_MAX + 1];
 
        if (sp->name[0] == '/') {
            snprintf(name, sizeof(name), "%s", sp->name);
        } else if (!strcmp(sp->name, TZDEFAULT)) {
            snprintf(name, sizeof(name), "/etc/%s", sp->name);
        } else {
            snprintf(name, sizeof(name), "%s/%s", TZDIR, sp->name);
        }
 
        add_notify(sp, name);
    }
    AST_LIST_UNLOCK(&zonelist);
}

References add_notify(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, FILENAME_MAX, state::list, name, state::name, TZDEFAULT, and TZDIR.

Referenced by inotify_daemon().

◆ detzcode()

static long detzcode ( const char *const codep )

static

Note: Section 4.12.3 of X3.159-1989 requires that Except for the strftime function, these functions [asctime, ctime, gmtime, localtime] return values in one of two static objects: a broken-down time structure and an array of char. Thanks to Paul Eggert for noting this.

Definition at line 822 of file localtime.c.

{
    long    result;
    int i;
 
    result = (codep[0] & 0x80) ? ~0L : 0;
    for (i = 0; i < 4; ++i)
        result = (result << 8) | (codep[i] & 0xff);
    return result;
}

References result.

Referenced by tzload().

◆ detzcode64()

static time_t detzcode64 ( const char *const codep )

static

Definition at line 833 of file localtime.c.

{
    time_t  result;
    int i;
 
    result = (codep[0] & 0x80) ?  (~(int_fast64_t) 0) : 0;
    for (i = 0; i < 8; ++i)
        result = result * 256 + (codep[i] & 0xff);
    return result;
}

References int_fast64_t, and result.

Referenced by tzload().

◆ differ_by_repeat()

static int differ_by_repeat	(	const time_t	t1,
		const time_t	t0
	)

static

Definition at line 844 of file localtime.c.

{
    const long long at1 = t1, at0 = t0;
    if (TYPE_INTEGRAL(time_t) &&
        TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS)
            return 0;
    return at1 - at0 == SECSPERREPEAT;
}

References SECSPERREPEAT, SECSPERREPEAT_BITS, TYPE_BIT, TYPE_INTEGRAL, and TYPE_SIGNED.

Referenced by tzload().

◆ find_by_locale()

static struct locale_entry * find_by_locale ( locale_t locale )

static

Definition at line 2366 of file localtime.c.

{
    struct locale_entry *cur;
    AST_LIST_TRAVERSE(&localelist, cur, list) {
        if (locale == cur->locale) {
            return cur;
        }
    }
    return NULL;
}

References AST_LIST_TRAVERSE, locale_entry::list, locale, locale_entry::locale, and NULL.

Referenced by store_by_locale().

◆ find_by_name()

static struct locale_entry * find_by_name ( const char * name )

static

Definition at line 2377 of file localtime.c.

{
    struct locale_entry *cur;
    AST_LIST_TRAVERSE(&localelist, cur, list) {
        if (strcmp(name, cur->name) == 0) {
            return cur;
        }
    }
    return NULL;
}

References AST_LIST_TRAVERSE, locale_entry::list, locale_entry::name, name, and NULL.

Referenced by ast_setlocale(), and store_by_locale().

◆ getnum()

static const char * getnum	(	const char *	strp,
		int *	nump,
		const int	min,
		const int	max
	)

static

Given a pointer into a time zone string, extract a number from that string. Check that the number is within a specified range; if it is not, return NULL. Otherwise, return a pointer to the first character not part of the number.

Definition at line 1153 of file localtime.c.

{
    char    c;
    int num;
 
    if (strp == NULL || !is_digit(c = *strp))
        return NULL;
    num = 0;
    do {
        num = num * 10 + (c - '0');
        if (num > max)
            return NULL;    /* illegal value */
        c = *++strp;
    } while (is_digit(c));
    if (num < min)
        return NULL;        /* illegal value */
    *nump = num;
    return strp;
}

References c, is_digit, max, min, and NULL.

Referenced by getrule(), and getsecs().

◆ getoffset()

static const char * getoffset	(	const char *	strp,
		long *	offsetp
	)

static

Given a pointer into a time zone string, extract an offset, in [+-]hh[:mm[:ss]] form, from the string. If any error occurs, return NULL. Otherwise, return a pointer to the first character not part of the time.

Definition at line 1220 of file localtime.c.

{
    int neg = 0;
 
    if (*strp == '-') {
        neg = 1;
        ++strp;
    } else if (*strp == '+')
        ++strp;
    strp = getsecs(strp, offsetp);
    if (strp == NULL)
        return NULL;        /* illegal time */
    if (neg)
        *offsetp = -*offsetp;
    return strp;
}

References getsecs(), and NULL.

Referenced by tzparse().

◆ getqzname()

static const char * getqzname	(	const char *	strp,
		const int	delim
	)

static

Given a pointer into an extended time zone string, scan until the ending delimiter of the zone name is located. Return a pointer to the delimiter.

As with getzname above, the legal character set is actually quite restricted, with other characters producing undefined results. We don't do any checking here; checking is done later in common-case code.

Definition at line 1137 of file localtime.c.

{
    int c;
 
    while ((c = *strp) != '\0' && c != delim)
        ++strp;
    return strp;
}

References c.

Referenced by tzparse().

◆ getrule()

static const char * getrule	(	const char *	strp,
		struct rule *	rulep
	)

static

Given a pointer into a time zone string, extract a rule in the form date[/time]. See POSIX section 8 for the format of "date" and "time". If a valid rule is not found, return NULL. Otherwise, return a pointer to the first character not part of the rule.

Definition at line 1244 of file localtime.c.

{
    if (*strp == 'J') {
        /*
        ** Julian day.
        */
        rulep->r_type = JULIAN_DAY;
        ++strp;
        strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
    } else if (*strp == 'M') {
        /*
        ** Month, week, day.
        */
        rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
        ++strp;
        strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
        if (strp == NULL)
            return NULL;
        if (*strp++ != '.')
            return NULL;
        strp = getnum(strp, &rulep->r_week, 1, 5);
        if (strp == NULL)
            return NULL;
        if (*strp++ != '.')
            return NULL;
        strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
    } else if (is_digit(*strp)) {
        /*
        ** Day of year.
        */
        rulep->r_type = DAY_OF_YEAR;
        strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
    } else  return NULL;        /* invalid format */
    if (strp == NULL)
        return NULL;
    if (*strp == '/') {
        /*
        ** Time specified.
        */
        ++strp;
        strp = getsecs(strp, &rulep->r_time);
    } else  rulep->r_time = 2 * SECSPERHOUR;    /* default = 2:00:00 */
    return strp;
}

References DAY_OF_YEAR, DAYSPERLYEAR, DAYSPERNYEAR, DAYSPERWEEK, getnum(), getsecs(), is_digit, JULIAN_DAY, MONSPERYEAR, MONTH_NTH_DAY_OF_WEEK, NULL, rule::r_day, rule::r_mon, rule::r_time, rule::r_type, rule::r_week, and SECSPERHOUR.

Referenced by tzparse().

◆ getsecs()

static const char * getsecs	(	const char *	strp,
		long *const	secsp
	)

static

Given a pointer into a time zone string, extract a number of seconds, in hh[:mm[:ss]] form, from the string. If any error occurs, return NULL. Otherwise, return a pointer to the first character not part of the number of seconds.

Definition at line 1181 of file localtime.c.

{
    int num;
 
    /*
    ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
    ** "M10.4.6/26", which does not conform to Posix,
    ** but which specifies the equivalent of
    ** ``02:00 on the first Sunday on or after 23 Oct''.
    */
    strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
    if (strp == NULL)
        return NULL;
    *secsp = num * (long) SECSPERHOUR;
    if (*strp == ':') {
        ++strp;
        strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
        if (strp == NULL)
            return NULL;
        *secsp += num * SECSPERMIN;
        if (*strp == ':') {
            ++strp;
            /* `SECSPERMIN' allows for leap seconds. */
            strp = getnum(strp, &num, 0, SECSPERMIN);
            if (strp == NULL)
                return NULL;
            *secsp += num;
        }
    }
    return strp;
}

References DAYSPERWEEK, getnum(), HOURSPERDAY, MINSPERHOUR, NULL, SECSPERHOUR, and SECSPERMIN.

Referenced by getoffset(), and getrule().

◆ getzname()

static const char * getzname ( const char * strp )

static

Given a pointer into a time zone string, scan until a character that is not a valid character in a zone name is found. Return a pointer to that character.

Definition at line 1118 of file localtime.c.

{
    char    c;
 
    while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&
        c != '+')
            ++strp;
    return strp;
}

References c, and is_digit.

Referenced by tzparse().

◆ gmtload()

static int gmtload ( struct state * sp )

static

Definition at line 1582 of file localtime.c.

{
    if (tzload(gmt, sp, TRUE) != 0)
        return tzparse(gmt, sp, TRUE);
    else
        return -1;
}

References gmt, TRUE, tzload(), and tzparse().

Referenced by ast_tzset(), and gmtsub().

◆ gmtsub()

static struct ast_tm * gmtsub	(	const struct timeval *	timep,
		const long	offset,
		struct ast_tm *	tmp
	)

static

Definition at line 1866 of file localtime.c.

{
    struct ast_tm * result;
    struct state *sp;
 
    AST_LIST_LOCK(&zonelist);
    AST_LIST_TRAVERSE(&zonelist, sp, list) {
        if (!strcmp(sp->name, "UTC"))
            break;
    }
 
    if (!sp) {
        if (!(sp = sstate_alloc())) {
            AST_LIST_UNLOCK(&zonelist);
            return NULL;
        }
        gmtload(sp);
        AST_LIST_INSERT_TAIL(&zonelist, sp, list);
    }
    AST_LIST_UNLOCK(&zonelist);
 
    result = timesub(timep, offset, sp, tmp);
#ifdef TM_ZONE
    /*
    ** Could get fancy here and deliver something such as
    ** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
    ** but this is no time for a treasure hunt.
    */
    if (offset != 0)
        tmp->TM_ZONE = "    ";
    else
        tmp->TM_ZONE = sp->chars;
#endif /* defined TM_ZONE */
    return result;
}

References AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, state::chars, gmtload(), state::list, state::name, NULL, result, sstate_alloc(), timesub(), and tmp().

Referenced by localsub().

◆ increment_overflow()

static int increment_overflow	(	int *	number,
		int	delta
	)

static

Simplified normalize logic courtesy Paul Eggert.

Note: Adapted from code provided by Robert Elz, who writes: The "best" way to do mktime I think is based on an idea of Bob Kridle's (so its said...) from a long time ago. It does a binary search of the time_t space. Since time_t's are just 32 bits, its a max of 32 iterations (even at 64 bits it would still be very reasonable).

Definition at line 2051 of file localtime.c.

{
    int number0;
 
    number0 = *number;
    *number += delta;
    return (*number < number0) != (delta < 0);
}

Referenced by normalize_overflow(), time2sub(), and timesub().

◆ inotify_daemon()

static void * inotify_daemon ( void * data )

static

Definition at line 353 of file localtime.c.

{
    /* inotify_event is dynamically sized */
    struct inotify_event *iev;
    size_t real_sizeof_iev = sizeof(*iev) + FILENAME_MAX + 1;
    ssize_t res;
    struct state *cur;
 
    inotify_fd = inotify_init();
 
    ast_mutex_lock(&initialization_lock);
    ast_cond_broadcast(&initialization);
    ast_mutex_unlock(&initialization_lock);
 
    if (inotify_fd < 0) {
        ast_log(LOG_ERROR, "Cannot initialize file notification service: %s (%d)\n", strerror(errno), errno);
        inotify_thread = AST_PTHREADT_NULL;
        return NULL;
    }
    iev = ast_alloca(real_sizeof_iev);
 
    common_startup();
 
    for (;/*ever*/;) {
        /* This read should block, most of the time. */
        if ((res = read(inotify_fd, iev, real_sizeof_iev)) < sizeof(*iev) && res > 0) {
            /* This should never happen */
            ast_log(LOG_ERROR, "Inotify read less than a full event (%zd < %zu)?!!\n", res, sizeof(*iev));
            break;
        } else if (res < 0) {
            if (errno == EINTR || errno == EAGAIN) {
                /* If read fails, try again */
                AST_LIST_LOCK(&zonelist);
                ast_cond_broadcast(&initialization);
                AST_LIST_UNLOCK(&zonelist);
                continue;
            }
            /* Sanity check -- this should never happen, either */
            ast_log(LOG_ERROR, "Inotify failed: %s\n", strerror(errno));
            break;
        }
        AST_LIST_LOCK(&zonelist);
        AST_LIST_TRAVERSE_SAFE_BEGIN(&zonelist, cur, list) {
            if (cur->wd[0] == iev->wd || cur->wd[1] == iev->wd) {
                AST_LIST_REMOVE_CURRENT(list);
                sstate_free(cur);
                break;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END
        ast_cond_broadcast(&initialization);
        AST_LIST_UNLOCK(&zonelist);
    }
    close(inotify_fd);
    inotify_thread = AST_PTHREADT_NULL;
    return NULL;
}

References ast_alloca, ast_cond_broadcast, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, common_startup(), errno, FILENAME_MAX, initialization, initialization_lock, inotify_fd, inotify_thread, state::list, LOG_ERROR, NULL, sstate_free(), and state::wd.

Referenced by add_notify().

◆ leaps_thru_end_of()

static int leaps_thru_end_of ( const int y )

static

Return the number of leap years through the end of the given year where, to make the math easy, the answer for year zero is defined as zero.

Definition at line 1907 of file localtime.c.

{
    return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
        -(leaps_thru_end_of(-(y + 1)) + 1);
}

References leaps_thru_end_of().

Referenced by leaps_thru_end_of(), and timesub().

◆ localsub()

static struct ast_tm * localsub	(	const struct timeval *	timep,
		const long	offset,
		struct ast_tm *	tmp,
		const struct state *	sp
	)

static

Note: The easy way to behave "as if no library function calls" localtime is to not call it–so we drop its guts into "localsub", which can be freely called. (And no, the PANS doesn't require the above behavior– but it is desirable.)

The unused offset argument is for the benefit of mktime variants.

Definition at line 1648 of file localtime.c.

{
    const struct ttinfo *   ttisp;
    int         i;
    struct ast_tm *     result;
    struct timeval  t;
    memcpy(&t, timep, sizeof(t));
 
    if (sp == NULL)
        return gmtsub(timep, offset, tmp);
    if ((sp->goback && t.tv_sec < sp->ats[0]) ||
        (sp->goahead && t.tv_sec > sp->ats[sp->timecnt - 1])) {
            struct timeval  newt = t;
            time_t      seconds;
            time_t      tcycles;
            int_fast64_t    icycles;
 
            if (t.tv_sec < sp->ats[0])
                seconds = sp->ats[0] - t.tv_sec;
            else    seconds = t.tv_sec - sp->ats[sp->timecnt - 1];
            --seconds;
            tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
            ++tcycles;
            icycles = tcycles;
            if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
                return NULL;
            seconds = icycles;
            seconds *= YEARSPERREPEAT;
            seconds *= AVGSECSPERYEAR;
            if (t.tv_sec < sp->ats[0])
                newt.tv_sec += seconds;
            else    newt.tv_sec -= seconds;
            if (newt.tv_sec < sp->ats[0] ||
                newt.tv_sec > sp->ats[sp->timecnt - 1])
                    return NULL;    /* "cannot happen" */
            result = localsub(&newt, offset, tmp, sp);
            if (result == tmp) {
                time_t  newy;
 
                newy = tmp->tm_year;
                if (t.tv_sec < sp->ats[0])
                    newy -= icycles * YEARSPERREPEAT;
                else
                    newy += icycles * YEARSPERREPEAT;
                tmp->tm_year = newy;
                if (tmp->tm_year != newy)
                    return NULL;
            }
            return result;
    }
    if (sp->timecnt == 0 || t.tv_sec < sp->ats[0]) {
        i = 0;
        while (sp->ttis[i].tt_isdst) {
            if (++i >= sp->typecnt) {
                i = 0;
                break;
            }
        }
    } else {
        int lo = 1;
        int hi = sp->timecnt;
 
        while (lo < hi) {
            int mid = (lo + hi) >> 1;
 
            if (t.tv_sec < sp->ats[mid])
                hi = mid;
            else
                lo = mid + 1;
        }
        i = (int) sp->types[lo - 1];
    }
    ttisp = &sp->ttis[i];
    /*
    ** To get (wrong) behavior that's compatible with System V Release 2.0
    ** you'd replace the statement below with
    **  t += ttisp->tt_gmtoff;
    **  timesub(&t, 0L, sp, tmp);
    */
    result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
    tmp->tm_isdst = ttisp->tt_isdst;
#ifndef SOLARIS /* Solaris doesn't have this element */
    tmp->tm_gmtoff = ttisp->tt_gmtoff;
#endif
#ifdef TM_ZONE
    tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
#endif /* defined TM_ZONE */
    tmp->tm_usec = timep->tv_usec;
    return result;
}

References state::ats, AVGSECSPERYEAR, state::chars, gmtsub(), state::goahead, state::goback, int_fast64_t, localsub(), NULL, result, state::timecnt, timesub(), tmp(), ttinfo::tt_abbrind, ttinfo::tt_gmtoff, ttinfo::tt_isdst, state::ttis, state::typecnt, state::types, and YEARSPERREPEAT.

Referenced by ast_localtime(), ast_mktime(), and localsub().

◆ long_increment_overflow()

static int long_increment_overflow	(	long *	number,
		int	delta
	)

static

Definition at line 2060 of file localtime.c.

{
    long    number0;
 
    number0 = *number;
    *number += delta;
    return (*number < number0) != (delta < 0);
}

Referenced by long_normalize_overflow(), and time2sub().

◆ long_normalize_overflow()

static int long_normalize_overflow	(	long *	tensptr,
		int *	unitsptr,
		const int	base
	)

static

Definition at line 2080 of file localtime.c.

{
    int tensdelta;
 
    tensdelta = (*unitsptr >= 0) ?
        (*unitsptr / base) :
        (-1 - (-1 - *unitsptr) / base);
    *unitsptr -= tensdelta * base;
    return long_increment_overflow(tensptr, tensdelta);
}

References long_increment_overflow().

Referenced by time2sub().

◆ normalize_overflow()

static int normalize_overflow	(	int *	tensptr,
		int *	unitsptr,
		const int	base
	)

static

Definition at line 2069 of file localtime.c.

{
    int tensdelta;
 
    tensdelta = (*unitsptr >= 0) ?
        (*unitsptr / base) :
        (-1 - (-1 - *unitsptr) / base);
    *unitsptr -= tensdelta * base;
    return increment_overflow(tensptr, tensdelta);
}

References increment_overflow().

Referenced by time2sub().

◆ P() [1/24]

static time_t detzcode64 P ( (const char *codep) )

static

◆ P() [2/24]

static int tzload P ( (const char *name, struct state *sp, int doextend) )

static

◆ P() [3/24]

static int tzparse P ( (const char *name, struct state *sp, int lastditch) )

static

◆ P() [4/24]

static const char *getzname P ( (const char *strp) )

static

◆ P() [5/24]

static const char *getqzname P ( (const char *strp, const int delim) )

static

◆ P() [6/24]

static const char *getnum P ( (const char *strp, int *nump, int min, int max) )

static

◆ P() [7/24]

static const char *getoffset P ( (const char *strp, long *offsetp) )

static

◆ P() [8/24]

static const char *getsecs P ( (const char *strp, long *secsp) )

static

◆ P() [9/24]

static const char *getrule P ( (const char *strp, struct rule *rulep) )

static

◆ P() [10/24]

static int tmcomp P ( (const struct ast_tm *atmp, const struct ast_tm *btmp) )

static

◆ P() [11/24]

static struct ast_tm *timesub P ( (const struct timeval *timep, long offset, const struct state *sp, struct ast_tm *tmp) )

static

◆ P() [12/24]

static struct ast_tm *gmtsub P ( (const struct timeval *timep, long offset, struct ast_tm *tmp) )

static

◆ P() [13/24]

static struct ast_tm *localsub P ( (const struct timeval *timep, long offset, struct ast_tm *tmp, const struct state *sp) )

static

◆ P() [14/24]

static int increment_overflow P ( (int *number, int delta) )

static

◆ P() [15/24]

static int normalize_overflow P ( (int *tensptr, int *unitsptr, const int base) )

static

◆ P() [16/24]

static int leaps_thru_end_of P ( (int y) )

static

◆ P() [17/24]

static int long_increment_overflow P ( (long *number, int delta) )

static

◆ P() [18/24]

static int long_normalize_overflow P ( (long *tensptr, int *unitsptr, const int base) )

static

◆ P() [19/24]

static struct timeval time1 P ( (struct ast_tm *tmp, struct ast_tm *(*funcp) P((const struct timeval *, long, struct ast_tm *, const struct state *sp)), long offset, const struct state *sp) )

static

◆ P() [20/24]

static struct timeval time2 P ( (struct ast_tm *tmp, struct ast_tm *(*funcp) P((const struct timeval *, long, struct ast_tm *, const struct state *sp)), long offset, int *okayp, const struct state *sp) )

static

◆ P() [21/24]

static struct timeval time2sub P ( (struct ast_tm *tmp, struct ast_tm *(*funcp)(const struct timeval *, long, struct ast_tm *, const struct state *sp), long offset, int *okayp, int do_norm_secs, const struct state *sp) )

static

◆ P() [22/24]

static int gmtload P ( (struct state *sp) )

static

◆ P() [23/24]

static time_t transtime P ( (time_t janfirst, int year, const struct rule *rulep, long offset) )

static

◆ P() [24/24]

static int differ_by_repeat P ( (time_t t1, time_t t0) )

static

◆ sstate_alloc()

static struct state * sstate_alloc ( void )

static

Definition at line 778 of file localtime.c.

{
    struct state *p = ast_calloc(1, sizeof(*p));
 
    if (p != NULL) {
        SP_HEAP_INIT(p);
    }
 
    return p;
}

References ast_calloc, NULL, and SP_HEAP_INIT.

Referenced by ast_tzset(), and gmtsub().

◆ sstate_free()

static void sstate_free ( struct state * p )

static

Definition at line 789 of file localtime.c.

{
    SP_HEAP_FREE(p);
    ast_free(p);
}

References ast_free, and SP_HEAP_FREE.

Referenced by clean_time_zones(), and inotify_daemon().

◆ store_by_locale()

static const char * store_by_locale ( locale_t prevlocale )

static

Definition at line 2388 of file localtime.c.

{
    struct locale_entry *cur;
    if (prevlocale == LC_GLOBAL_LOCALE) {
        return NULL;
    } else {
        /* Get a handle for this entry, if any */
        if ((cur = find_by_locale(prevlocale))) {
            return cur->name;
        } else {
            /* Create an entry, so it can be restored later */
            int x;
            cur = NULL;
            AST_LIST_LOCK(&localelist);
            for (x = 0; x < 10000; x++) {
                char name[6];
                snprintf(name, sizeof(name), "%04d", x);
                if (!find_by_name(name)) {
                    if ((cur = ast_calloc(1, sizeof(*cur) + strlen(name) + 1))) {
                        cur->locale = prevlocale;
                        strcpy(cur->name, name); /* SAFE */
                        AST_LIST_INSERT_TAIL(&localelist, cur, list);
                    }
                    break;
                }
            }
            AST_LIST_UNLOCK(&localelist);
            return cur ? cur->name : NULL;
        }
    }
}

References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, find_by_locale(), find_by_name(), locale_entry::list, locale_entry::locale, locale_entry::name, name, and NULL.

Referenced by ast_setlocale().

◆ time1()

static struct timeval time1	(	struct ast_tm *	tmp,
		struct ast_tm ()(const struct timeval , long, struct ast_tm , const struct state *)	funcp,
		const long	offset,
		const struct state *	sp
	)

static

Definition at line 2292 of file localtime.c.

{
    struct timeval          t;
    int         samei, otheri;
    int         sameind, otherind;
    int         i;
    int         nseen;
    int             seen[TZ_MAX_TYPES];
    int             types[TZ_MAX_TYPES];
    int             okay;
 
    if (tmp->tm_isdst > 1)
        tmp->tm_isdst = 1;
    t = time2(tmp, funcp, offset, &okay, sp);
#ifdef PCTS
    /*
    ** PCTS code courtesy Grant Sullivan.
    */
    if (okay)
        return t;
    if (tmp->tm_isdst < 0)
        tmp->tm_isdst = 0;  /* reset to std and try again */
#endif /* defined PCTS */
#ifndef PCTS
    if (okay || tmp->tm_isdst < 0)
        return t;
#endif /* !defined PCTS */
    /*
    ** We're supposed to assume that somebody took a time of one type
    ** and did some math on it that yielded a "struct ast_tm" that's bad.
    ** We try to divine the type they started from and adjust to the
    ** type they need.
    */
    if (sp == NULL)
        return WRONG;
    for (i = 0; i < sp->typecnt; ++i)
        seen[i] = FALSE;
    nseen = 0;
    for (i = sp->timecnt - 1; i >= 0; --i)
        if (!seen[sp->types[i]]) {
            seen[sp->types[i]] = TRUE;
            types[nseen++] = sp->types[i];
        }
    for (sameind = 0; sameind < nseen; ++sameind) {
        samei = types[sameind];
        if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
            continue;
        for (otherind = 0; otherind < nseen; ++otherind) {
            otheri = types[otherind];
            if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
                continue;
            tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
                    sp->ttis[samei].tt_gmtoff;
            tmp->tm_isdst = !tmp->tm_isdst;
            t = time2(tmp, funcp, offset, &okay, sp);
            if (okay)
                return t;
            tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
                    sp->ttis[samei].tt_gmtoff;
            tmp->tm_isdst = !tmp->tm_isdst;
        }
    }
    return WRONG;
}

References FALSE, NULL, time2(), state::timecnt, tmp(), TRUE, ttinfo::tt_gmtoff, ttinfo::tt_isdst, state::ttis, state::typecnt, state::types, TZ_MAX_TYPES, and WRONG.

Referenced by ast_mktime().

◆ time2()

static struct timeval time2	(	struct ast_tm *	tmp,
		struct ast_tm ()(const struct timeval , long, struct ast_tm , const struct state *sp)	funcp,
		const long	offset,
		int *	okayp,
		const struct state *	sp
	)

static

Note: First try without normalization of seconds (in case tm_sec contains a value associated with a leap second). If that fails, try with normalization of seconds.

Definition at line 2279 of file localtime.c.

{
    struct timeval  t;
 
    /*! \note
    ** First try without normalization of seconds
    ** (in case tm_sec contains a value associated with a leap second).
    ** If that fails, try with normalization of seconds.
    */
    t = time2sub(tmp, funcp, offset, okayp, FALSE, sp);
    return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE, sp);
}

References FALSE, time2sub(), tmp(), and TRUE.

Referenced by time1().

◆ time2sub()

static struct timeval time2sub	(	struct ast_tm *	tmp,
		struct ast_tm ()(const struct timeval , long, struct ast_tm , const struct state *)	funcp,
		const long	offset,
		int *	okayp,
		const int	do_norm_secs,
		const struct state *	sp
	)

static

Definition at line 2105 of file localtime.c.

{
    int         dir;
    int         i, j;
    int         saved_seconds;
    long            li;
    time_t          lo;
    time_t          hi;
    long                y;
    struct timeval          newt = { 0, 0 };
    struct timeval          t = { 0, 0 };
    struct ast_tm           yourtm, mytm;
 
    *okayp = FALSE;
    yourtm = *tmp;
    if (do_norm_secs) {
        if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
            SECSPERMIN))
                return WRONG;
    }
    if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
        return WRONG;
    if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
        return WRONG;
    y = yourtm.tm_year;
    if (long_normalize_overflow(&y, &yourtm.tm_mon, MONSPERYEAR))
        return WRONG;
    /*
    ** Turn y into an actual year number for now.
    ** It is converted back to an offset from TM_YEAR_BASE later.
    */
    if (long_increment_overflow(&y, TM_YEAR_BASE))
        return WRONG;
    while (yourtm.tm_mday <= 0) {
        if (long_increment_overflow(&y, -1))
            return WRONG;
        li = y + (1 < yourtm.tm_mon);
        yourtm.tm_mday += year_lengths[isleap(li)];
    }
    while (yourtm.tm_mday > DAYSPERLYEAR) {
        li = y + (1 < yourtm.tm_mon);
        yourtm.tm_mday -= year_lengths[isleap(li)];
        if (long_increment_overflow(&y, 1))
            return WRONG;
    }
    for ( ; ; ) {
        i = mon_lengths[isleap(y)][yourtm.tm_mon];
        if (yourtm.tm_mday <= i)
            break;
        yourtm.tm_mday -= i;
        if (++yourtm.tm_mon >= MONSPERYEAR) {
            yourtm.tm_mon = 0;
            if (long_increment_overflow(&y, 1))
                return WRONG;
        }
    }
    if (long_increment_overflow(&y, -TM_YEAR_BASE))
        return WRONG;
    yourtm.tm_year = y;
    if (yourtm.tm_year != y)
        return WRONG;
    if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
        saved_seconds = 0;
    else if (y + TM_YEAR_BASE < EPOCH_YEAR) {
        /*
        ** We can't set tm_sec to 0, because that might push the
        ** time below the minimum representable time.
        ** Set tm_sec to 59 instead.
        ** This assumes that the minimum representable time is
        ** not in the same minute that a leap second was deleted from,
        ** which is a safer assumption than using 58 would be.
        */
        if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
            return WRONG;
        saved_seconds = yourtm.tm_sec;
        yourtm.tm_sec = SECSPERMIN - 1;
    } else {
        saved_seconds = yourtm.tm_sec;
        yourtm.tm_sec = 0;
    }
    /*
    ** Do a binary search (this works whatever time_t's type is).
    */
    if (!TYPE_SIGNED(time_t)) {
        lo = 0;
        hi = lo - 1;
    } else if (!TYPE_INTEGRAL(time_t)) {
        if (sizeof(time_t) > sizeof(float))
            hi = (time_t) DBL_MAX;
        else    hi = (time_t) FLT_MAX;
        lo = -hi;
    } else {
        lo = 1;
        for (i = 0; i < (int) TYPE_BIT(time_t) - 1; ++i)
            lo *= 2;
        hi = -(lo + 1);
    }
    for ( ; ; ) {
        t.tv_sec = lo / 2 + hi / 2;
        if (t.tv_sec < lo)
            t.tv_sec = lo;
        else if (t.tv_sec > hi)
            t.tv_sec = hi;
        if ((*funcp)(&t, offset, &mytm, sp) == NULL) {
            /*
            ** Assume that t is too extreme to be represented in
            ** a struct ast_tm; arrange things so that it is less
            ** extreme on the next pass.
            */
            dir = (t.tv_sec > 0) ? 1 : -1;
        } else  dir = tmcomp(&mytm, &yourtm);
        if (dir != 0) {
            if (t.tv_sec == lo) {
                ++t.tv_sec;
                if (t.tv_sec <= lo)
                    return WRONG;
                ++lo;
            } else if (t.tv_sec == hi) {
                --t.tv_sec;
                if (t.tv_sec >= hi)
                    return WRONG;
                --hi;
            }
            if (lo > hi)
                return WRONG;
            if (dir > 0)
                hi = t.tv_sec;
            else    lo = t.tv_sec;
            continue;
        }
        if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
            break;
        /*
        ** Right time, wrong type.
        ** Hunt for right time, right type.
        ** It's okay to guess wrong since the guess
        ** gets checked.
        */
        /*
        ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
        */
        for (i = sp->typecnt - 1; i >= 0; --i) {
            if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
                continue;
            for (j = sp->typecnt - 1; j >= 0; --j) {
                if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
                    continue;
                newt.tv_sec = t.tv_sec + sp->ttis[j].tt_gmtoff -
                    sp->ttis[i].tt_gmtoff;
                if ((*funcp)(&newt, offset, &mytm, sp) == NULL)
                    continue;
                if (tmcomp(&mytm, &yourtm) != 0)
                    continue;
                if (mytm.tm_isdst != yourtm.tm_isdst)
                    continue;
                /*
                ** We have a match.
                */
                t = newt;
                goto label;
            }
        }
        return WRONG;
    }
label:
    newt.tv_sec = t.tv_sec + saved_seconds;
    if ((newt.tv_sec < t.tv_sec) != (saved_seconds < 0))
        return WRONG;
    t.tv_sec = newt.tv_sec;
    if ((*funcp)(&t, offset, tmp, sp))
        *okayp = TRUE;
    return t;
}

References DAYSPERLYEAR, EPOCH_YEAR, FALSE, HOURSPERDAY, increment_overflow(), isleap, long_increment_overflow(), long_normalize_overflow(), MINSPERHOUR, mon_lengths, MONSPERYEAR, normalize_overflow(), NULL, SECSPERMIN, ast_tm::tm_hour, ast_tm::tm_isdst, ast_tm::tm_mday, ast_tm::tm_min, ast_tm::tm_mon, ast_tm::tm_sec, ast_tm::tm_year, TM_YEAR_BASE, tmcomp(), tmp(), TRUE, ttinfo::tt_gmtoff, ttinfo::tt_isdst, state::ttis, TYPE_BIT, TYPE_INTEGRAL, TYPE_SIGNED, state::typecnt, WRONG, and year_lengths.

Referenced by time2().

◆ timesub()

static struct ast_tm * timesub	(	const struct timeval *	timep,
		const long	offset,
		const struct state *	sp,
		struct ast_tm *	tmp
	)

static

Definition at line 1913 of file localtime.c.

{
    const struct lsinfo *   lp;
    time_t          tdays;
    int         idays;  /* unsigned would be so 2003 */
    long            rem;
    int             y;
    const int *     ip;
    long            corr;
    int         hit;
    int         i;
    long    seconds;
 
 
    corr = 0;
    hit = 0;
    i = (sp == NULL) ? 0 : sp->leapcnt;
    while (--i >= 0) {
        lp = &sp->lsis[i];
        if (timep->tv_sec >= lp->ls_trans) {
            if (timep->tv_sec == lp->ls_trans) {
                hit = ((i == 0 && lp->ls_corr > 0) ||
                    lp->ls_corr > sp->lsis[i - 1].ls_corr);
                if (hit)
                    while (i > 0 &&
                        sp->lsis[i].ls_trans ==
                        sp->lsis[i - 1].ls_trans + 1 &&
                        sp->lsis[i].ls_corr ==
                        sp->lsis[i - 1].ls_corr + 1) {
                            ++hit;
                            --i;
                    }
            }
            corr = lp->ls_corr;
            break;
        }
    }
    y = EPOCH_YEAR;
    tdays = timep->tv_sec / SECSPERDAY;
    rem = timep->tv_sec - tdays * SECSPERDAY;
    while (tdays < 0 || tdays >= year_lengths[isleap(y)]) {
        int     newy;
        time_t  tdelta;
        int idelta;
        int leapdays;
 
        tdelta = tdays / DAYSPERLYEAR;
        idelta = tdelta;
        if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
            return NULL;
        if (idelta == 0)
            idelta = (tdays < 0) ? -1 : 1;
        newy = y;
        if (increment_overflow(&newy, idelta))
            return NULL;
        leapdays = leaps_thru_end_of(newy - 1) -
            leaps_thru_end_of(y - 1);
        tdays -= ((time_t) newy - y) * DAYSPERNYEAR;
        tdays -= leapdays;
        y = newy;
    }
 
    seconds = tdays * SECSPERDAY + 0.5;
    tdays = seconds / SECSPERDAY;
    rem += seconds - tdays * SECSPERDAY;
 
    /*
    ** Given the range, we can now fearlessly cast...
    */
    idays = tdays;
    rem += offset - corr;
    while (rem < 0) {
        rem += SECSPERDAY;
        --idays;
    }
    while (rem >= SECSPERDAY) {
        rem -= SECSPERDAY;
        ++idays;
    }
    while (idays < 0) {
        if (increment_overflow(&y, -1))
            return NULL;
        idays += year_lengths[isleap(y)];
    }
    while (idays >= year_lengths[isleap(y)]) {
        idays -= year_lengths[isleap(y)];
        if (increment_overflow(&y, 1))
            return NULL;
    }
    tmp->tm_year = y;
    if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
        return NULL;
    tmp->tm_yday = idays;
    /*
    ** The "extra" mods below avoid overflow problems.
    */
    tmp->tm_wday = EPOCH_WDAY +
        ((y - EPOCH_YEAR) % DAYSPERWEEK) *
        (DAYSPERNYEAR % DAYSPERWEEK) +
        leaps_thru_end_of(y - 1) -
        leaps_thru_end_of(EPOCH_YEAR - 1) +
        idays;
    tmp->tm_wday %= DAYSPERWEEK;
    if (tmp->tm_wday < 0)
        tmp->tm_wday += DAYSPERWEEK;
    tmp->tm_hour = (int) (rem / SECSPERHOUR);
    rem %= SECSPERHOUR;
    tmp->tm_min = (int) (rem / SECSPERMIN);
    /*
    ** A positive leap second requires a special
    ** representation. This uses "... ??:59:60" et seq.
    */
    tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
    ip = mon_lengths[isleap(y)];
    for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon))
        idays -= ip[tmp->tm_mon];
    tmp->tm_mday = (int) (idays + 1);
    tmp->tm_isdst = 0;
#ifdef TM_GMTOFF
    tmp->TM_GMTOFF = offset;
#endif /* defined TM_GMTOFF */
    tmp->tm_usec = timep->tv_usec;
    return tmp;
}

References DAYSPERLYEAR, DAYSPERNYEAR, DAYSPERWEEK, EPOCH_WDAY, EPOCH_YEAR, increment_overflow(), isleap, state::leapcnt, leaps_thru_end_of(), lsinfo::ls_corr, lsinfo::ls_trans, state::lsis, mon_lengths, NULL, SECSPERDAY, SECSPERHOUR, SECSPERMIN, TM_YEAR_BASE, tmp(), while(), and year_lengths.

Referenced by gmtsub(), and localsub().

◆ tmcomp()

static int tmcomp	(	const struct ast_tm *	atmp,
		const struct ast_tm *	btmp
	)

static

Definition at line 2091 of file localtime.c.

{
    int result;
 
    if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
        (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
        (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
        (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
        (result = (atmp->tm_min - btmp->tm_min)) == 0 &&
        (result = (atmp->tm_sec - btmp->tm_sec)) == 0)
            result = atmp->tm_usec - btmp->tm_usec;
    return result;
}

References result, ast_tm::tm_hour, ast_tm::tm_mday, ast_tm::tm_min, ast_tm::tm_mon, ast_tm::tm_sec, ast_tm::tm_usec, and ast_tm::tm_year.

Referenced by time2sub().

◆ transtime()

static time_t transtime	(	const time_t	janfirst,
		const int	year,
		const struct rule *	rulep,
		const long	offset
	)

static

Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the year, a rule, and the offset from UTC at the time that rule takes effect, calculate the Epoch-relative time that rule takes effect.

Definition at line 1295 of file localtime.c.

{
    int leapyear;
    time_t  value;
    int i;
    int     d, m1, yy0, yy1, yy2, dow;
 
    INITIALIZE(value);
    leapyear = isleap(year);
    switch (rulep->r_type) {
 
    case JULIAN_DAY:
        /*
        ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
        ** years.
        ** In non-leap years, or if the day number is 59 or less, just
        ** add SECSPERDAY times the day number-1 to the time of
        ** January 1, midnight, to get the day.
        */
        value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
        if (leapyear && rulep->r_day >= 60)
            value += SECSPERDAY;
        break;
 
    case DAY_OF_YEAR:
        /*
        ** n - day of year.
        ** Just add SECSPERDAY times the day number to the time of
        ** January 1, midnight, to get the day.
        */
        value = janfirst + rulep->r_day * SECSPERDAY;
        break;
 
    case MONTH_NTH_DAY_OF_WEEK:
        /*
        ** Mm.n.d - nth "dth day" of month m.
        */
        value = janfirst;
        for (i = 0; i < rulep->r_mon - 1; ++i)
            value += mon_lengths[leapyear][i] * SECSPERDAY;
 
        /*
        ** Use Zeller's Congruence to get day-of-week of first day of
        ** month.
        */
        m1 = (rulep->r_mon + 9) % 12 + 1;
        yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
        yy1 = yy0 / 100;
        yy2 = yy0 % 100;
        dow = ((26 * m1 - 2) / 10 +
            1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
        if (dow < 0)
            dow += DAYSPERWEEK;
 
        /*
        ** "dow" is the day-of-week of the first day of the month. Get
        ** the day-of-month (zero-origin) of the first "dow" day of the
        ** month.
        */
        d = rulep->r_day - dow;
        if (d < 0)
            d += DAYSPERWEEK;
        for (i = 1; i < rulep->r_week; ++i) {
            if (d + DAYSPERWEEK >=
                mon_lengths[leapyear][rulep->r_mon - 1])
                    break;
            d += DAYSPERWEEK;
        }
 
        /*
        ** "d" is the day-of-month (zero-origin) of the day we want.
        */
        value += d * SECSPERDAY;
        break;
    }
 
    /*
    ** "value" is the Epoch-relative time of 00:00:00 UTC on the day in
    ** question. To get the Epoch-relative time of the specified local
    ** time on that day, add the transition time and the current offset
    ** from UTC.
    */
    return value + rulep->r_time + offset;
}

References d, DAY_OF_YEAR, DAYSPERWEEK, INITIALIZE, isleap, JULIAN_DAY, mon_lengths, MONTH_NTH_DAY_OF_WEEK, rule::r_day, rule::r_mon, rule::r_time, rule::r_type, rule::r_week, SECSPERDAY, and value.

Referenced by tzparse().

◆ tzload()

static int tzload	(	const char *	name,
		struct state *const	sp,
		const int	doextend
	)

static

Definition at line 853 of file localtime.c.

{
    const char *        p;
    int         i;
    int         fid;
    int         stored;
    int         nread;
    union {
        struct tzhead   tzhead;
        char        buf[2 * sizeof(struct tzhead) +
                    2 * sizeof *sp +
                    4 * TZ_MAX_TIMES];
    } u;
 
    if (name == NULL && (name = TZDEFAULT) == NULL)
        return -1;
    {
        int doaccess;
        /*
        ** Section 4.9.1 of the C standard says that
        ** "FILENAME_MAX expands to an integral constant expression
        ** that is the size needed for an array of char large enough
        ** to hold the longest file name string that the implementation
        ** guarantees can be opened."
        */
        char        fullname[FILENAME_MAX + 1];
 
        if (name[0] == ':')
            ++name;
        doaccess = name[0] == '/';
        if (!doaccess) {
            if ((p = TZDIR) == NULL)
                return -1;
            if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
                return -1;
            (void) strcpy(fullname, p);
            (void) strcat(fullname, "/");
            (void) strcat(fullname, name);
            /*
            ** Set doaccess if '.' (as in "../") shows up in name.
            */
            if (strchr(name, '.') != NULL)
                doaccess = TRUE;
            name = fullname;
        }
        if (doaccess && access(name, R_OK) != 0)
            return -1;
        if ((fid = open(name, OPEN_MODE)) == -1)
            return -1;
        if (ast_fully_booted) {
            /* If we don't wait until Asterisk is fully booted, it's possible
             * that the watcher thread gets started in the parent process,
             * before daemon(3) is called, and the thread won't propagate to
             * the child.  Given that bootup only takes a few seconds, it's
             * reasonable to only start the watcher later. */
            add_notify(sp, name);
        }
    }
    nread = read(fid, u.buf, sizeof u.buf);
    /* comp nread < sizeof u.tzhead against unexpected short files */
    if (close(fid) < 0 || nread < sizeof u.tzhead)
        return -1;
    for (stored = 4; stored <= 8; stored *= 2) {
        int     ttisstdcnt;
        int     ttisgmtcnt;
 
        ttisstdcnt = (int) detzcode(u.tzhead.tzh_ttisstdcnt);
        ttisgmtcnt = (int) detzcode(u.tzhead.tzh_ttisgmtcnt);
        sp->leapcnt = (int) detzcode(u.tzhead.tzh_leapcnt);
        sp->timecnt = (int) detzcode(u.tzhead.tzh_timecnt);
        sp->typecnt = (int) detzcode(u.tzhead.tzh_typecnt);
        sp->charcnt = (int) detzcode(u.tzhead.tzh_charcnt);
        p = u.tzhead.tzh_charcnt + sizeof u.tzhead.tzh_charcnt;
        if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
            sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
            sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
            sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
            (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
            (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
                return -1;
        if (nread - (p - u.buf) <
            sp->timecnt * stored +      /* ats */
            sp->timecnt +           /* types */
            sp->typecnt * 6 +       /* ttinfos */
            sp->charcnt +           /* chars */
            sp->leapcnt * (stored + 4) +    /* lsinfos */
            ttisstdcnt +            /* ttisstds */
            ttisgmtcnt)         /* ttisgmts */
                return -1;
        for (i = 0; i < sp->timecnt; ++i) {
            sp->ats[i] = (stored == 4) ?
                detzcode(p) : detzcode64(p);
            p += stored;
        }
        for (i = 0; i < sp->timecnt; ++i) {
            sp->types[i] = (unsigned char) *p++;
            if (sp->types[i] >= sp->typecnt)
                return -1;
        }
        for (i = 0; i < sp->typecnt; ++i) {
            struct ttinfo * ttisp;
 
            ttisp = &sp->ttis[i];
            ttisp->tt_gmtoff = detzcode(p);
            p += 4;
            ttisp->tt_isdst = (unsigned char) *p++;
            if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
                return -1;
            ttisp->tt_abbrind = (unsigned char) *p++;
            if (ttisp->tt_abbrind < 0 ||
                ttisp->tt_abbrind > sp->charcnt)
                    return -1;
        }
        for (i = 0; i < sp->charcnt; ++i)
            sp->chars[i] = *p++;
        sp->chars[i] = '\0';    /* ensure '\0' at end */
        for (i = 0; i < sp->leapcnt; ++i) {
            struct lsinfo * lsisp;
 
            lsisp = &sp->lsis[i];
            lsisp->ls_trans = (stored == 4) ?
                detzcode(p) : detzcode64(p);
            p += stored;
            lsisp->ls_corr = detzcode(p);
            p += 4;
        }
        for (i = 0; i < sp->typecnt; ++i) {
            struct ttinfo * ttisp;
 
            ttisp = &sp->ttis[i];
            if (ttisstdcnt == 0)
                ttisp->tt_ttisstd = FALSE;
            else {
                ttisp->tt_ttisstd = *p++;
                if (ttisp->tt_ttisstd != TRUE &&
                    ttisp->tt_ttisstd != FALSE)
                        return -1;
            }
        }
        for (i = 0; i < sp->typecnt; ++i) {
            struct ttinfo * ttisp;
 
            ttisp = &sp->ttis[i];
            if (ttisgmtcnt == 0)
                ttisp->tt_ttisgmt = FALSE;
            else {
                ttisp->tt_ttisgmt = *p++;
                if (ttisp->tt_ttisgmt != TRUE &&
                    ttisp->tt_ttisgmt != FALSE)
                        return -1;
            }
        }
        /*
        ** Out-of-sort ats should mean we're running on a
        ** signed time_t system but using a data file with
        ** unsigned values (or vice versa).
        */
        for (i = 0; i < sp->timecnt - 2; ++i)
            if (sp->ats[i] > sp->ats[i + 1]) {
                ++i;
                if (TYPE_SIGNED(time_t)) {
                    /*
                    ** Ignore the end (easy).
                    */
                    sp->timecnt = i;
                } else {
                    /*
                    ** Ignore the beginning (harder).
                    */
                    int j;
 
                    for (j = 0; j + i < sp->timecnt; ++j) {
                        sp->ats[j] = sp->ats[j + i];
                        sp->types[j] = sp->types[j + i];
                    }
                    sp->timecnt = j;
                }
                break;
            }
        /*
        ** If this is an old file, we're done.
        */
        if (u.tzhead.tzh_version[0] == '\0')
            break;
        nread -= p - u.buf;
        for (i = 0; i < nread; ++i)
            u.buf[i] = p[i];
        /* next loop iter. will assume at least
           sizeof(struct tzhead) bytes */
        if (nread < sizeof(u.tzhead)) {
            break;
        }
        /*
        ** If this is a narrow integer time_t system, we're done.
        */
        if (stored >= (int) sizeof(time_t) && TYPE_INTEGRAL(time_t))
            break;
    }
    if (doextend && nread > 2 &&
        u.buf[0] == '\n' && u.buf[nread - 1] == '\n' &&
        sp->typecnt + 2 <= TZ_MAX_TYPES) {
            struct state    ts;
            int result;
 
            /* for temporary struct state --
             * macro flags the struct as a stack temp.
             * to prevent use within add_notify()
             */
            SP_STACK_INIT(ts);
 
            u.buf[nread - 1] = '\0';
            result = tzparse(&u.buf[1], &ts, FALSE);
            if (result == 0 && ts.typecnt == 2 &&
                sp->charcnt + ts.charcnt <= TZ_MAX_CHARS) {
                    for (i = 0; i < 2; ++i)
                        ts.ttis[i].tt_abbrind +=
                            sp->charcnt;
                    for (i = 0; i < ts.charcnt; ++i)
                        sp->chars[sp->charcnt++] =
                            ts.chars[i];
                    i = 0;
                    while (i < ts.timecnt &&
                        ts.ats[i] <=
                        sp->ats[sp->timecnt - 1])
                            ++i;
                    while (i < ts.timecnt &&
                        sp->timecnt < TZ_MAX_TIMES) {
                        sp->ats[sp->timecnt] =
                            ts.ats[i];
                        sp->types[sp->timecnt] =
                            sp->typecnt +
                            ts.types[i];
                        ++sp->timecnt;
                        ++i;
                    }
                    sp->ttis[sp->typecnt++] = ts.ttis[0];
                    sp->ttis[sp->typecnt++] = ts.ttis[1];
            }
    }
    i = 2 * YEARSPERREPEAT;
    sp->goback = sp->goahead = sp->timecnt > i;
    sp->goback = sp->goback && sp->types[i] == sp->types[0] &&
        differ_by_repeat(sp->ats[i], sp->ats[0]);
    sp->goahead = sp->goahead &&
        sp->types[sp->timecnt - 1] == sp->types[sp->timecnt - 1 - i] &&
        differ_by_repeat(sp->ats[sp->timecnt - 1],
             sp->ats[sp->timecnt - 1 - i]);
    return 0;
}

References add_notify(), ast_fully_booted, state::ats, buf, state::charcnt, state::chars, detzcode(), detzcode64(), differ_by_repeat(), FALSE, FILENAME_MAX, state::goahead, state::goback, if(), state::leapcnt, lsinfo::ls_corr, lsinfo::ls_trans, state::lsis, name, NULL, OPEN_MODE, result, SP_STACK_INIT, state::timecnt, TRUE, ttinfo::tt_abbrind, ttinfo::tt_gmtoff, ttinfo::tt_isdst, ttinfo::tt_ttisgmt, ttinfo::tt_ttisstd, state::ttis, TYPE_INTEGRAL, TYPE_SIGNED, state::typecnt, state::types, TZ_MAX_CHARS, TZ_MAX_LEAPS, TZ_MAX_TIMES, TZ_MAX_TYPES, TZDEFAULT, TZDIR, tzparse(), while(), and YEARSPERREPEAT.

Referenced by ast_tzset(), gmtload(), and tzparse().

◆ tzparse()

static int tzparse	(	const char *	name,
		struct state *	sp,
		const int	lastditch
	)

static

Note: Given a POSIX section 8-style TZ string, fill in the rule tables as appropriate.

Definition at line 1385 of file localtime.c.

{
    const char *            stdname;
    const char *            dstname;
    size_t              stdlen;
    size_t              dstlen;
    long                stdoffset;
    long                dstoffset;
    time_t *        atp;
    unsigned char * typep;
    char *          cp;
    int         load_result;
 
    INITIALIZE(dstname);
    stdname = name;
    if (lastditch) {
        stdlen = strlen(name);  /* length of standard zone name */
        name += stdlen;
        if (stdlen >= sizeof sp->chars)
            stdlen = (sizeof sp->chars) - 1;
        stdoffset = 0;
    } else {
        if (*name == '<') {
            name++;
            stdname = name;
            name = getqzname(name, '>');
            if (*name != '>')
                return -1;
            stdlen = name - stdname;
            name++;
        } else {
            name = getzname(name);
            stdlen = name - stdname;
        }
        if (*name == '\0')
            return -1;
        name = getoffset(name, &stdoffset);
        if (name == NULL)
            return -1;
    }
    load_result = tzload(TZDEFRULES, sp, FALSE);
    if (load_result != 0)
        sp->leapcnt = 0;        /* so, we're off a little */
    if (*name != '\0') {
        if (*name == '<') {
            dstname = ++name;
            name = getqzname(name, '>');
            if (*name != '>')
                return -1;
            dstlen = name - dstname;
            name++;
        } else {
            dstname = name;
            name = getzname(name);
            dstlen = name - dstname; /* length of DST zone name */
        }
        if (*name != '\0' && *name != ',' && *name != ';') {
            name = getoffset(name, &dstoffset);
            if (name == NULL)
                return -1;
        } else  dstoffset = stdoffset - SECSPERHOUR;
        if (*name == '\0' && load_result != 0)
            name = TZDEFRULESTRING;
        if (*name == ',' || *name == ';') {
            struct rule start;
            struct rule end;
            int year;
            time_t  janfirst;
            time_t      starttime;
            time_t      endtime;
 
            ++name;
            if ((name = getrule(name, &start)) == NULL)
                return -1;
            if (*name++ != ',')
                return -1;
            if ((name = getrule(name, &end)) == NULL)
                return -1;
            if (*name != '\0')
                return -1;
            sp->typecnt = 2;    /* standard time and DST */
            /*
            ** Two transitions per year, from EPOCH_YEAR forward.
            */
            sp->ttis[0].tt_gmtoff = -dstoffset;
            sp->ttis[0].tt_isdst = 1;
            sp->ttis[0].tt_abbrind = stdlen + 1;
            sp->ttis[1].tt_gmtoff = -stdoffset;
            sp->ttis[1].tt_isdst = 0;
            sp->ttis[1].tt_abbrind = 0;
            atp = sp->ats;
            typep = sp->types;
            janfirst = 0;
            sp->timecnt = 0;
            for (year = EPOCH_YEAR;
                sp->timecnt + 2 <= TZ_MAX_TIMES;
                ++year) {
                time_t  newfirst;
 
                starttime = transtime(janfirst, year, &start,
                    stdoffset);
                endtime = transtime(janfirst, year, &end,
                    dstoffset);
                if (starttime > endtime) {
                    *atp++ = endtime;
                    *typep++ = 1;   /* DST ends */
                    *atp++ = starttime;
                    *typep++ = 0;   /* DST begins */
                } else {
                    *atp++ = starttime;
                    *typep++ = 0;   /* DST begins */
                    *atp++ = endtime;
                    *typep++ = 1;   /* DST ends */
                }
                sp->timecnt += 2;
                newfirst = janfirst;
                newfirst += year_lengths[isleap(year)] *
                    SECSPERDAY;
                if (newfirst <= janfirst)
                    break;
                janfirst = newfirst;
            }
        } else {
            long    theirstdoffset;
            long    theiroffset;
            int i;
            int j;
 
            if (*name != '\0')
                return -1;
            /*
            ** Initial values of theirstdoffset.
            */
            theirstdoffset = 0;
            for (i = 0; i < sp->timecnt; ++i) {
                j = sp->types[i];
                if (!sp->ttis[j].tt_isdst) {
                    theirstdoffset =
                        -sp->ttis[j].tt_gmtoff;
                    break;
                }
            }
            theiroffset = theirstdoffset;
            /*
            ** Now juggle transition times and types
            ** tracking offsets as you do.
            */
            for (i = 0; i < sp->timecnt; ++i) {
                j = sp->types[i];
                sp->types[i] = sp->ttis[j].tt_isdst;
                if (sp->ttis[j].tt_ttisgmt) {
                    /* No adjustment to transition time */
                } else {
                    /* Add the standard time offset to the transition time. */
                    sp->ats[i] += stdoffset - theirstdoffset;
                }
                theiroffset = -sp->ttis[j].tt_gmtoff;
                if (!sp->ttis[j].tt_isdst) {
                    theirstdoffset = theiroffset;
                }
            }
            /*
            ** Finally, fill in ttis.
            ** ttisstd and ttisgmt need not be handled.
            */
            sp->ttis[0].tt_gmtoff = -stdoffset;
            sp->ttis[0].tt_isdst = FALSE;
            sp->ttis[0].tt_abbrind = 0;
            sp->ttis[1].tt_gmtoff = -dstoffset;
            sp->ttis[1].tt_isdst = TRUE;
            sp->ttis[1].tt_abbrind = stdlen + 1;
            sp->typecnt = 2;
        }
    } else {
        dstlen = 0;
        sp->typecnt = 1;        /* only standard time */
        sp->timecnt = 0;
        sp->ttis[0].tt_gmtoff = -stdoffset;
        sp->ttis[0].tt_isdst = 0;
        sp->ttis[0].tt_abbrind = 0;
    }
    sp->charcnt = stdlen + 1;
    if (dstlen != 0)
        sp->charcnt += dstlen + 1;
    if ((size_t) sp->charcnt > sizeof sp->chars)
        return -1;
    cp = sp->chars;
    (void) strncpy(cp, stdname, stdlen);
    cp += stdlen;
    *cp++ = '\0';
    if (dstlen != 0) {
        (void) strncpy(cp, dstname, dstlen);
        *(cp + dstlen) = '\0';
    }
    return 0;
}

References state::ats, state::charcnt, state::chars, end, EPOCH_YEAR, FALSE, getoffset(), getqzname(), getrule(), getzname(), INITIALIZE, isleap, state::leapcnt, name, NULL, SECSPERDAY, SECSPERHOUR, state::timecnt, transtime(), TRUE, ttinfo::tt_abbrind, ttinfo::tt_gmtoff, ttinfo::tt_isdst, ttinfo::tt_ttisgmt, state::ttis, state::typecnt, state::types, TZ_MAX_TIMES, TZDEFRULES, TZDEFRULESTRING, tzload(), and year_lengths.

Referenced by ast_tzset(), gmtload(), and tzload().

Variable Documentation

◆ elsieid

char elsieid[] = "@(#)localtime.c 8.5"

static

Definition at line 82 of file localtime.c.

◆ gmt

const char gmt[] = "GMT"

static

Definition at line 110 of file localtime.c.

Referenced by gmtload().

◆ initialization

ast_cond_t initialization

static

Definition at line 322 of file localtime.c.

Referenced by add_notify(), ast_localtime_wakeup_monitor(), and inotify_daemon().

◆ initialization_lock

ast_mutex_t initialization_lock

static

Definition at line 323 of file localtime.c.

Referenced by add_notify(), and inotify_daemon().

◆ inotify_fd

int inotify_fd = -1

static

Definition at line 351 of file localtime.c.

Referenced by add_notify(), inotify_daemon(), and scan_thread().

◆ inotify_thread

pthread_t inotify_thread = AST_PTHREADT_NULL

static

Definition at line 321 of file localtime.c.

Referenced by add_notify(), ast_localtime_wakeup_monitor(), and inotify_daemon().

◆ localelist

struct localelist localelist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

◆ mon_lengths

const int mon_lengths[2][MONSPERYEAR]

static

Initial value:

= {
    { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
    { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
}

Definition at line 1103 of file localtime.c.

Referenced by time2sub(), timesub(), and transtime().

◆ WRONG

const struct timeval WRONG = { 0, 0 }

static

Definition at line 111 of file localtime.c.

Referenced by ast_mktime(), time1(), and time2sub().

◆ year_lengths

const int year_lengths[2]

static

Initial value:

= {
    DAYSPERNYEAR, DAYSPERLYEAR
}

Definition at line 1108 of file localtime.c.

Referenced by time2sub(), timesub(), and tzparse().

◆ zonelist

struct zonelist zonelist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ BIGGEST

◆ DAY_OF_YEAR

◆ JULIAN_DAY

◆ MONTH_NTH_DAY_OF_WEEK

◆ MY_TZNAME_MAX

◆ OPEN_MODE

◆ SP_HEAP_FREE

◆ SP_HEAP_INIT

◆ SP_STACK_CHECK

◆ SP_STACK_FLAG

◆ SP_STACK_INIT

◆ TZ_ABBR_CHAR_SET

◆ TZ_ABBR_ERR_CHAR

◆ TZ_ABBR_MAX_LEN

◆ TZ_STRLEN_MAX

◆ TZDEFRULESTRING

Function Documentation

◆ add_notify()

◆ ast_get_dst_info()

◆ ast_localtime()

◆ ast_localtime_wakeup_monitor()

◆ ast_mktime()

◆ ast_setlocale()

◆ ast_strftime()

◆ ast_strftime_locale()

◆ ast_strptime()

◆ ast_strptime_locale()

◆ ast_tzset()

◆ clean_time_zones()

◆ common_startup()

◆ detzcode()

◆ detzcode64()

◆ differ_by_repeat()

◆ find_by_locale()

◆ find_by_name()

◆ getnum()

◆ getoffset()

◆ getqzname()

◆ getrule()

◆ getsecs()

◆ getzname()

◆ gmtload()

◆ gmtsub()

◆ increment_overflow()

◆ inotify_daemon()

◆ leaps_thru_end_of()

◆ localsub()

◆ long_increment_overflow()

◆ long_normalize_overflow()

◆ normalize_overflow()

◆ P() [1/24]

◆ P() [2/24]

◆ P() [3/24]

◆ P() [4/24]

◆ P() [5/24]

◆ P() [6/24]

◆ P() [7/24]

◆ P() [8/24]

◆ P() [9/24]

◆ P() [10/24]

◆ P() [11/24]

◆ P() [12/24]

◆ P() [13/24]

◆ P() [14/24]

◆ P() [15/24]

◆ P() [16/24]

◆ P() [17/24]

◆ P() [18/24]

◆ P() [19/24]

◆ P() [20/24]

◆ P() [21/24]

◆ P() [22/24]

◆ P() [23/24]

◆ P() [24/24]