/* strdate_r and strtime_r must be at least BUF_DATE AND BUF_TIME in size */
void move_time(const char *fromtz, const char *totz, const char *strdate, const char *strtime, char *strdate_r, char *strtime_r)
{
if (strtime && strlen(strtime)) {
time_t t;
struct tm tm;
if (strdate && strlen(strdate)) {
tm_read_strdate(&tm, strdate);
} else {
time(&t);
localtime_r(&t, &tm);
}
tm_read_strtime(&tm, strtime);
if ((t = tmtz_mktime(&tm, fromtz)) == -1) {
fprintf(stderr, "tmtz_mktime failed in move_time\n");
return;
}
localtime_tz(&t, totz, &tm);
strftime(strtime_r, BUF_TIME, "%H:%M", &tm);
strftime(strdate_r, BUF_DATE, "%Y-%m-%d", &tm);
} else {
*strtime_r = '\0';
strncpy(strdate_r, strdate, BUF_DATE);
strdate_r[BUF_DATE - 1] = '\0';
}
//fprintf(stderr, "move_time -- fromtz: %s, totz: %s\n", fromtz, totz);
}
void
Time::setToNow()
{
time_t seconds;
time(&seconds);
localtime_tz(&seconds, &(this->t), this->timezone);
}
void reconcile_time(ReconcileTime rc, struct tm *t1, const char *tz1, struct tm *t2, const char *tz2, long *elapsed)
{
time_t t1_t, t2_t;
switch (rc) {
case RECONCILE_TIME_BEGIN:
t2_t = tmtz_mktime(t2, tz2);
t1_t = t2_t - *elapsed;
localtime_tz(&t1_t, tz1, t1);
break;
case RECONCILE_TIME_END:
t1_t = tmtz_mktime(t1, tz1);
t2_t = t1_t + *elapsed;
localtime_tz(&t2_t, tz2, t2);
break;
case RECONCILE_TIME_ELAPSED:
t1_t = tmtz_mktime(t1, tz1);
t2_t = tmtz_mktime(t2, tz2);
*elapsed = t2_t - t1_t;
break;
}
}
/**
* @param begin The begin of the validity of the PTY will be stored
* here.
* @param end The end of the validity of the PTY will be stored here.
* @param last_transm The last time when a program ID with the PTY
* in question was broadcast by the network.
* @param tz A time zone name in the same format as the TZ environment
* variable. If @c NULL the current value of TZ will be used.
*
* This function calculates the validity time window of a Program Type
* (PTY) code according to EN 300 231. That is the time window where a
* network can be expected to broadcast another program with the same
* PTY, approximately up to four weeks after its last
* transmission. When the PTY is a series code (>= 0x80) and not
* transmitted again before @a end, the network may assign the code to
* another series.
*
* @a tz is the time zone of the intended audience of the program.
* Ideally the time zone would be specified as a geographic area like
* "Europe/London", such that the function can determine if
* daylight-saving time is in effect at @a time or at the end of the
* validity time window. See the documentation of the localtime()
* function and the TZ environment variable for details. If no time
* zone name is available "UTC" should be specified, the returned
* @a end time may be off by one hour in this case.
*
* @returns
* On error the function returns @c FALSE and @a *begin and @a *end
* remain unchanged:
* - @a tz is empty or contains an equal sign '='.
* - The @a end time cannot be represented as a time_t value
* (December 2037 is closer than you think!).
* - Insufficient memory was available.
*
* @since 0.2.34
*
* @bug
* This function is not thread safe unless @a tz is @c NULL.
* That is a limitation of the C library which permits the conversion
* of a broken-down time in an arbitrary time zone only by setting
* the TZ environment variable. The function may also fail to restore
* the value of TZ if insufficient memory is available.
*/
vbi_bool
vbi_pty_validity_window (time_t * begin,
time_t * end,
time_t last_transm,
const char * tz)
{
char *old_tz;
struct tm tm;
time_t stop;
int saved_errno;
assert (NULL != begin);
assert (NULL != end);
if (NULL != tz && 0 == strcmp (tz, "UTC")) {
vbi_bool success;
success = pty_utc_validity_window (begin, end,
last_transm);
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return success;
}
if (unlikely (!localtime_tz (&tm, &old_tz, last_transm, tz)))
goto failed;
tm.tm_mday += 4 * 7 + 1;
tm.tm_hour = 4;
tm.tm_min = 0;
tm.tm_sec = 0;
tm.tm_isdst = -1; /* unknown */
stop = mktime (&tm);
if (unlikely ((time_t) -1 == stop)) {
saved_errno = errno;
if (unlikely (!restore_tz (&old_tz, tz)))
return FALSE;
#if 3 == VBI_VERSION_MINOR
errno = saved_errno;
#else
errno = 0;
#endif
return FALSE;
}
if (unlikely (!restore_tz (&old_tz, tz)))
goto failed;
*begin = last_transm;
*end = stop;
return TRUE;
failed:
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return FALSE;
}
/**
* @param pil Program Identification Label (PIL) to convert.
* @param start The most recently announced start time of the
* program. If zero the current system time will be used.
* @param tz A time zone name in the same format as the TZ environment
* variable. If @c NULL the current value of TZ will be used.
*
* This function converts a PIL to a time_t in the same manner
* localtime() converts a broken-down time to time_t.
*
* Since PILs do not contain a year field, the year is determined from
* the @a start parameter, that is the most recently announced start
* time of the program or "AT-1" in EN 300 231 parlance. If @a pil
* contains a month more than five months after @a start, @a pil is
* assumed to refer to an earlier date than @a start.
*
* @a pil is assumed to be a time in the time zone @a tz. @a start
* will be converted to a local time in the same time zone to
* determine the correct year.
*
* Teletext packet 8/30 format 2, VPS and DVB PDC descriptors give a
* PIL relative to the time zone of the intended audience of the
* program. Ideally the time zone would be specified as a geographic
* area like "Europe/London", such that the function can determine
* the correct offset from UTC and if daylight-saving time is in
* effect at the specified date. See the documentation of the
* localtime() function and the TZ environment variable for details.
*
* XDS Current/Future Program ID packets give a PIL relative to UTC.
* Just specify time zone "UTC" in this case.
*
* @returns
* The PIL as a time_t, that is the number of seconds since
* 1970-01-01 00:00 UTC. On error the function
* returns (time_t) -1:
* - @a pil does not contain a valid date or time. February 29th is
* a valid date only if the estimated year is a leap year.
* - @a tz is empty or contains an equal sign '='.
* - @a start is zero and the current system time could not be
* determined.
* - The time specified by @a pil, @a start and @a tz cannot be
* represented as a time_t value.
* - Insufficient memory was available.
*
* @since 0.2.34
*
* @bug
* This function is not thread safe unless @a tz is @c NULL. That is
* a limitation of the C library which permits the conversion of a
* broken-down time in an arbitrary time zone only by setting the TZ
* environment variable. The function may also fail to restore the
* value of TZ if insufficient memory is available.
*/
time_t
vbi_pil_to_time (vbi_pil pil,
time_t start,
const char * tz)
{
struct tm tm;
char *old_tz;
time_t result;
int saved_errno;
if (unlikely (!vbi_pil_is_valid_date (pil))) {
#if 3 == VBI_VERSION_MINOR
errno = VBI_ERR_INVALID_PIL;
#else
errno = 0;
#endif
return (time_t) -1;
}
if (NULL != tz && 0 == strcmp (tz, "UTC")) {
time_t t;
t = valid_pil_lto_to_time (pil, start,
/* seconds_east */ 0);
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return t;
}
if (unlikely (!localtime_tz (&tm, &old_tz, start, tz))) {
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return (time_t) -1;
}
if (unlikely (!tm_mon_mday_from_pil (&tm, pil))) {
saved_errno = EOVERFLOW;
goto failed;
}
if (unlikely (!tm_leap_day_check (&tm))) {
saved_errno = VBI_ERR_INVALID_PIL;
goto failed;
}
tm.tm_hour = VBI_PIL_HOUR (pil);
tm.tm_min = VBI_PIL_MINUTE (pil);
tm.tm_sec = 0;
tm.tm_isdst = -1; /* unknown */
result = mktime (&tm);
if (unlikely ((time_t) -1 == result))
goto failed;
if (unlikely (!restore_tz (&old_tz, tz))) {
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return (time_t) -1;
}
return result;
failed:
if (unlikely (!restore_tz (&old_tz, tz))) {
#if 2 == VBI_VERSION_MINOR
errno = 0;
#endif
return (time_t) -1;
}
#if 3 == VBI_VERSION_MINOR
errno = saved_errno;
#else
errno = 0;
#endif
return (time_t) -1;
}
static vbi_bool
valid_pil_validity_window (time_t * begin,
time_t * end,
vbi_pil pil,
time_t start,
const char * tz)
{
char *old_tz;
struct tm tm;
struct tm tm2;
time_t stop;
int saved_errno;
/* EN 300 231 Section 9.3 and Annex F. */
old_tz = NULL;
if (NULL != tz && 0 == strcmp (tz, "UTC")) {
return valid_pil_lto_validity_window
(begin, end, pil, start, /* seconds_east */ 0);
}
if (unlikely (!localtime_tz (&tm, &old_tz, start, tz)))
return FALSE;
if (unlikely (!tm_mon_mday_from_pil (&tm, pil))) {
saved_errno = EOVERFLOW;
goto failed;
}
if (unlikely (!tm_leap_day_check (&tm))) {
/* Annex F: "Invalid days - indefinite time window". */
if (!restore_tz (&old_tz, tz))
return FALSE;
*begin = TIME_MIN;
*end = TIME_MAX;
return TRUE;
}
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
tm.tm_isdst = -1; /* unknown */
tm2 = tm;
if (VBI_PIL_HOUR (pil) < 4) {
--tm.tm_mday;
tm.tm_hour = 20;
}
start = mktime (&tm);
if (unlikely ((time_t) -1 == start))
goto failed;
tm2.tm_mday += 1;
tm2.tm_hour = 4;
stop = mktime (&tm2);
if (unlikely ((time_t) -1 == stop))
goto failed;
if (unlikely (!restore_tz (&old_tz, tz)))
return FALSE;
*begin = start;
*end = stop;
return TRUE;
failed:
if (unlikely (!restore_tz (&old_tz, tz)))
return FALSE;
errno = saved_errno;
return FALSE;
}
void
Time::switchTimezone(const char* timezone)
{
time_t seconds = mktime_tz(&(this->t), this->timezone);
localtime_tz(&seconds, &(this->t), timezone);
}
void
Time::set(int64_t millis)
{
time_t seconds = millis / 1000;
localtime_tz(&seconds, &(this->t), this->timezone);
}
