switch_time.c File Reference

#include <switch.h>
#include <stdio.h>
#include "private/switch_apr_pvt.h"
#include "private/switch_core_pvt.h"
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <assert.h>

Include dependency graph for switch_time.c:

Go to the source code of this file.

Data Structures
struct	timer_private
struct	timer_matrix
struct	switch_timezones_list_t
struct	rule
struct	ttinfo
struct	lsinfo
struct	state

Macros
#define	DISABLE_1MS_COND
#define	UINT32_MAX   0xffffffff
#define	MAX_TICK   UINT32_MAX - 1024
#define	MAX_ELEMENTS   3600
#define	IDLE_SPEED   100
#define	calc_step()   if (step > 11) step -= 10; else if (step > 1) step--
#define	check_roll()
#define	TRUE   1
#define	FALSE   0
#define	TZ_MAX_TIMES   370
#define	TZ_MAX_TYPES   256 /* Limited by what (unsigned char)'s can hold */
#define	TZ_MAX_CHARS   50 /* Maximum number of abbreviation characters */
#define	TZ_MAX_LEAPS   50 /* Maximum number of leap second corrections */
#define	MY_TZNAME_MAX   255
#define	SECSPERMIN   60
#define	MINSPERHOUR   60
#define	HOURSPERDAY   24
#define	DAYSPERWEEK   7
#define	DAYSPERNYEAR   365
#define	DAYSPERLYEAR   366
#define	SECSPERHOUR   (SECSPERMIN * MINSPERHOUR)
#define	SECSPERDAY   ((long) SECSPERHOUR * HOURSPERDAY)
#define	MONSPERYEAR   12
#define	JULIAN_DAY   0 /* Jn - Julian day */
#define	DAY_OF_YEAR   1 /* n - day of year */
#define	MONTH_NTH_DAY_OF_WEEK   2 /* Mm.n.d - month, week, day of week */
#define	EPOCH_YEAR   1970
#define	EPOCH_WDAY   TM_THURSDAY
#define	TZDEFRULES   "posixrules"
#define	TZDEFRULESTRING   ",M4.1.0,M10.5.0"
#define	is_digit(c)   ((unsigned)(c) - '0' <= 9)
#define	BIGGEST(a, b)   (((a) > (b)) ? (a) : (b))
#define	isleap(y)   (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
#define	INITIALIZE(x)
#define	TM_SUNDAY   0
#define	TM_MONDAY   1
#define	TM_TUESDAY   2
#define	TM_WEDNESDAY   3
#define	TM_THURSDAY   4
#define	TM_FRIDAY   5
#define	TM_SATURDAY   6
#define	TM_JANUARY   0
#define	TM_FEBRUARY   1
#define	TM_MARCH   2
#define	TM_APRIL   3
#define	TM_MAY   4
#define	TM_JUNE   5
#define	TM_JULY   6
#define	TM_AUGUST   7
#define	TM_SEPTEMBER   8
#define	TM_OCTOBER   9
#define	TM_NOVEMBER   10
#define	TM_DECEMBER   11
#define	TM_YEAR_BASE   1900
#define	EPOCH_YEAR   1970
#define	EPOCH_WDAY   TM_THURSDAY
#define	CHARS_DEF   BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))
#define	switch_assert(expr)   assert(expr)
#define	LEAPS_THRU_END_OF(y)   ((y) / 4 - (y) / 100 + (y) / 400)

Typedefs
typedef struct timer_private	timer_private_t
typedef struct timer_matrix	timer_matrix_t

Functions
	SWITCH_MODULE_LOAD_FUNCTION (softtimer_load)
	SWITCH_MODULE_SHUTDOWN_FUNCTION (softtimer_shutdown)
	SWITCH_MODULE_RUNTIME_FUNCTION (softtimer_runtime)
	SWITCH_MODULE_DEFINITION (CORE_SOFTTIMER_MODULE, softtimer_load, softtimer_shutdown, softtimer_runtime)
static switch_time_t	time_now (int64_t offset)
void	switch_os_yield (void)
static void	do_sleep (switch_interval_time_t t)
static switch_interval_time_t	average_time (switch_interval_time_t t, int reps)
void	switch_time_calibrate_clock (void)
switch_time_t	switch_micro_time_now (void)
	Get the current epoch time in microseconds. More...
switch_time_t	switch_mono_micro_time_now (void)
time_t	switch_epoch_time_now (time_t *t)
	Get the current epoch time. More...
void	switch_time_set_monotonic (switch_bool_t enable)
void	switch_time_set_use_system_time (switch_bool_t enable)
void	switch_time_set_timerfd (int enable)
void	switch_time_set_matrix (switch_bool_t enable)
void	switch_time_set_nanosleep (switch_bool_t enable)
void	switch_time_set_cond_yield (switch_bool_t enable)
static switch_status_t	timer_generic_sync (switch_timer_t *timer)
switch_time_t	switch_time_ref (void)
void	switch_time_sync (void)
void	switch_micro_sleep (switch_interval_time_t t)
void	switch_sleep (switch_interval_time_t t)
void	switch_cond_next (void)
void	switch_cond_yield (switch_interval_time_t t)
static switch_status_t	timer_init (switch_timer_t *timer)
static switch_status_t	timer_step (switch_timer_t *timer)
static switch_status_t	timer_sync (switch_timer_t *timer)
static switch_status_t	timer_next (switch_timer_t *timer)
static switch_status_t	timer_check (switch_timer_t *timer, switch_bool_t step)
static switch_status_t	timer_destroy (switch_timer_t *timer)
static void	win32_init_timers (void)
static void	tm2switchtime (struct tm *tm, switch_time_exp_t *xt)
const char *	switch_lookup_timezone (const char *tz_name)
void	switch_load_timezones (switch_bool_t reload)
static void	event_handler (switch_event_t *event)
static void	tztime (const time_t *const timep, const char *tzstring, struct tm *const tmp)
switch_status_t	switch_time_exp_tz_name (const char *tz, switch_time_exp_t *tm, switch_time_t thetime)
switch_status_t	switch_strftime_tz (const char *tz, const char *format, char *date, size_t len, switch_time_t thetime)
static const char *	getzname (register const char *strp)
static const char *	getnum (register const char *strp, int *const nump, const int min, const int max)
static const char *	getsecs (register const char *strp, long *const secsp)
static const char *	getoffset (register const char *strp, long *const offsetp)
static const char *	getrule (const char *strp, register struct rule *const rulep)
static time_t	transtime (const time_t janfirst, const int year, register const struct rule *const rulep, const long offset)
static int	tzparse (const char *name, register struct state *const sp, const int lastditch)
static void	timesub (const time_t *const timep, const long offset, register const struct state *const sp, register struct tm *const tmp)

Variables
static int	MONO = 0
static int	SYSTEM_TIME = 0
static int	TFD = 0
static int	NANO = 0
static int	OFFSET = 0
static int	COND = 1
static int	MATRIX = 1
static switch_memory_pool_t *	module_pool = NULL
struct {
int32_t   RUNNING
int32_t   STARTED
int32_t   use_cond_yield
switch_mutex_t *   mutex
uint32_t   timer_count
}	globals
static timer_matrix_t	TIMER_MATRIX [MAX_ELEMENTS+1]
static switch_time_t	last_time = 0
static switch_timezones_list_t	TIMEZONES_LIST = { 0 }
static switch_event_node_t *	NODE = NULL
static const char	gmt [] = "GMT"
static const int	mon_lengths [2][MONSPERYEAR]
static const int	year_lengths [2]

Macro Definition Documentation

BIGGEST

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

Definition at line 1747 of file switch_time.c.

calc_step

#define calc_step

(

)

if (step > 11) step -= 10; else if (step > 1) step--

Definition at line 207 of file switch_time.c.

Referenced by switch_time_calibrate_clock().

CHARS_DEF

#define CHARS_DEF   BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))

Definition at line 1814 of file switch_time.c.

check_roll

#define check_roll

(

)

Value:

if (private_info->roll < TIMER_MATRIX[timer->interval].roll) {  \
                private_info->roll++;                                                                                   \
                private_info->reference = private_info->start = (switch_size_t)TIMER_MATRIX[timer->interval].tick;      \
                private_info->start--; /* Must have a diff */                                   \
        }                                                                                                                                       \

Definition at line 768 of file switch_time.c.

Referenced by timer_check(), timer_next(), and timer_step().

DAY_OF_YEAR

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

Definition at line 1712 of file switch_time.c.

Referenced by getrule(), and transtime().

DAYSPERLYEAR

#define DAYSPERLYEAR   366

Definition at line 1706 of file switch_time.c.

Referenced by getrule().

DAYSPERNYEAR

#define DAYSPERNYEAR   365

Definition at line 1705 of file switch_time.c.

Referenced by getrule(), and timesub().

DAYSPERWEEK

#define DAYSPERWEEK   7

Definition at line 1704 of file switch_time.c.

Referenced by getrule(), getsecs(), timesub(), and transtime().

DISABLE_1MS_COND

#define DISABLE_1MS_COND

Definition at line 44 of file switch_time.c.

EPOCH_WDAY [1/2]

#define EPOCH_WDAY   TM_THURSDAY

Definition at line 1805 of file switch_time.c.

Referenced by timesub().

EPOCH_WDAY [2/2]

#define EPOCH_WDAY   TM_THURSDAY

Definition at line 1805 of file switch_time.c.

EPOCH_YEAR [1/2]

#define EPOCH_YEAR   1970

Definition at line 1804 of file switch_time.c.

Referenced by timesub(), and tzparse().

EPOCH_YEAR [2/2]

#define EPOCH_YEAR   1970

Definition at line 1804 of file switch_time.c.

FALSE

#define FALSE   0

Definition at line 1652 of file switch_time.c.

Referenced by tzparse(), and tztime().

HOURSPERDAY

#define HOURSPERDAY   24

Definition at line 1703 of file switch_time.c.

Referenced by getsecs().

IDLE_SPEED

#define IDLE_SPEED   100

Definition at line 54 of file switch_time.c.

INITIALIZE

#define INITIALIZE

(

x

)

Definition at line 1776 of file switch_time.c.

Referenced by transtime(), and tzparse().

is_digit

#define is_digit

(

c

)

((unsigned)(c) - '0' <= 9)

Definition at line 1745 of file switch_time.c.

Referenced by getnum(), getrule(), and getzname().

isleap

#define isleap

(

y

)

(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))

Definition at line 1749 of file switch_time.c.

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

JULIAN_DAY

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

Definition at line 1711 of file switch_time.c.

Referenced by getrule(), and transtime().

LEAPS_THRU_END_OF

#define LEAPS_THRU_END_OF

(

y

)

((y) / 4 - (y) / 100 + (y) / 400)

Referenced by timesub().

MAX_ELEMENTS

#define MAX_ELEMENTS   3600

Definition at line 53 of file switch_time.c.

Referenced by SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_destroy().

MAX_TICK

#define MAX_TICK   UINT32_MAX - 1024

Definition at line 51 of file switch_time.c.

Referenced by SWITCH_MODULE_RUNTIME_FUNCTION().

MINSPERHOUR

#define MINSPERHOUR   60

Definition at line 1702 of file switch_time.c.

Referenced by getsecs().

MONSPERYEAR

#define MONSPERYEAR   12

Definition at line 1709 of file switch_time.c.

Referenced by getrule().

MONTH_NTH_DAY_OF_WEEK

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

Definition at line 1713 of file switch_time.c.

Referenced by getrule(), and transtime().

MY_TZNAME_MAX

#define MY_TZNAME_MAX   255

Definition at line 1697 of file switch_time.c.

SECSPERDAY

#define SECSPERDAY   ((long) SECSPERHOUR * HOURSPERDAY)

Definition at line 1708 of file switch_time.c.

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

SECSPERHOUR

#define SECSPERHOUR   (SECSPERMIN * MINSPERHOUR)

Definition at line 1707 of file switch_time.c.

Referenced by getrule(), getsecs(), timesub(), and tzparse().

SECSPERMIN

#define SECSPERMIN   60

Definition at line 1701 of file switch_time.c.

Referenced by getsecs(), and timesub().

switch_assert

#define switch_assert

(

expr

)

assert(expr)

Definition at line 2343 of file switch_time.c.

Referenced by timesub().

TM_APRIL

#define TM_APRIL   3

Definition at line 1792 of file switch_time.c.

TM_AUGUST

#define TM_AUGUST   7

Definition at line 1796 of file switch_time.c.

TM_DECEMBER

#define TM_DECEMBER   11

Definition at line 1800 of file switch_time.c.

TM_FEBRUARY

#define TM_FEBRUARY   1

Definition at line 1790 of file switch_time.c.

TM_FRIDAY

#define TM_FRIDAY   5

Definition at line 1786 of file switch_time.c.

TM_JANUARY

#define TM_JANUARY   0

Definition at line 1789 of file switch_time.c.

TM_JULY

#define TM_JULY   6

Definition at line 1795 of file switch_time.c.

TM_JUNE

#define TM_JUNE   5

Definition at line 1794 of file switch_time.c.

TM_MARCH

#define TM_MARCH   2

Definition at line 1791 of file switch_time.c.

TM_MAY

#define TM_MAY   4

Definition at line 1793 of file switch_time.c.

TM_MONDAY

#define TM_MONDAY   1

Definition at line 1782 of file switch_time.c.

TM_NOVEMBER

#define TM_NOVEMBER   10

Definition at line 1799 of file switch_time.c.

TM_OCTOBER

#define TM_OCTOBER   9

Definition at line 1798 of file switch_time.c.

TM_SATURDAY

#define TM_SATURDAY   6

Definition at line 1787 of file switch_time.c.

TM_SEPTEMBER

#define TM_SEPTEMBER   8

Definition at line 1797 of file switch_time.c.

TM_SUNDAY

#define TM_SUNDAY   0

Definition at line 1781 of file switch_time.c.

TM_THURSDAY

#define TM_THURSDAY   4

Definition at line 1785 of file switch_time.c.

TM_TUESDAY

#define TM_TUESDAY   2

Definition at line 1783 of file switch_time.c.

TM_WEDNESDAY

#define TM_WEDNESDAY   3

Definition at line 1784 of file switch_time.c.

TM_YEAR_BASE

#define TM_YEAR_BASE   1900

Definition at line 1802 of file switch_time.c.

Referenced by timesub().

TRUE

#define TRUE   1

Definition at line 1648 of file switch_time.c.

Referenced by tzparse().

TZ_MAX_CHARS

#define TZ_MAX_CHARS   50 /* Maximum number of abbreviation characters */

Definition at line 1684 of file switch_time.c.

TZ_MAX_LEAPS

#define TZ_MAX_LEAPS   50 /* Maximum number of leap second corrections */

Definition at line 1689 of file switch_time.c.

TZ_MAX_TIMES

#define TZ_MAX_TIMES   370

Definition at line 1664 of file switch_time.c.

Referenced by tzparse().

TZ_MAX_TYPES

#define TZ_MAX_TYPES   256 /* Limited by what (unsigned char)'s can hold */

Definition at line 1670 of file switch_time.c.

TZDEFRULES

#define TZDEFRULES   "posixrules"

Definition at line 1730 of file switch_time.c.

TZDEFRULESTRING

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

Definition at line 1741 of file switch_time.c.

UINT32_MAX

#define UINT32_MAX   0xffffffff

Definition at line 48 of file switch_time.c.

Referenced by timer_step().

Typedef Documentation

timer_matrix_t

typedef struct timer_matrix timer_matrix_t

Definition at line 136 of file switch_time.c.

timer_private_t

typedef struct timer_private timer_private_t

Definition at line 126 of file switch_time.c.

Function Documentation

average_time()

static switch_interval_time_t average_time ( switch_interval_time_t  t, int  reps  )

static

Definition at line 191 of file switch_time.c.

References do_sleep(), timer_private::start, and switch_time_ref().

Referenced by switch_time_calibrate_clock().

{
        int x = 0;
        switch_time_t start, stop, sum = 0;

        for (x = 0; x < reps; x++) {
                start = switch_time_ref();
                do_sleep(t);
                stop = switch_time_ref();
                sum += (stop - start);
        }

        return sum / reps;

}

do_sleep()

static void do_sleep ( switch_interval_time_t  t )

static

Definition at line 151 of file switch_time.c.

References NANO, and OFFSET.

Referenced by average_time(), switch_cond_next(), switch_cond_yield(), switch_micro_sleep(), SWITCH_MODULE_RUNTIME_FUNCTION(), SWITCH_MODULE_SHUTDOWN_FUNCTION(), switch_sleep(), switch_time_calibrate_clock(), timer_init(), and timer_next().

{
#if defined(HAVE_CLOCK_NANOSLEEP) || defined(DARWIN)
        struct timespec ts;
#endif

#if defined(WIN32)
        if (t < 1000) {
                t = 1000;
        }
#endif

#if !defined(DARWIN)
        if (t > 100000 || !NANO) {
                fspr_sleep(t);
                return;
        }
#endif

#if defined(HAVE_CLOCK_NANOSLEEP)
        t -= OFFSET;
        ts.tv_sec = t / 1000000;
        ts.tv_nsec = ((t % 1000000) * 1000);
        clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);

#elif defined(DARWIN)
        t -= OFFSET;
        ts.tv_sec = t / APR_USEC_PER_SEC;
        ts.tv_nsec = (t % APR_USEC_PER_SEC) * 850;
        nanosleep(&ts, NULL);
#else
        fspr_sleep(t);
#endif

#if defined(DARWIN)
        sched_yield();
#endif

}

event_handler()

static void event_handler ( switch_event_t *  event )

static

Definition at line 1439 of file switch_time.c.

References globals, switch_load_timezones(), switch_mutex_lock(), switch_mutex_unlock(), and tztime().

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        switch_mutex_lock(globals.mutex);
        switch_load_timezones(1);
        switch_mutex_unlock(globals.mutex);
}

getnum()

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

static

Definition at line 1889 of file switch_time.c.

References is_digit.

Referenced by getrule(), and getsecs().

{
        register char c;
        register 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;
}

getoffset()

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

static

Definition at line 1956 of file switch_time.c.

References getsecs().

Referenced by tzparse().

{
        register 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;
}

getrule()

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

static

Definition at line 1980 of file switch_time.c.

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

Referenced by tzparse().

{
        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;
}

getsecs()

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

static

Definition at line 1917 of file switch_time.c.

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

Referenced by getoffset(), and getrule().

{
        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;
}

getzname()

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

static

Definition at line 1872 of file switch_time.c.

References is_digit.

Referenced by tzparse().

{
        register char c;

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

switch_load_timezones()

void switch_load_timezones

(

switch_bool_t

reload

)

Definition at line 1397 of file switch_time.c.

References switch_timezones_list_t::hash, memset(), name, switch_xml::next, switch_timezones_list_t::pool, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_core_hash_destroy(), switch_core_hash_init, switch_core_hash_insert, switch_core_new_memory_pool, switch_core_strdup, SWITCH_LOG_INFO, switch_log_printf(), switch_xml_attr(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), value, and zstr.

Referenced by event_handler(), and SWITCH_MODULE_LOAD_FUNCTION().

{
        switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, cfg = NULL;
        unsigned total = 0;

        if (TIMEZONES_LIST.hash) {
                switch_core_hash_destroy(&TIMEZONES_LIST.hash);
        }

        if (TIMEZONES_LIST.pool) {
                switch_core_destroy_memory_pool(&TIMEZONES_LIST.pool);
        }

        memset(&TIMEZONES_LIST, 0, sizeof(TIMEZONES_LIST));
        switch_core_new_memory_pool(&TIMEZONES_LIST.pool);
        switch_core_hash_init(&TIMEZONES_LIST.hash);

        if ((xml = switch_xml_open_cfg("timezones.conf", &cfg, NULL))) {
                if ((x_lists = switch_xml_child(cfg, "timezones"))) {
                        for (x_list = switch_xml_child(x_lists, "zone"); x_list; x_list = x_list->next) {
                                const char *name = switch_xml_attr(x_list, "name");
                                const char *value = switch_xml_attr(x_list, "value");

                                if (zstr(name)) {
                                        continue;
                                }

                                if (zstr(value)) {
                                        continue;
                                }

                                switch_core_hash_insert(TIMEZONES_LIST.hash, name, switch_core_strdup(TIMEZONES_LIST.pool, value));
                                total++;
                        }
                }

                switch_xml_free(xml);
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Timezone %sloaded %d definitions\n", reload ? "re" : "", total);
}

SWITCH_MODULE_DEFINITION()

SWITCH_MODULE_DEFINITION	(	CORE_SOFTTIMER_MODULE	,
		softtimer_load	,
		softtimer_shutdown	,
		softtimer_runtime
	)

SWITCH_MODULE_LOAD_FUNCTION()

SWITCH_MODULE_LOAD_FUNCTION

(

softtimer_load

)

Definition at line 1514 of file switch_time.c.

References event_handler(), globals, switch_runtime::initiated, switch_timer_interface::interface_name, switch_runtime::memory_pool, memset(), module_pool, MONO, pool, runtime, SCF_CALIBRATE_CLOCK, SCF_USE_CLOCK_RT, SCF_USE_HEAVY_TIMING, SCF_USE_WIN32_MONOTONIC, SWITCH_CHANNEL_LOG, switch_clear_flag, switch_event_bind_removable(), SWITCH_EVENT_RELOADXML, SWITCH_FALSE, switch_load_timezones(), switch_loadable_module_create_interface(), switch_loadable_module_create_module_interface(), SWITCH_LOG_CONSOLE, SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mono_micro_time_now(), switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_time_calibrate_clock(), switch_time_set_cond_yield(), switch_time_set_nanosleep(), SWITCH_TIMER_INTERFACE, TFD, switch_timer_interface::timer_check, timer_check(), switch_timer_interface::timer_destroy, timer_destroy(), switch_timer_interface::timer_init, timer_init(), switch_timer_interface::timer_next, timer_next(), switch_timer_interface::timer_step, timer_step(), switch_timer_interface::timer_sync, timer_sync(), and win32_init_timers().

{
        switch_timer_interface_t *timer_interface;
        module_pool = pool;

#ifdef WIN32
        timeBeginPeriod(1);

        InitializeCriticalSection(&timer_section);

        win32_init_timers(); /* Init timers for Windows, if we should use timeGetTime() or QueryPerformanceCounters() */
#endif

        memset(&globals, 0, sizeof(globals));
        switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);

        if ((switch_event_bind_removable(modname, SWITCH_EVENT_RELOADXML, NULL, event_handler, NULL, &NODE) != SWITCH_STATUS_SUCCESS)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't bind!\n");
        }
        switch_load_timezones(0);

        /* connect my internal structure to the blank pointer passed to me */
        *module_interface = switch_loadable_module_create_module_interface(pool, modname);
        timer_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_TIMER_INTERFACE);
        timer_interface->interface_name = "soft";
        timer_interface->timer_init = timer_init;
        timer_interface->timer_next = timer_next;
        timer_interface->timer_step = timer_step;
        timer_interface->timer_sync = timer_sync;
        timer_interface->timer_check = timer_check;
        timer_interface->timer_destroy = timer_destroy;

        if (!switch_test_flag((&runtime), SCF_USE_CLOCK_RT)) {
                switch_time_set_nanosleep(SWITCH_FALSE);
        }

        if (switch_test_flag((&runtime), SCF_USE_HEAVY_TIMING)) {
                switch_time_set_cond_yield(SWITCH_FALSE);
        }

        if (TFD) {
                switch_clear_flag((&runtime), SCF_CALIBRATE_CLOCK);
        }

#ifdef WIN32
        if (switch_test_flag((&runtime), SCF_USE_WIN32_MONOTONIC)) {
                MONO = 1;

                if (win32_use_qpc) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Enabled Windows monotonic clock, using QueryPerformanceCounter()\n");
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Enabled Windows monotonic clock, using timeGetTime()\n");
                }

                runtime.initiated = switch_mono_micro_time_now(); /* Update mono_initiated, since now is the first time the real clock is enabled */
        }

        /* No need to calibrate clock in Win32, we will only sleep ms anyway, it's just not accurate enough */
        switch_clear_flag((&runtime), SCF_CALIBRATE_CLOCK);
#endif

        if (switch_test_flag((&runtime), SCF_CALIBRATE_CLOCK)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Calibrating timer, please wait...\n");
                switch_time_calibrate_clock();
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clock calibration disabled.\n");
        }

        /* indicate that the module should continue to be loaded */
        return SWITCH_STATUS_SUCCESS;
}

SWITCH_MODULE_RUNTIME_FUNCTION()

SWITCH_MODULE_RUNTIME_FUNCTION

(

softtimer_runtime

)

Definition at line 1038 of file switch_time.c.

References COND, count, do_sleep(), globals, switch_runtime::initiated, MATRIX, MAX_ELEMENTS, MAX_TICK, switch_runtime::microseconds_per_tick, module_pool, MONO, mutex, NANO, switch_runtime::offset, switch_runtime::profile_time, switch_runtime::profile_timer, switch_runtime::reference, timer_matrix::roll, runtime, switch_session_manager::session_count, switch_runtime::session_hash_mutex, session_manager, switch_runtime::sessions_peak_fivemin, switch_runtime::sps, switch_runtime::sps_last, switch_runtime::sps_peak, switch_runtime::sps_peak_fivemin, switch_runtime::sps_total, SWITCH_CHANNEL_LOG, switch_core_thread_set_cpu_affinity(), switch_delete_profile_timer(), switch_get_system_idle_time(), SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mono_micro_time_now(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_trylock(), switch_mutex_unlock(), switch_new_profile_timer(), switch_os_yield(), SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TERM, switch_thread_cond_broadcast(), switch_thread_cond_create(), switch_time_now(), switch_time_ref(), switch_time_sync(), TFD, switch_runtime::throttle_mutex, timer_matrix::tick, time_now(), switch_runtime::time_sync, switch_runtime::timer_affinity, switch_runtime::timestamp, switch_runtime::tipping_point, and win32_init_timers().

{
        switch_time_t too_late = runtime.microseconds_per_tick * 1000;
        uint32_t current_ms = 0;
        uint32_t x, tick = 0, sps_interval_ticks = 0;
        switch_time_t ts = 0, last = 0;
        int fwd_errs = 0, rev_errs = 0;
        int profile_tick = 0;
        int tfd = -1;
        uint32_t time_sync;

#ifdef HAVE_TIMERFD_CREATE
        int last_MICROSECONDS_PER_TICK = runtime.microseconds_per_tick;

        struct itimerspec spec = { { 0 } };

        if (MONO && TFD) {
                tfd = timerfd_create(CLOCK_MONOTONIC, 0);

                if (tfd > -1) {
                        spec.it_interval.tv_sec = 0;
                        spec.it_interval.tv_nsec = runtime.microseconds_per_tick * 1000;
                        spec.it_value.tv_sec = 0;
                        spec.it_value.tv_nsec = 100000;

                        if (timerfd_settime(tfd, 0, &spec, NULL)) {
                                close(tfd);
                                tfd = -1;
                        }
                }

                if (tfd > -1) MATRIX = 0;
        }
#else
        tfd = -1;
#endif

        runtime.profile_timer = switch_new_profile_timer();
        switch_get_system_idle_time(runtime.profile_timer, &runtime.profile_time);

        if (runtime.timer_affinity > -1) {
                switch_core_thread_set_cpu_affinity(runtime.timer_affinity);
        }

        switch_time_sync();

        globals.STARTED = globals.RUNNING = 1;
        switch_mutex_lock(runtime.throttle_mutex);
        runtime.sps = runtime.sps_total;
        switch_mutex_unlock(runtime.throttle_mutex);

        if (MONO) {
                int loops;
                for (loops = 0; loops < 3; loops++) {
                        ts = switch_time_ref();
                        /* if it returns the same value every time it won't be of much use. */
                        if (ts == last) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Broken MONOTONIC Clock Detected!, Support Disabled.\n");
                                MONO = 0;
                                NANO = 0;
                                runtime.reference = switch_time_now();
                                runtime.initiated = runtime.reference;
                                break;
                        }
                        do_sleep(runtime.microseconds_per_tick);
                        last = ts;
                }
        }

        last = 0;
        fwd_errs = rev_errs = 0;

#ifndef DISABLE_1MS_COND
        if (!NANO) {
                switch_mutex_init(&TIMER_MATRIX[1].mutex, SWITCH_MUTEX_NESTED, module_pool);
                switch_thread_cond_create(&TIMER_MATRIX[1].cond, module_pool);
        }
#endif


        switch_time_sync();
        time_sync = runtime.time_sync;

        globals.use_cond_yield = COND;
        globals.RUNNING = 1;

        while (globals.RUNNING == 1) {

#ifdef HAVE_TIMERFD_CREATE
                if (last_MICROSECONDS_PER_TICK != runtime.microseconds_per_tick) {
                        spec.it_interval.tv_nsec = runtime.microseconds_per_tick * 1000;
                        timerfd_settime(tfd, 0, &spec, NULL);
                }

                last_MICROSECONDS_PER_TICK = runtime.microseconds_per_tick;
#endif

                runtime.reference += runtime.microseconds_per_tick;

                while (((ts = time_now(runtime.offset)) + 100) < runtime.reference) {
                        if (ts < last) {
                                if (MONO) {
                                        runtime.initiated = switch_mono_micro_time_now() - ((last - runtime.offset) - runtime.initiated);

                                        if (time_sync == runtime.time_sync) { /* Only resync if not in the middle of switch_time_sync() already */
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Virtual Migration Detected! Syncing Clock\n");
                                                win32_init_timers(); /* Make sure to reinit timers on WIN32 */
                                                switch_time_sync();
                                                time_sync = runtime.time_sync;
                                        }
                                } else {
                                        int64_t diff = (int64_t) (ts - last);
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Reverse Clock Skew Detected!\n");
                                        runtime.reference = switch_time_now();
                                        current_ms = 0;
                                        tick = 0;
                                        runtime.initiated += diff;
                                        rev_errs++;
                                }

                                if (!MONO || time_sync == runtime.time_sync) {
#if defined(HAVE_CLOCK_NANOSLEEP)
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
                                                                          "If you see this message many times try setting the param enable-clock-nanosleep to true in switch.conf.xml or consider a nicer machine to run me on.\n");
#else
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
                                                                          "If you see this message many times consider a nicer machine to run me on.\n");
#endif
                                }
                        } else {
                                rev_errs = 0;
                        }

                        if (runtime.tipping_point && globals.timer_count >= runtime.tipping_point) {
                                switch_os_yield();
                        } else {
                                if (tfd > -1 && globals.RUNNING == 1) {
                                        uint64_t exp;
                                        read(tfd, &exp, sizeof(exp));
                                        (void)exp;
                                } else {
                                        switch_time_t timediff = runtime.reference - ts;

                                        if (runtime.microseconds_per_tick < timediff) {
                                                /* Only sleep for runtime.microseconds_per_tick if this value is lower then the actual time diff we need to sleep */
                                                do_sleep(runtime.microseconds_per_tick);
                                        } else {
#ifdef WIN32
                                                /* Windows only sleeps in ms precision, try to round the usec value as good as possible */
                                                do_sleep((switch_interval_time_t)floor((timediff / 1000.0) + 0.5) * 1000);
#else
                                                do_sleep(timediff);
#endif
                                        }
                                }
                        }

                        last = ts;
                }

                if (ts > (runtime.reference + too_late)) {
                        if (MONO) {
                                runtime.initiated = switch_mono_micro_time_now() - (((runtime.reference - runtime.microseconds_per_tick) - runtime.offset) - runtime.initiated);

                                if (time_sync == runtime.time_sync) { /* Only resync if not in the middle of switch_time_sync() already */
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Virtual Migration Detected! Syncing Clock\n");
                                        win32_init_timers(); /* Make sure to reinit timers on WIN32 */
                                        switch_time_sync();
                                        time_sync = runtime.time_sync;
                                }
                        } else {
                                switch_time_t diff = ts - (runtime.reference - runtime.microseconds_per_tick);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Forward Clock Skew Detected!\n");
                                fwd_errs++;
                                runtime.reference = switch_time_now();
                                current_ms = 0;
                                tick = 0;
                                runtime.initiated += diff;
                        }
                } else {
                        fwd_errs = 0;
                }

                if (fwd_errs > 9 || rev_errs > 9) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Auto Re-Syncing clock.\n");
                        switch_time_sync();
                        time_sync = runtime.time_sync;
                        fwd_errs = rev_errs = 0;
                }

                runtime.timestamp = ts;
                current_ms += (runtime.microseconds_per_tick / 1000);
                tick++;

                if (time_sync < runtime.time_sync) {
                        time_sync++; /* Only step once for each loop, we want to make sure to keep this thread safe */
                }

                if (tick >= (1000000 / runtime.microseconds_per_tick)) {
                        if (++profile_tick == 1) {
                                switch_get_system_idle_time(runtime.profile_timer, &runtime.profile_time);
                                profile_tick = 0;
                        }

                        if (runtime.sps <= 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Rate of %d!\n", runtime.sps_total);
                        }

                        /* These two mutexes must be held in exact order: session_hash_mutex and then throttle_mutex. See switch_core_session_request_uuid() */
                        switch_mutex_lock(runtime.session_hash_mutex);
                        switch_mutex_lock(runtime.throttle_mutex);
                        runtime.sps_last = runtime.sps_total - runtime.sps;

                        if (sps_interval_ticks >= 300) {
                                runtime.sps_peak_fivemin = 0;
                                sps_interval_ticks = 0;
                                /* This line is protected by runtime.session_hash_mutex */
                                runtime.sessions_peak_fivemin = session_manager.session_count;
                        }

                        sps_interval_ticks++;

                        if (runtime.sps_last > runtime.sps_peak_fivemin) {
                                runtime.sps_peak_fivemin = runtime.sps_last;
                        }

                        if (runtime.sps_last > runtime.sps_peak) {
                                runtime.sps_peak = runtime.sps_last;
                        }
                        runtime.sps = runtime.sps_total;
                        switch_mutex_unlock(runtime.throttle_mutex);
                        switch_mutex_unlock(runtime.session_hash_mutex);
                        tick = 0;
                }
#ifndef DISABLE_1MS_COND
                TIMER_MATRIX[1].tick++;
                if (switch_mutex_trylock(TIMER_MATRIX[1].mutex) == SWITCH_STATUS_SUCCESS) {
                        switch_thread_cond_broadcast(TIMER_MATRIX[1].cond);
                        switch_mutex_unlock(TIMER_MATRIX[1].mutex);
                }
                if (TIMER_MATRIX[1].tick == MAX_TICK) {
                        TIMER_MATRIX[1].tick = 0;
                        TIMER_MATRIX[1].roll++;
                }
#endif


                if (MATRIX && (current_ms % (runtime.microseconds_per_tick / 1000)) == 0) {
                        for (x = (runtime.microseconds_per_tick / 1000); x <= MAX_ELEMENTS; x += (runtime.microseconds_per_tick / 1000)) {
                                if ((current_ms % x) == 0) {
                                        if (TIMER_MATRIX[x].count) {
                                                TIMER_MATRIX[x].tick++;
#ifdef DISABLE_1MS_COND

                                                if (TIMER_MATRIX[x].mutex && switch_mutex_trylock(TIMER_MATRIX[x].mutex) == SWITCH_STATUS_SUCCESS) {
                                                        switch_thread_cond_broadcast(TIMER_MATRIX[x].cond);
                                                        switch_mutex_unlock(TIMER_MATRIX[x].mutex);
                                                }
#endif
                                                if (TIMER_MATRIX[x].tick == MAX_TICK) {
                                                        TIMER_MATRIX[x].tick = 0;
                                                        TIMER_MATRIX[x].roll++;
                                                }
                                        }
                                }
                        }
                }

                if (current_ms == MAX_ELEMENTS) {
                        current_ms = 0;
                }
        }

        globals.use_cond_yield = 0;

        for (x = (runtime.microseconds_per_tick / 1000); x <= MAX_ELEMENTS; x += (runtime.microseconds_per_tick / 1000)) {
                if (TIMER_MATRIX[x].mutex && switch_mutex_trylock(TIMER_MATRIX[x].mutex) == SWITCH_STATUS_SUCCESS) {
                        switch_thread_cond_broadcast(TIMER_MATRIX[x].cond);
                        switch_mutex_unlock(TIMER_MATRIX[x].mutex);
                }
        }

        if (tfd > -1) {
                close(tfd);
        }


        switch_mutex_lock(globals.mutex);
        globals.RUNNING = 0;
        switch_mutex_unlock(globals.mutex);

        switch_delete_profile_timer(&runtime.profile_timer);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Soft timer thread exiting.\n");

        return SWITCH_STATUS_TERM;
}

SWITCH_MODULE_SHUTDOWN_FUNCTION()

SWITCH_MODULE_SHUTDOWN_FUNCTION

(

softtimer_shutdown

)

Definition at line 1586 of file switch_time.c.

References do_sleep(), globals, switch_timezones_list_t::hash, switch_timezones_list_t::pool, switch_core_destroy_memory_pool, switch_core_hash_destroy(), switch_event_unbind(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

{
        globals.use_cond_yield = 0;

        if (globals.RUNNING == 1) {
                switch_mutex_lock(globals.mutex);
                globals.RUNNING = -1;
                switch_mutex_unlock(globals.mutex);

                while (globals.RUNNING == -1) {
                        do_sleep(10000);
                }
        }
#if defined(WIN32)
        timeEndPeriod(1);
        win32_tick_time_since_start = -1; /* we are not initialized anymore */
        DeleteCriticalSection(&timer_section);
#endif

        if (NODE) {
                switch_event_unbind(&NODE);
        }

        switch_mutex_lock(globals.mutex);
        if (TIMEZONES_LIST.hash) {
                switch_core_hash_destroy(&TIMEZONES_LIST.hash);
        }

        switch_mutex_unlock(globals.mutex);

        if (TIMEZONES_LIST.pool) {
                switch_core_destroy_memory_pool(&TIMEZONES_LIST.pool);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_os_yield()

void switch_os_yield

(

void

)

Definition at line 142 of file switch_time.c.

Referenced by switch_cond_next(), switch_core_session_read_frame(), switch_event_channel_deliver_thread(), switch_event_dispatch_thread(), SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_next().

{
#if defined(WIN32)
        SwitchToThread();
#else
        sched_yield();
#endif
}

time_now()

static switch_time_t time_now ( int64_t  offset )

static

Definition at line 540 of file switch_time.c.

References count, MONO, and switch_time_now().

Referenced by SWITCH_MODULE_RUNTIME_FUNCTION(), switch_mono_micro_time_now(), switch_time_ref(), switch_time_sync(), switch_xml_locate_user_cache(), and switch_xml_locate_user_merged().

{
        switch_time_t now;

#if (defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)) || defined(WIN32)
        if (MONO) {
#ifndef WIN32
                struct timespec ts;
                clock_gettime(offset ? CLOCK_MONOTONIC : CLOCK_REALTIME, &ts);
                if (offset < 0) offset = 0;
                now = ts.tv_sec * APR_USEC_PER_SEC + (ts.tv_nsec / 1000) + offset;
#else
                if (offset == 0) {
                        return switch_time_now();
                } else if (offset < 0) offset = 0;


                if (win32_use_qpc) {
                        /* Use QueryPerformanceCounter */
                        uint64_t count = 0;
                        QueryPerformanceCounter((LARGE_INTEGER*)&count);
                        now = ((count * 1000000) / win32_qpc_freq) + offset;
                } else {
                        /* Use good old timeGetTime() */
                        DWORD tick_now;
                        DWORD tick_diff;

                        tick_now = timeGetTime();
                        if (win32_tick_time_since_start != -1) {
                                EnterCriticalSection(&timer_section);
                                /* just add diff (to make it work more than 50 days). */
                                tick_diff = tick_now - win32_last_get_time_tick;
                                win32_tick_time_since_start += tick_diff;

                                win32_last_get_time_tick = tick_now;
                                now = (win32_tick_time_since_start * 1000) + offset;
                                LeaveCriticalSection(&timer_section);
                        } else {
                                /* If someone is calling us before timer is initialized,
                                 * return the current tick + offset
                                 */
                                now = (tick_now * 1000) + offset;
                        }
                }
#endif
        } else {
#endif
                now = switch_time_now();

#if (defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)) || defined(WIN32)
        }
#endif

        return now;
}

timer_check()

static switch_status_t timer_check ( switch_timer_t *  timer, switch_bool_t  step  )

static

Definition at line 903 of file switch_time.c.

References check_roll, switch_timer::diff, globals, switch_timer::interval, switch_timer::private_info, timer_private::ready, timer_private::reference, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, TFD, timer_matrix::tick, switch_timer::tick, and timer_step().

Referenced by rtp_common_read(), and SWITCH_MODULE_LOAD_FUNCTION().

{
        timer_private_t *private_info;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (timer->interval == 1) {
                return SWITCH_STATUS_FALSE;
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return _timerfd_check(timer, step);
        }
#endif

        private_info = timer->private_info;

        if (globals.RUNNING != 1 || !private_info->ready) {
                return SWITCH_STATUS_SUCCESS;
        }

        check_roll();

        timer->tick = TIMER_MATRIX[timer->interval].tick;

        if (timer->tick < private_info->reference) {
                timer->diff = (switch_size_t)(private_info->reference - timer->tick);
        } else {
                timer->diff = 0;
        }

        if (timer->diff) {
                status = SWITCH_STATUS_FALSE;
        } else if (step) {
                timer_step(timer);
        }


        return status;
}

timer_destroy()

static switch_status_t timer_destroy ( switch_timer_t *  timer )

static

Definition at line 944 of file switch_time.c.

References timer_matrix::count, globals, switch_timer::interval, MAX_ELEMENTS, switch_timer::private_info, timer_private::ready, runtime, SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, TFD, timer_matrix::tick, and switch_runtime::tipping_point.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        timer_private_t *private_info;

        if (timer->interval == 1) {
                switch_mutex_lock(globals.mutex);
                if (globals.timer_count) {
                        globals.timer_count--;
                }
                switch_mutex_unlock(globals.mutex);
                return SWITCH_STATUS_SUCCESS;
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return _timerfd_destroy(timer);
        }
#endif

        private_info = timer->private_info;

        if (timer->interval < MAX_ELEMENTS) {
                switch_mutex_lock(globals.mutex);
                TIMER_MATRIX[timer->interval].count--;
                if (TIMER_MATRIX[timer->interval].count == 0) {
                        TIMER_MATRIX[timer->interval].tick = 0;
                }
                switch_mutex_unlock(globals.mutex);
        }
        if (private_info) {
                private_info->ready = 0;
        }

        switch_mutex_lock(globals.mutex);
        if (globals.timer_count) {
                globals.timer_count--;
                if (runtime.tipping_point && globals.timer_count == (runtime.tipping_point - 1)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Fell Below tipping point of %u, shifting into low-gear.\n", runtime.tipping_point);
                }
        }
        switch_mutex_unlock(globals.mutex);

        return SWITCH_STATUS_SUCCESS;
}

timer_generic_sync()

static switch_status_t timer_generic_sync ( switch_timer_t *  timer )

static

Definition at line 382 of file switch_time.c.

References switch_timer::diff, switch_timer::interval, switch_timer::last_samplecount, switch_timer::memory_pool, switch_timer::private_info, switch_timer::samplecount, switch_timer::samples, switch_timer::start, SWITCH_CHANNEL_LOG, switch_core_alloc, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_micro_time_now(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_timer::tick.

Referenced by timer_sync().

{
        switch_time_t now = switch_micro_time_now();
        int64_t elapsed = (now - timer->start);

        timer->tick = (elapsed / timer->interval) / 1000;
        timer->samplecount = (uint32_t)(timer->tick * timer->samples);

        if (timer->interval == 1 && timer->samplecount == timer->last_samplecount) {
                timer->samplecount++;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Timer sync too often\n");
        }
        timer->last_samplecount = timer->samplecount;



        return SWITCH_STATUS_SUCCESS;
}

timer_init()

static switch_status_t timer_init ( switch_timer_t *  timer )

static

Definition at line 699 of file switch_time.c.

References timer_matrix::cond, timer_matrix::count, do_sleep(), globals, if(), switch_timer::interval, switch_timer::memory_pool, switch_runtime::microseconds_per_tick, module_pool, timer_matrix::mutex, switch_timer::private_info, timer_private::ready, timer_private::reference, timer_private::roll, timer_matrix::roll, runtime, timer_private::start, switch_timer::start, SWITCH_CHANNEL_LOG, switch_core_alloc, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, switch_micro_time_now(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_thread_cond_create(), switch_time_sync(), TFD, timer_matrix::tick, and switch_runtime::tipping_point.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        timer_private_t *private_info;
        int sanity = 0;

        timer->start = switch_micro_time_now();

        if (timer->interval == 1) {
                switch_mutex_lock(globals.mutex);
                globals.timer_count++;
                switch_mutex_unlock(globals.mutex);
                return SWITCH_STATUS_SUCCESS;
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return _timerfd_init(timer);
        }
#endif

        while (globals.STARTED == 0) {
                do_sleep(100000);
                if (++sanity == 300) {
                        abort();
                }
        }

        if (globals.RUNNING != 1 || !globals.mutex || timer->interval < 1) {
                return SWITCH_STATUS_FALSE;
        }

        if ((private_info = switch_core_alloc(timer->memory_pool, sizeof(*private_info)))) {
                switch_mutex_lock(globals.mutex);
                if (!TIMER_MATRIX[timer->interval].mutex) {
                        switch_mutex_init(&TIMER_MATRIX[timer->interval].mutex, SWITCH_MUTEX_NESTED, module_pool);
                        switch_thread_cond_create(&TIMER_MATRIX[timer->interval].cond, module_pool);
                }
                TIMER_MATRIX[timer->interval].count++;
                switch_mutex_unlock(globals.mutex);
                timer->private_info = private_info;
                private_info->start = private_info->reference = (switch_size_t)TIMER_MATRIX[timer->interval].tick;
                private_info->start -= 2; /* switch_core_timer_init sets samplecount to samples, this makes first next() step once */
                private_info->roll = TIMER_MATRIX[timer->interval].roll;
                private_info->ready = 1;

                if (runtime.microseconds_per_tick > 10000  && (timer->interval % (int)(runtime.microseconds_per_tick / 1000)) != 0 && (timer->interval % 10) == 0) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Increasing global timer resolution to 10ms to handle interval %d\n", timer->interval);
                        runtime.microseconds_per_tick = 10000;
                }

                if (timer->interval > 0 && (timer->interval < (int)(runtime.microseconds_per_tick / 1000) || (timer->interval % 10) != 0)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Increasing global timer resolution to 1ms to handle interval %d\n", timer->interval);
                        runtime.microseconds_per_tick = 1000;
                        switch_time_sync();
                }

                switch_mutex_lock(globals.mutex);
                globals.timer_count++;
                if (runtime.tipping_point && globals.timer_count == (runtime.tipping_point + 1)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Crossed tipping point of %u, shifting into high-gear.\n", runtime.tipping_point);
                }
                switch_mutex_unlock(globals.mutex);

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_MEMERR;
}

timer_next()

static switch_status_t timer_next ( switch_timer_t *  timer )

static

Definition at line 840 of file switch_time.c.

References check_roll, do_sleep(), globals, switch_timer::interval, MATRIX, mutex, switch_timer::private_info, timer_private::ready, timer_private::reference, runtime, switch_mutex_lock(), switch_mutex_unlock(), switch_os_yield(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_cond_wait(), TFD, timer_matrix::tick, switch_timer::tick, timer_step(), and switch_runtime::tipping_point.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        timer_private_t *private_info;

#ifdef DISABLE_1MS_COND
        int cond_index = timer->interval;
#else
        int cond_index = 1;
#endif
        int delta;

        if (timer->interval == 1) {
                return SWITCH_STATUS_FALSE;
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return _timerfd_next(timer);
        }
#endif

        private_info = timer->private_info;

        delta = (int) (private_info->reference - TIMER_MATRIX[timer->interval].tick);



        /* sync up timer if it's not been called for a while otherwise it will return instantly several times until it catches up */
        if (delta < -1) {
                private_info->reference = (switch_size_t)(timer->tick = TIMER_MATRIX[timer->interval].tick);
        }
        timer_step(timer);

        if (!MATRIX) {
                do_sleep(1000 * timer->interval);
                goto end;
        }

        while (globals.RUNNING == 1 && private_info->ready && TIMER_MATRIX[timer->interval].tick < private_info->reference) {
                check_roll();

                switch_os_yield();


                if (runtime.tipping_point && globals.timer_count >= runtime.tipping_point) {
                        globals.use_cond_yield = 0;
                } else {
                        if (globals.use_cond_yield == 1) {
                                switch_mutex_lock(TIMER_MATRIX[cond_index].mutex);
                                if (TIMER_MATRIX[timer->interval].tick < private_info->reference) {
                                        switch_thread_cond_wait(TIMER_MATRIX[cond_index].cond, TIMER_MATRIX[cond_index].mutex);
                                }
                                switch_mutex_unlock(TIMER_MATRIX[cond_index].mutex);
                        } else {
                                do_sleep(1000);
                        }
                }
        }

  end:
        return globals.RUNNING == 1 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

timer_step()

static switch_status_t timer_step ( switch_timer_t *  timer )

static

Definition at line 775 of file switch_time.c.

References check_roll, globals, switch_timer::interval, switch_timer::private_info, timer_private::ready, timer_private::reference, switch_timer::samplecount, switch_timer::samples, timer_private::start, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, TFD, and UINT32_MAX.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), timer_check(), timer_next(), and timer_sync().

{
        timer_private_t *private_info;
        uint64_t samples;

        if (timer->interval == 1) {
                return SWITCH_STATUS_FALSE;
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return _timerfd_step(timer);
        }
#endif

        private_info = timer->private_info;

        if (globals.RUNNING != 1 || private_info->ready == 0) {
                return SWITCH_STATUS_FALSE;
        }

        check_roll();
        samples = (uint64_t)timer->samples * (private_info->reference - private_info->start);

        if (samples > UINT32_MAX) {
                private_info->start = private_info->reference - 1; /* Must have a diff */
                samples = timer->samples;
        }

        timer->samplecount = (uint32_t) samples;
        private_info->reference++;

        return SWITCH_STATUS_SUCCESS;
}

timer_sync()

static switch_status_t timer_sync ( switch_timer_t *  timer )

static

Definition at line 810 of file switch_time.c.

References globals, switch_timer::interval, switch_timer::private_info, timer_private::ready, timer_private::reference, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, TFD, timer_matrix::tick, switch_timer::tick, timer_generic_sync(), and timer_step().

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        timer_private_t *private_info;

        if (timer->interval == 1) {
                return timer_generic_sync(timer);
        }

#ifdef HAVE_TIMERFD_CREATE
        if (TFD == 2) {
                return timer_generic_sync(timer);
        }
#endif

        private_info = timer->private_info;

        if (globals.RUNNING != 1 || private_info->ready == 0) {
                return SWITCH_STATUS_FALSE;
        }

        /* sync the clock */
        private_info->reference = (switch_size_t)(timer->tick = TIMER_MATRIX[timer->interval].tick);

        /* apply timestamp */
        timer_step(timer);

        return SWITCH_STATUS_SUCCESS;
}

timesub()

static void timesub ( const time_t *const  timep, const long  offset, register const struct state *const  sp, register struct tm *const  tmp  )

static

Definition at line 2346 of file switch_time.c.

References DAYSPERNYEAR, DAYSPERWEEK, EPOCH_WDAY, EPOCH_YEAR, ip, isleap, state::leapcnt, LEAPS_THRU_END_OF, lsinfo::ls_corr, lsinfo::ls_trans, state::lsis, mon_lengths, SECSPERDAY, SECSPERHOUR, SECSPERMIN, switch_assert, TM_YEAR_BASE, while(), and year_lengths.

Referenced by tztime().

{
        register const struct lsinfo *lp;
        register long days;
        register time_t rem;
        register int y;
        register int yleap;
        register const int *ip;
        register long corr;
        register int hit;
        register int i;

        switch_assert(timep != NULL);
        switch_assert(sp != NULL);
        switch_assert(tmp != NULL);

        corr = 0;
        hit = 0;
        i = (sp == NULL) ? 0 : sp->leapcnt;

        while (--i >= 0) {
                lp = &sp->lsis[i];
                if (*timep >= lp->ls_trans) {
                        if (*timep == lp->ls_trans) {
                                hit = ((i == 0 && lp->ls_corr > 0) || (i > 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;
                }
        }
        days = (long) (*timep / SECSPERDAY);
        rem = *timep % SECSPERDAY;


#ifdef mc68k
        /* If this is for CPU bugs workarounds, i would remove this anyway. Who would use it on an old mc68k ? */
        if (*timep == 0x80000000) {
                /*
                 ** A 3B1 muffs the division on the most negative number.
                 */
                days = -24855;
                rem = -11648;
        }
#endif

        rem += (offset - corr);
        while (rem < 0) {
                rem += SECSPERDAY;
                --days;
        }
        while (rem >= SECSPERDAY) {
                rem -= SECSPERDAY;
                ++days;
        }
        tmp->tm_hour = (int) (rem / SECSPERHOUR);
        rem = 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;
        tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);

        if (tmp->tm_wday < 0)
                tmp->tm_wday += DAYSPERWEEK;

        y = EPOCH_YEAR;

#define LEAPS_THRU_END_OF(y)    ((y) / 4 - (y) / 100 + (y) / 400)

        while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
                register int newy;

                newy = (int) (y + days / DAYSPERNYEAR);
                if (days < 0)
                        --newy;
                days -= (newy - y) * DAYSPERNYEAR + LEAPS_THRU_END_OF(newy - 1) - LEAPS_THRU_END_OF(y - 1);
                y = newy;
        }

        tmp->tm_year = y - TM_YEAR_BASE;
        tmp->tm_yday = (int) days;

        ip = mon_lengths[yleap];

        for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
                days = days - (long) ip[tmp->tm_mon];

        tmp->tm_mday = (int) (days + 1);
        tmp->tm_isdst = 0;
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        tmp->tm_gmtoff = offset;
#endif
}

tm2switchtime()

static void tm2switchtime ( struct tm *  tm, switch_time_exp_t *  xt  )

static

Definition at line 1342 of file switch_time.c.

References memset(), switch_time_exp_t::tm_gmtoff, switch_time_exp_t::tm_hour, switch_time_exp_t::tm_isdst, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_wday, switch_time_exp_t::tm_yday, and switch_time_exp_t::tm_year.

Referenced by switch_strftime_tz(), and switch_time_exp_tz_name().

{

        if (!xt || !tm) {
                return;
        }
        memset(xt, 0, sizeof(*xt));

        xt->tm_sec = tm->tm_sec;
        xt->tm_min = tm->tm_min;
        xt->tm_hour = tm->tm_hour;
        xt->tm_mday = tm->tm_mday;
        xt->tm_mon = tm->tm_mon;
        xt->tm_year = tm->tm_year;
        xt->tm_wday = tm->tm_wday;
        xt->tm_yday = tm->tm_yday;
        xt->tm_isdst = tm->tm_isdst;

#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        xt->tm_gmtoff = tm->tm_gmtoff;
#endif

        return;
}

transtime()

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

static

Definition at line 2034 of file switch_time.c.

References 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().

{
        register int leapyear;
        register time_t value;
        register 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;
}

tzparse()

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

static

Definition at line 2124 of file switch_time.c.

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

Referenced by tztime().

{
        const char *stdname;
        const char *dstname;
        size_t stdlen;
        size_t dstlen;
        long stdoffset;
        long dstoffset;
        register time_t *atp;
        register unsigned char *typep;
        register char *cp;


        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 {
                name = getzname(name);
                stdlen = name - stdname;
                if (stdlen < 3)
                        return -1;
                if (*name == '\0')
                        return -1;
                name = getoffset(name, &stdoffset);
                if (name == NULL)
                        return -1;
        }

        sp->leapcnt = 0;                        /* so, we're off a little */

        if (*name != '\0') {
                dstname = name;
                name = getzname(name);
                dstlen = name - dstname;        /* length of DST zone name */
                if (dstlen < 3)
                        return -1;
                if (*name != '\0' && *name != ',' && *name != ';') {
                        name = getoffset(name, &dstoffset);
                        if (name == NULL)
                                return -1;
                } else
                        dstoffset = stdoffset - SECSPERHOUR;

                /* Go parsing the daylight saving stuff */
                if (*name == ',' || *name == ';') {
                        struct rule start;
                        struct rule end;
                        register int year;
                        register 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 to 2037.
                         */
                        sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);

                        if (sp->timecnt > TZ_MAX_TIMES)
                                return -1;

                        sp->ttis[0].tt_gmtoff = -dstoffset;
                        sp->ttis[0].tt_isdst = 1;
                        sp->ttis[0].tt_abbrind = (int) (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;

                        for (year = EPOCH_YEAR; year <= 2037; ++year) {
                                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 */
                                }

                                janfirst += year_lengths[isleap(year)] * SECSPERDAY;
                        }

                } else {
                        register long theirstdoffset;
                        register long theirdstoffset;
                        register long theiroffset;
                        register int isdst;
                        register int i;
                        register int j;

                        if (*name != '\0')
                                return -1;
                        /*
                           Initial values of theirstdoffset and theirdstoffset.
                         */
                        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;
                                }
                        }
                        theirdstoffset = 0;
                        for (i = 0; i < sp->timecnt; ++i) {
                                j = sp->types[i];
                                if (sp->ttis[j].tt_isdst) {
                                        theirdstoffset = -sp->ttis[j].tt_gmtoff;
                                        break;
                                }
                        }
                        /*
                         ** Initially we're assumed to be in standard time.
                         */
                        isdst = FALSE;
                        /*
                         ** 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] = (unsigned char) sp->ttis[j].tt_isdst;
                                if (sp->ttis[j].tt_ttisgmt) {
                                        /* No adjustment to transition time */
                                } else {
                                        /*
                                         ** If summer time is in effect, and the
                                         ** transition time was not specified as
                                         ** standard time, add the summer time
                                         ** offset to the transition time;
                                         ** otherwise, add the standard time
                                         ** offset to the transition time.
                                         */
                                        /*
                                         ** Transitions from DST to DDST
                                         ** will effectively disappear since
                                         ** POSIX provides for only one DST
                                         ** offset.
                                         */
                                        if (isdst && !sp->ttis[j].tt_ttisstd) {
                                                sp->ats[i] += dstoffset - theirdstoffset;
                                        } else {
                                                sp->ats[i] += stdoffset - theirstdoffset;
                                        }
                                }
                                theiroffset = -sp->ttis[j].tt_gmtoff;
                                if (sp->ttis[j].tt_isdst)
                                        theirdstoffset = theiroffset;
                                else
                                        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 = (int) (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 = (int) (stdlen + 1);
        if (dstlen != 0)
                sp->charcnt += (int) (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;
}

tztime()

static void tztime ( const time_t *const  timep, const char *  tzstring, struct tm *const  tmp  )

static

Definition at line 2452 of file switch_time.c.

References state::ats, state::chars, FALSE, gmt, memset(), state::timecnt, timesub(), ttinfo::tt_abbrind, ttinfo::tt_gmtoff, ttinfo::tt_isdst, state::ttis, state::typecnt, state::types, and tzparse().

Referenced by event_handler(), switch_strftime_tz(), and switch_time_exp_tz_name().

{
        struct state *tzptr, *sp;
        const time_t t = *timep;
        register int i;
        register const struct ttinfo *ttisp;

        if (tzstring == NULL)
                tzstring = gmt;

        tzptr = (struct state *) malloc(sizeof(struct state));
        sp = tzptr;

        if (tzptr != NULL) {

                memset(tzptr, 0, sizeof(struct state));

                (void) tzparse(tzstring, tzptr, FALSE);

                if (sp->timecnt == 0 || t < sp->ats[0]) {
                        i = 0;
                        while (sp->ttis[i].tt_isdst)
                                if (++i >= sp->typecnt) {
                                        i = 0;
                                        break;
                                }
                } else {
                        for (i = 1; i < sp->timecnt; ++i)
                                if (t < sp->ats[i])
                                        break;
                        i = sp->types[i - 1];   // DST begin or DST end
                }
                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);
                 */
                if (tmp != NULL) {              /* Just a check not to assert */
                        timesub(&t, ttisp->tt_gmtoff, sp, tmp);
                        tmp->tm_isdst = ttisp->tt_isdst;
#if defined(HAVE_STRUCT_TM_TM_ZONE)
                        tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
#endif
                }

                free(tzptr);
        }

}

win32_init_timers()

static void win32_init_timers ( void  )

static

Definition at line 989 of file switch_time.c.

References count.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), and SWITCH_MODULE_RUNTIME_FUNCTION().

{
#ifdef WIN32
        OSVERSIONINFOEX version_info; /* Used to fetch current OS version from Windows */

        EnterCriticalSection(&timer_section);

        ZeroMemory(&version_info, sizeof(OSVERSIONINFOEX));
        version_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

        /* Check if we should use timeGetTime() (pre-Vista) or QueryPerformanceCounter() (Vista and later) */

        if (GetVersionEx((OSVERSIONINFO*) &version_info)) {
                if (version_info.dwPlatformId == VER_PLATFORM_WIN32_NT && version_info.dwMajorVersion >= 6) {
                        if (QueryPerformanceFrequency((LARGE_INTEGER*)&win32_qpc_freq) && win32_qpc_freq > 0) {
                                /* At least Vista, and QueryPerformanceFrequency() suceeded, enable qpc */
                                win32_use_qpc = 1;
                        } else {
                                /* At least Vista, but QueryPerformanceFrequency() failed, disable qpc */
                                win32_use_qpc = 0;
                        }
                } else {
                        /* Older then Vista, disable qpc */
                        win32_use_qpc = 0;
                }
        } else {
                /* Unknown version - we want at least Vista, disable qpc */
                win32_use_qpc = 0;
        }

        if (win32_use_qpc) {
                uint64_t count = 0;

                if (!QueryPerformanceCounter((LARGE_INTEGER*)&count) || count == 0) {
                        /* Call to QueryPerformanceCounter() failed, disable qpc again */
                        win32_use_qpc = 0;
                }
        }

        if (!win32_use_qpc) {
                /* This will enable timeGetTime() instead, qpc init failed */
                win32_last_get_time_tick = timeGetTime();
                win32_tick_time_since_start = win32_last_get_time_tick;
        }

        LeaveCriticalSection(&timer_section);
#endif
}

Variable Documentation

COND

int COND = 1

static

Definition at line 87 of file switch_time.c.

Referenced by SWITCH_MODULE_RUNTIME_FUNCTION(), and switch_time_set_cond_yield().

globals

struct { ... } globals

Referenced by event_handler(), switch_cond_next(), switch_cond_yield(), switch_lookup_timezone(), switch_micro_time_now(), SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), SWITCH_MODULE_SHUTDOWN_FUNCTION(), switch_sleep(), timer_check(), timer_destroy(), timer_init(), timer_next(), timer_step(), and timer_sync().

gmt

const char gmt[] = "GMT"

static

Definition at line 1812 of file switch_time.c.

Referenced by tztime().

last_time

switch_time_t last_time = 0

static

Definition at line 607 of file switch_time.c.

Referenced by switch_time_sync().

MATRIX

int MATRIX = 1

static

Definition at line 89 of file switch_time.c.

Referenced by SWITCH_MODULE_RUNTIME_FUNCTION(), switch_time_set_cond_yield(), switch_time_set_matrix(), and timer_next().

module_pool

switch_memory_pool_t* module_pool = NULL

static

Definition at line 100 of file switch_time.c.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_init().

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 1851 of file switch_time.c.

Referenced by timesub(), and transtime().

MONO

int MONO = 0

static

Definition at line 64 of file switch_time.c.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_time_set_monotonic(), and time_now().

mutex

switch_mutex_t* mutex

Definition at line 106 of file switch_time.c.

Referenced by switch_cond_next(), switch_cond_yield(), SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_next().

NANO

int NANO = 0

static

Definition at line 82 of file switch_time.c.

Referenced by do_sleep(), SWITCH_MODULE_RUNTIME_FUNCTION(), and switch_time_set_nanosleep().

NODE

switch_event_node_t* NODE = NULL

static

Definition at line 1377 of file switch_time.c.

OFFSET

int OFFSET = 0

static

Definition at line 85 of file switch_time.c.

Referenced by do_sleep(), and switch_time_calibrate_clock().

RUNNING

int32_t RUNNING

Definition at line 103 of file switch_time.c.

STARTED

int32_t STARTED

Definition at line 104 of file switch_time.c.

SYSTEM_TIME

int SYSTEM_TIME = 0

static

Definition at line 68 of file switch_time.c.

Referenced by switch_time_ref(), switch_time_set_use_system_time(), and switch_time_sync().

TFD

int TFD = 0

static

Definition at line 81 of file switch_time.c.

Referenced by SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_time_set_timerfd(), timer_check(), timer_destroy(), timer_init(), timer_next(), timer_step(), and timer_sync().

timer_count

uint32_t timer_count

Definition at line 107 of file switch_time.c.

TIMER_MATRIX

timer_matrix_t TIMER_MATRIX[MAX_ELEMENTS+1]

static

Definition at line 138 of file switch_time.c.

TIMEZONES_LIST

switch_timezones_list_t TIMEZONES_LIST = { 0 }

static

Definition at line 1376 of file switch_time.c.

use_cond_yield

int32_t use_cond_yield

Definition at line 105 of file switch_time.c.

year_lengths

const int year_lengths[2]

static

Initial value:

= {
        DAYSPERNYEAR, DAYSPERLYEAR
}

Definition at line 1856 of file switch_time.c.

Referenced by timesub(), and tzparse().