#include <ctype.h>

#include <errno.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <endian.h>

#include <byteswap.h>

#include <assert.h>

#include <limits.h>

#include <unistd.h>

#include <stdint.h>

#include <stdbool.h>

#include <sys/stat.h>

#include "time-dst.h"

#include "util.h"

#define TZ_MAGIC "TZif"

struct tzhead {

char tzh_magic[4]; /* TZ_MAGIC */

char tzh_version[1]; /* '\0' or '2' as of 2005 */

char tzh_reserved[15]; /* reserved--must be zero */

char tzh_ttisgmtcnt[4]; /* coded number of trans. time flags */

char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */

char tzh_leapcnt[4]; /* coded number of leap seconds */

char tzh_timecnt[4]; /* coded number of transition times */

char tzh_typecnt[4]; /* coded number of local time types */

char tzh_charcnt[4]; /* coded number of abbr. chars */

};

struct ttinfo {

long int offset; /* Seconds east of GMT. */

unsigned char isdst; /* Used to set tm_isdst. */

unsigned char idx; /* Index into `zone_names'. */

unsigned char isstd; /* Transition times are in standard time. */

unsigned char isgmt; /* Transition times are in GMT. */

};

struct leap {

time_t transition; /* Time the transition takes effect. */

long int change; /* Seconds of correction to apply. */

};

static inline int decode(const void *ptr) {

return be32toh(*(int *)ptr);

}

static inline int64_t decode64(const void *ptr) {

return be64toh(*(int64_t *)ptr);

}

int time_get_dst(time_t date, const char *tzfile,

time_t *switch_cur, char **zone_cur, bool *dst_cur,

time_t *switch_next, int *delta_next, char **zone_next, bool *dst_next) {

unsigned char *type_idxs = 0;

size_t num_types = 0;

struct ttinfo *types = NULL;

char *zone_names = NULL;

struct stat st;

size_t num_isstd, num_isgmt;

struct tzhead tzhead;

size_t chars;

size_t i;

size_t total_size;

size_t types_idx;

int trans_width = 4;

size_t tzspec_len;

size_t num_leaps;

size_t lo, hi;

size_t num_transitions = 0;

_cleanup_free_ time_t *transitions = NULL;

_cleanup_fclose_ FILE *f;

f = fopen(tzfile, "re");

if (f == NULL)

return -errno;

if (fstat(fileno(f), &st) < 0)

return -errno;

read_again:

if (fread((void *)&tzhead, sizeof(tzhead), 1, f) != 1 ||

memcmp(tzhead.tzh_magic, TZ_MAGIC, sizeof(tzhead.tzh_magic)) != 0)

return -EINVAL;

num_transitions = (size_t)decode(tzhead.tzh_timecnt);

num_types = (size_t)decode(tzhead.tzh_typecnt);

chars = (size_t)decode(tzhead.tzh_charcnt);

num_leaps = (size_t)decode(tzhead.tzh_leapcnt);

num_isstd = (size_t)decode(tzhead.tzh_ttisstdcnt);

num_isgmt = (size_t)decode(tzhead.tzh_ttisgmtcnt);

/* For platforms with 64-bit time_t we use the new format if available. */

if (sizeof(time_t) == 8 && trans_width == 4 && tzhead.tzh_version[0] != '\0') {

size_t to_skip;

/* We use the 8-byte format. */

trans_width = 8;

/* Position the stream before the second header. */

to_skip = (num_transitions * (4 + 1)

+ num_types * 6

+ chars

+ num_leaps * 8 + num_isstd + num_isgmt);

if (fseek(f, to_skip, SEEK_CUR) != 0)

return -EINVAL;

goto read_again;

}

if (num_transitions > ((SIZE_MAX - (__alignof__(struct ttinfo) - 1)) / (sizeof(time_t) + 1)))

return -EINVAL;

total_size = num_transitions * (sizeof(time_t) + 1);

total_size = ((total_size + __alignof__(struct ttinfo) - 1) & ~(__alignof__(struct ttinfo) - 1));

types_idx = total_size;

if (num_leaps > (SIZE_MAX - total_size) / sizeof(struct ttinfo))

return -EINVAL;

total_size += num_types * sizeof(struct ttinfo);

if (chars > SIZE_MAX - total_size)

return -EINVAL;

total_size += chars;

if (__alignof__(struct leap) - 1 > SIZE_MAX - total_size)

return -EINVAL;

total_size = ((total_size + __alignof__(struct leap) - 1) & ~(__alignof__(struct leap) - 1));

if (num_leaps > (SIZE_MAX - total_size) / sizeof(struct leap))

return -EINVAL;

total_size += num_leaps * sizeof(struct leap);

tzspec_len = 0;

if (sizeof(time_t) == 8 && trans_width == 8) {

off_t rem = st.st_size - ftello(f);

if (rem < 0 || (size_t) rem < (num_transitions * (8 + 1) + num_types * 6 + chars))

return -EINVAL;

tzspec_len = (size_t) rem - (num_transitions * (8 + 1) + num_types * 6 + chars);

if (num_leaps > SIZE_MAX / 12 || tzspec_len < num_leaps * 12)

return -EINVAL;

tzspec_len -= num_leaps * 12;

if (tzspec_len < num_isstd)

return -EINVAL;

tzspec_len -= num_isstd;

if (tzspec_len == 0 || tzspec_len - 1 < num_isgmt)

return -EINVAL;

tzspec_len -= num_isgmt + 1;

if (SIZE_MAX - total_size < tzspec_len)

return -EINVAL;

}

transitions = malloc0(total_size + tzspec_len);

if (transitions == NULL)

return -EINVAL;

type_idxs = (unsigned char *)transitions + (num_transitions

* sizeof(time_t));

types = (struct ttinfo *)((char *)transitions + types_idx);

zone_names = (char *)types + num_types * sizeof(struct ttinfo);

if (sizeof(time_t) == 4 || trans_width == 8) {

if (fread(transitions, trans_width + 1, num_transitions, f) != num_transitions)

return -EINVAL;

} else {

if (fread(transitions, 4, num_transitions, f) != num_transitions ||

fread(type_idxs, 1, num_transitions, f) != num_transitions)

return -EINVAL;

}

/* Check for bogus indices in the data file, so we can hereafter

for (i = 0; i < num_transitions; ++i)

if (type_idxs[i] >= num_types)

return -EINVAL;

if (BYTE_ORDER == BIG_ENDIAN ? sizeof(time_t) == 8 && trans_width == 4

: sizeof(time_t) == 4 || trans_width == 4) {

/* Decode the transition times, stored as 4-byte integers in

i = num_transitions;

while (i-- > 0)

transitions[i] = decode((char *)transitions + i * 4);

} else if (BYTE_ORDER != BIG_ENDIAN && sizeof(time_t) == 8) {

/* Decode the transition times, stored as 8-byte integers in

for (i = 0; i < num_transitions; ++i)

transitions[i] = decode64((char *)transitions + i * 8);

}

for (i = 0; i < num_types; ++i) {

unsigned char x[4];

int c;

if (fread(x, 1, sizeof(x), f) != sizeof(x))

return -EINVAL;

c = getc(f);

if ((unsigned int)c > 1u)

return -EINVAL;

types[i].isdst = c;

c = getc(f);

if ((size_t) c > chars)

/* Bogus index in data file. */

return -EINVAL;

types[i].idx = c;

types[i].offset = (long int)decode(x);

}

if (fread(zone_names, 1, chars, f) != chars)

return -EINVAL;

for (i = 0; i < num_isstd; ++i) {

int c = getc(f);

if (c == EOF)

return -EINVAL;

types[i].isstd = c != 0;

}

while (i < num_types)

types[i++].isstd = 0;

for (i = 0; i < num_isgmt; ++i) {

int c = getc(f);

if (c == EOF)

return -EINVAL;

types[i].isgmt = c != 0;

}

while (i < num_types)

types[i++].isgmt = 0;

if (num_transitions == 0)

return -EINVAL;

if (date < transitions[0] || date >= transitions[num_transitions - 1])

return -EINVAL;

/* Find the first transition after TIMER, and

lo = 0;

hi = num_transitions - 1;

/* Assume that DST is changing twice a year and guess initial

i = (transitions[num_transitions - 1] - date) / 15778476;

if (i < num_transitions) {

i = num_transitions - 1 - i;

if (date < transitions[i]) {

if (i < 10 || date >= transitions[i - 10]) {

/* Linear search. */

while (date < transitions[i - 1])

i--;

goto found;

}

hi = i - 10;

} else {

if (i + 10 >= num_transitions || date < transitions[i + 10]) {

/* Linear search. */

while (date >= transitions[i])

i++;

goto found;

}

lo = i + 10;

}

}

/* Binary search. */

while (lo + 1 < hi) {

i = (lo + hi) / 2;

if (date < transitions[i])

hi = i;

else

lo = i;

}

i = hi;

found:

if (switch_cur)

*switch_cur = transitions[i-1];

if (zone_cur)

*zone_cur = strdup(&zone_names[types[type_idxs[i - 1]].idx]);

if (dst_cur)

*dst_cur = types[type_idxs[i-1]].isdst;

if (switch_next)

*switch_next = transitions[i];

if (delta_next)

*delta_next = (types[type_idxs[i]].offset - types[type_idxs[i-1]].offset) / 60;

if (zone_next)

*zone_next = strdup(&zone_names[types[type_idxs[i]].idx]);

if (dst_next)

*dst_next = types[type_idxs[i]].isdst;

return 0;

}