defmodule Timex.Parse.ZoneInfo.Parser do
@moduledoc """
This module is responsible for parsing binary zoneinfo files,
such as those found in /usr/local/zoneinfo.
"""
# See https://tools.ietf.org/id/draft-murchison-tzdist-tzif-00.html for details
defmodule Zone do
@moduledoc """
Represents the data retrieved from a binary tzfile.
"""
# Maximum version encountered
defstruct version: nil,
# Transition times
transitions: [],
# Leap second adjustments
leaps: [],
# POSIX-TZ rule that describes the zone for future dates
rule: nil
end
defmodule Header do
@moduledoc false
# Six big-endian 4-8 byte integers
# count of UTC/local indicators
defstruct utc_count: 0,
# count of standard/wall indicators
wall_count: 0,
# number of leap seconds
leap_count: 0,
# number of transition times
transition_count: 0,
# number of local time types (never zero)
type_count: 0,
# total number of characters of the zone abbreviations string
abbrev_length: 0
end
defmodule TransitionInfo do
@moduledoc false
# total ISO 8601 offset (std + dst)
defstruct gmt_offset: 0,
# The time at which this transition starts
starts_at: 0,
# Is this transition in daylight savings time
is_dst?: false,
# The lookup index of the abbreviation
abbrev_index: 0,
# The zone abbreviation
abbreviation: "N/A",
# Whether transitions are standard or wall
is_std?: true,
# Whether transitions are UTC or local
is_utc?: false
end
defmodule LeapSecond do
@moduledoc false
# The time at which this leap second occurs
defstruct epoch: 0,
# The number of leap seconds to be applied to UTC on/after epoch
correction: 0
end
defmodule Rule do
@moduledoc false
defstruct std_abbr: nil,
std_offset: 0,
dst_abbr: nil,
dst_offset: 0,
start_time: nil,
end_time: nil
end
defguardp is_digit(c) when c >= ?0 and c <= ?9
defguardp is_alphabetic(c) when (c >= ?A and c <= ?Z) or (c >= ?a and c <= ?z)
##############
# Macros defining common bitstring modifier combinations in zoneinfo files
defmacrop char() do
quote do: size(1) - unit(8) - integer
end
defmacrop bytes(size) do
quote do: binary - size(unquote(size)) - unit(8)
end
defmacrop integer_32bit_be do
quote do: big - size(4) - unit(8) - integer
end
defmacrop integer_64bit_be do
quote do: big - size(8) - unit(8) - integer
end
defmacrop signed_char_be do
quote do: big - size(1) - unit(8) - signed - integer
end
defmacrop unsigned_char_be do
quote do: big - size(1) - unit(8) - unsigned - integer
end
@doc """
Parses a binary representing a valid zoneinfo file.
Parses the timezone information inside, and returns it as a Zone struct.
"""
@spec parse(binary) :: {:ok, Zone.t()} | {:error, binary}
def parse(<<?T, ?Z, ?i, ?f, version::bytes(1), _reserved::bytes(15), rest::binary>>) do
version =
case version do
<<0>> ->
1
<<?2>> ->
2
<<?3>> ->
3
byte ->
{:error, {:invalid_tzfile_version, byte}, rest}
end
with v when is_integer(v) <- version,
{:ok, zoneinfo, _} <- parse_versioned_content(v, rest) do
{:ok, zoneinfo}
else
{:error, reason, _} ->
{:error, reason}
end
end
def parse(_) do
{:error, :invalid_zoneinfo_content}
end
@doc """
Like `parse/1`, but expects a file path to parse.
"""
def parse_file(path) when is_binary(path) do
if path |> File.exists?() do
path |> File.read!() |> parse()
else
{:error, "No zoneinfo file at #{path}"}
end
end
# Parses the content of a tzinfo file based on the version format
defp parse_versioned_content(version, data)
defp parse_versioned_content(1, data) do
with {:ok, zone, rest} <- parse_content(1, data, %Zone{version: 1}) do
transitions = Enum.sort_by(zone.transitions, fn tx -> tx.starts_at end)
leaps = Enum.sort_by(zone.leaps, fn leap -> leap.epoch end)
{:ok, %Zone{zone | transitions: transitions, leaps: leaps}, rest}
end
end
defp parse_versioned_content(version, data) do
expected_version =
case version do
1 -> <<0>>
2 -> <<?2>>
3 -> <<?3>>
end
with {:ok, zone1, rest} <- parse_content(1, data, %Zone{version: 1}),
{:header, <<?T, ?Z, ?i, ?f, ^expected_version::bytes(1), _::bytes(15), rest::binary>>} <-
{:header, rest},
{:ok, zone2, rest} <- parse_content(version, rest, %Zone{version: version}) do
# Append the second set of zone info to the first set
transitions =
zone1.transitions
|> Enum.concat(zone2.transitions)
|> Enum.sort_by(fn tx -> tx.starts_at end)
leaps =
zone1.leaps
|> Enum.concat(zone2.leaps)
|> Enum.sort_by(fn leap -> leap.epoch end)
zone = %Zone{
version: zone2.version,
transitions: transitions,
leaps: leaps,
rule: zone2.rule
}
{:ok, zone, rest}
else
{:header, bytes} ->
{:error, {:invalid_version_header, version}, bytes}
end
end
# Parsing the content of a tzinfo file starting with the header
#
# ## Header Format
#
# +---------------+---+
# | magic (4) | <-+-- version (1)
# +---------------+---+---------------------------------------+
# | [unused - reserved for future use] (15) |
# +---------------+---------------+---------------+-----------+
# | isutccnt (4) | isstdcnt (4) | leapcnt (4) |
# +---------------+---------------+---------------+
# | timecnt (4) | typecnt (4) | charcnt (4) |
# ---
#
# ## 32-bit Body Format
#
# | transition times (timecnt x 4) ...
# +-----------------------------------------------+
# | transition time index (timecnt) ...
# +-----------------------------------------------+
# | local time type records (typecnt x 6) ...
# +-----------------------------------------------+
# | time zone designations (charcnt) ...
# +-----------------------------------------------+
# | leap second records (leapcnt x 8) ...
# +-----------------------------------------------+
# | standard/wall indicators (isstdcnt) ...
# +-----------------------------------------------+
# | UTC/local indicators (isutccnt) ...
# +-----------------------------------------------+
#
# ## 64-bit Body Format
#
# | transition times (timecnt x 8) ...
# +-----------------------------------------------+
# | transition time index (timecnt) ...
# +-----------------------------------------------+
# | local time type records (typecnt x 6) ...
# +-----------------------------------------------+
# | time zone designations (charcnt) ...
# +-----------------------------------------------+
# | leap second records (leapcnt x 12) ...
# +-----------------------------------------------+
# | standard/wall indicators (isstdcnt) ...
# +-----------------------------------------------+
# | UTC/local indicators (isutccnt) ...
# +---+---------------------------------------+---+
# | NL| POSIX TZ string (0...) |NL |
# +---+---------------------------------------+---+
defp parse_content(version, <<header_raw::bytes(24), rest::binary>>, zone) do
{utc_count, header_raw} = parse_i32(header_raw)
{wall_count, header_raw} = parse_i32(header_raw)
{leap_count, header_raw} = parse_i32(header_raw)
{tx_count, header_raw} = parse_i32(header_raw)
{type_count, header_raw} = parse_i32(header_raw)
{abbrev_length, _} = parse_i32(header_raw)
header = %Header{
utc_count: utc_count,
wall_count: wall_count,
leap_count: leap_count,
transition_count: tx_count,
type_count: type_count,
abbrev_length: abbrev_length
}
parse_transition_times(version, rest, header, zone)
end
# Parse the number of transition times in this zone
defp parse_transition_times(version, data, %Header{transition_count: tx_count} = header, zone) do
{times, rest} = parse_array(data, tx_count, &parse_int(version, &1))
parse_transition_info(version, rest, header, %Zone{zone | transitions: times})
end
# Parse transition time info for this zone
defp parse_transition_info(
version,
data,
%Header{transition_count: tx_count, type_count: type_count} = header,
%Zone{transitions: transitions} = zone
) do
{indices, rest} = parse_array(data, tx_count, &parse_uchar/1)
{txinfos, rest} =
parse_array(rest, type_count, fn data ->
{gmt_offset, next} = parse_i32(data)
{is_dst, next} = parse_char(next)
{abbrev_index, next} = parse_uchar(next)
info = %TransitionInfo{
gmt_offset: gmt_offset,
is_dst?: is_dst == 1,
abbrev_index: abbrev_index
}
{info, next}
end)
txs =
indices
|> Enum.map(&Enum.at(txinfos, &1))
|> Enum.zip(transitions)
|> Enum.map(fn {info, time} ->
Map.put(info, :starts_at, time)
end)
parse_abbreviations(version, rest, header, %Zone{zone | transitions: txs})
end
# Parses zone abbreviations for this zone
defp parse_abbreviations(
version,
data,
%Header{abbrev_length: len} = header,
%Zone{transitions: transitions} = zone
) do
<<abbrevs::bytes(len), rest::binary>> = data
txinfos =
Enum.map(transitions, fn %TransitionInfo{abbrev_index: idx} = tx ->
{:ok, abbrev, _} = parse_null_terminated_str(:binary.part(abbrevs, idx, len - idx))
%{tx | :abbreviation => abbrev}
end)
parse_leap_seconds(version, rest, header, %Zone{zone | transitions: txinfos})
end
# Parses leap second information for this zone
defp parse_leap_seconds(version, data, %Header{leap_count: count} = header, zone) do
{leaps, rest} =
parse_array(data, count, fn data ->
{epoch, next} = parse_int(version, data)
{correction, next} = parse_i32(next)
leap = %LeapSecond{
epoch: epoch,
correction: correction
}
{leap, next}
end)
parse_flags(version, rest, header, %Zone{zone | leaps: leaps})
end
# Parses the trailing flags in the zoneinfo binary
defp parse_flags(version, data, %Header{utc_count: utc_count, wall_count: wall_count}, zone) do
{is_std_indicators, rest} = parse_array(data, wall_count, &parse_char/1)
{is_utc_indicators, rest} = parse_array(rest, utc_count, &parse_char/1)
transitions =
zone.transitions
|> Enum.with_index()
|> Enum.map(fn {tx, i} ->
is_std? = Enum.at(is_std_indicators, i) == 1
is_utc? = Enum.at(is_utc_indicators, i) == 1
%{tx | :is_std? => is_std?, :is_utc? => is_utc?}
end)
if version > 1 do
parse_posixtz_string(version, rest, %Zone{zone | transitions: transitions})
else
{:ok, %Zone{zone | transitions: transitions}, rest}
end
end
# stdoffset[dst[offset][,start[/time],end[/time]]]
defp parse_posixtz_string(_version, <<?\n, rest::binary>>, zone) do
with {:ok, format_str, rest} <- parse_newline_terminated_str(rest),
{:ok, rule, format_rest} <- parse_tz(format_str) do
{:ok, %Zone{zone | rule: rule}, format_rest <> rest}
end
end
defp parse_posixtz_string(_version, rest, _zone) do
{:error, {:invalid_format, "expected newline to follow set of utc/local indicators"}, rest}
end
defp parse_tz(""), do: {:ok, nil, ""}
defp parse_tz(str), do: parse_tz(:std_abbr, str, %Rule{})
defp parse_tz(:std_abbr, str, rule) do
with {:ok, abbr, rest} <- parse_abbrev(str) do
parse_tz(:std_offset, rest, %Rule{rule | std_abbr: abbr, dst_abbr: abbr})
end
end
defp parse_tz(:std_offset, str, rule) do
with {:ok, offset, rest} <- parse_offset(str) do
parse_tz(:dst_abbr, rest, %Rule{rule | std_offset: offset, dst_offset: offset})
else
{:error, nil, ""} ->
{:ok, rule, ""}
{:error, nil, rest} ->
parse_tz(:dst_abbr, rest, rule)
{:error, _, _} = err ->
err
end
end
# dst[offset][,...]
defp parse_tz(:dst_abbr, str, rule) do
with {:ok, abbr, rest} <- parse_abbrev(str),
rule = %Rule{rule | dst_abbr: abbr} do
# dst_offset is optional, and may or may not be followed by a comma and start/end rule
# if the offset is not present.
case rest do
<<>> ->
{:ok, rule, ""}
<<?,, rest::binary>> ->
parse_tz(:rule_period, rest, rule)
_ ->
parse_tz(:dst_offset, rest, rule)
end
end
end
# offset[,...]
defp parse_tz(:dst_offset, str, rule) do
with {:ok, offset, rest} <- parse_offset(str),
rule = %Rule{rule | dst_offset: offset} do
case rest do
<<>> ->
{:ok, rule, ""}
<<?,, rest::binary>> ->
parse_tz(:rule_period, rest, rule)
_ ->
{:error, :invalid_tz_rule_format}
end
else
{:error, nil, ""} ->
{:ok, rule, ""}
{:error, nil, <<?,, rest::binary>>} ->
parse_tz(:rule_period, rest, rule)
{:error, _, _} = err ->
err
end
end
defp parse_tz(:rule_period, str, rule) do
case String.split(str, ",", parts: 2, trim: false) do
[start_dt, end_dt] ->
with {:ok, start_time, _} <- parse_posixtz_datetime(start_dt),
{:ok, end_time, rest} <- parse_posixtz_datetime(end_dt) do
{:ok, %Rule{rule | start_time: start_time, end_time: end_time}, rest}
else
{:ok, _, rest} ->
{:error, :expected_comma, rest}
{:error, _, _} = err ->
err
end
_ ->
{:error, :expected_datetime_range, str}
end
end
defp parse_posixtz_datetime(str) do
result =
case str do
<<?M, rest::binary>> -> parse_month_week_day(rest)
<<?J, rest::binary>> -> parse_julian_day(rest, allow_leap_days: false)
_ -> parse_julian_day(str, allow_leap_days: true)
end
with {:ok, date, rest} <- result do
case rest do
<<?/, rest::binary>> ->
with {:ok, time, rest} <- parse_time(rest) do
{:ok, {date, time}, rest}
end
_ ->
{:ok, {date, Timex.Time.new!(2, 0, 0, 0)}, rest}
end
end
end
defp parse_month_week_day(str) do
case String.split(str, ".", parts: 3, trim: false) do
[m, n, rest] ->
case Integer.parse(rest) do
{d, rest} ->
with {:ok, date} <- parse_month_week_day(m, n, d) do
{:ok, date, rest}
else
{:error, reason} ->
{:error, reason, str}
end
:error ->
{:error, :expected_day_number, str}
end
_ ->
{:error, :invalid_month_week_day, str}
end
end
defp parse_month_week_day(m, n, d) do
with {:ok, m} <- to_integer(m),
{:ok, n} <- to_integer(n),
{:ok, d} <- to_integer(d) do
cond do
m < 1 or m > 12 ->
{:error, :invalid_month}
n < 1 or n > 5 ->
{:error, :invalid_week_of_month}
d < 0 or d > 6 ->
{:error, :invalid_week_day}
:else ->
{:ok, {:mwd, {m, n, d}}}
end
else
:error ->
{:error, :invalid_number}
end
end
defp parse_julian_day(str, opts) do
with {:ok, day, rest} <- parse_integer_unsigned(str) do
allow_leaps? = Keyword.get(opts, :allow_leap_days, true)
cond do
# Day of year including Feb 29
allow_leaps? and day >= 0 and day <= 365 ->
{:ok, {:julian, day, opts}, rest}
allow_leaps? ->
{:error, {:invalid_julian_day, day}, str}
# Day of year without Feb 29, i.e. day 59 is Feb 28, and day 60 is Mar 1
day >= 1 and day <= 365 ->
{:ok, {:julian, day, opts}, rest}
:else ->
{:error, {:invalid_julian_day, day}, str}
end
end
end
defp parse_abbrev(<<?<, rest::binary>>), do: parse_quoted_abbrev(rest)
defp parse_abbrev(str), do: parse_unquoted_abbrev(str)
defp parse_quoted_abbrev(str, acc \\ "")
defp parse_quoted_abbrev(<<?>, rest::binary>>, acc) when byte_size(acc) < 3,
do: {:error, {:invalid_quoted_abbreviation, acc}, rest}
defp parse_quoted_abbrev(<<?>, rest::binary>>, acc),
do: {:ok, acc, rest}
defp parse_quoted_abbrev(<<c::char(), rest::binary>>, acc),
do: parse_quoted_abbrev(rest, acc <> <<c::char()>>)
defp parse_quoted_abbrev(<<>>, acc),
do: {:error, :unclosed_quoted_abbreviation, acc}
defp parse_unquoted_abbrev(str, acc \\ "")
defp parse_unquoted_abbrev(<<c::char(), rest::binary>>, acc) when is_alphabetic(c),
do: parse_unquoted_abbrev(rest, acc <> <<c::char()>>)
defp parse_unquoted_abbrev(rest, acc) when byte_size(acc) < 3,
do: {:error, {:invalid_unquoted_abbreviation, acc}, rest}
defp parse_unquoted_abbrev(rest, acc),
do: {:ok, acc, rest}
defp parse_offset(<<sign::char(), rest::binary>>) when sign in [?+, ?-],
do: parse_offset(rest, sign)
defp parse_offset(str) when is_binary(str),
do: parse_offset(str, ?+)
defp parse_offset(str, sign) do
sign = if sign == ?+, do: 1, else: -1
with {:ok, time, rest} <- parse_time(str),
{seconds, _} <- Timex.Time.to_seconds_after_midnight(time) do
{:ok, sign * seconds, rest}
end
end
defp parse_time(str) do
case parse_integer_unsigned(str) do
{:ok, hh, <<?:, rest::binary>>} when hh >= 0 and hh <= 24 ->
case parse_integer_unsigned(rest) do
{:ok, mm, <<?:, rest::binary>>} when mm >= 0 and mm < 60 ->
case parse_integer_unsigned(rest) do
{:ok, ss, rest} when ss >= 0 and ss < 60 ->
{:ok, Timex.Time.new!(hh, mm, ss, 0), rest}
_ ->
{:ok, Timex.Time.new!(hh, mm, 0, 0), rest}
end
{:ok, mm, rest} when mm >= 0 and mm < 60 ->
{:ok, Timex.Time.new!(hh, mm, 0, 0), rest}
_ ->
{:ok, Timex.Time.new!(hh, 0, 0, 0), rest}
end
{:ok, hh, rest} when hh >= 0 and hh <= 24 ->
{:ok, Timex.Time.new!(hh, 0, 0, 0), rest}
{:ok, _, _} ->
{:error, :invalid_hour, str}
{:error, _, _} = err ->
err
end
end
defp to_integer(n) when is_integer(n) and n >= 0, do: {:ok, n}
defp to_integer(s) when is_binary(s) do
with {:ok, n, _} <- parse_integer_signed(s) do
{:ok, n}
end
end
defp parse_integer_signed(str) do
case Integer.parse(str) do
{value, rest} ->
{:ok, value, rest}
_ ->
{:error, :invalid_number, str}
end
end
defp parse_integer_unsigned(str, acc \\ "")
defp parse_integer_unsigned(<<c::char(), rest::binary>>, acc) when is_digit(c) do
parse_integer_unsigned(rest, acc <> <<c::char()>>)
end
defp parse_integer_unsigned(rest, acc) when byte_size(acc) > 0 do
{:ok, String.to_integer(acc), rest}
end
defp parse_integer_unsigned(rest, _) do
{:error, :invalid_number, rest}
end
################
# Parses an array of a primitive type, ex:
# parse_array(<<"test">>, 2, &parse_uchar/1) => [?t, ?e]
###
defp parse_array(data, 0, _parser), do: {[], data}
defp parse_array(data, count, parser) when is_binary(data) and is_function(parser) do
{results, rest} = do_parse_array(data, count, parser, [])
{results, rest}
end
defp do_parse_array(data, 0, _, acc), do: {Enum.reverse(acc), data}
defp do_parse_array(data, count, parser, acc) do
{item, next} = parser.(data)
do_parse_array(next, count - 1, parser, [item | acc])
end
#################
# Data Type Parsers
defp parse_int(1, bin), do: parse_i32(bin)
defp parse_int(_, bin), do: parse_i64(bin)
defp parse_i32(<<val::integer_32bit_be(), rest::binary>>), do: {val, rest}
defp parse_i64(<<val::integer_64bit_be(), rest::binary>>), do: {val, rest}
defp parse_char(<<val::signed_char_be(), rest::binary>>), do: {val, rest}
defp parse_uchar(<<val::unsigned_char_be(), rest::binary>>), do: {val, rest}
defp parse_null_terminated_str(bin), do: parse_null_terminated_str(bin, <<>>)
defp parse_null_terminated_str(<<>>, acc), do: {:ok, acc, ""}
defp parse_null_terminated_str(<<0, rest::binary>>, acc), do: {:ok, acc, rest}
defp parse_null_terminated_str(<<c::char(), rest::binary>>, acc) do
parse_null_terminated_str(rest, acc <> <<c::char()>>)
end
defp parse_newline_terminated_str(bin), do: parse_newline_terminated_str(bin, <<>>)
defp parse_newline_terminated_str(<<>>, acc), do: {:ok, acc, ""}
defp parse_newline_terminated_str(<<?\n, rest::binary>>, acc), do: {:ok, acc, rest}
defp parse_newline_terminated_str(<<c::char(), rest::binary>>, acc) do
parse_newline_terminated_str(rest, acc <> <<c::char()>>)
end
end
