@@ -2,37 +2,42 @@
22-----------------------------------------------------------------------------
33-- |
44-- Module : Data.Time.LocalTime.TimeZone.Olson.Render
5−-- Copyright : Yitzchak Gale 2010
5+-- Copyright : Yitzchak Gale 2018
66--
77-- Maintainer : Yitzchak Gale <gale@sefer.org>
88-- Portability : portable
99--
10−-- Render Olson timezone data in the standard binary format as
11−-- used in Olson timezone files, and as specified by the
12−-- tzfile(5) man page on Unix-like systems. For more information
13−-- about this format, see http://www.twinsun.com/tz/tz-link.htm.
10+-- Render Olson timezone data in the standard binary format as used in
11+-- Olson timezone files, and as specified by the tzfile(5) man page on
12+-- Unix-like systems. For more information about this format, see
13+-- <http://www.twinsun.com/tz/tz-link.htm>.
1414
15−{-
16−Copyright (c) 2010 Yitzchak Gale. All rights reserved.
17−For licensing information, see the file LICENSE that was
18−originally distributed by the author together with this file.
19−-}
15+{- Copyright (c) 2018ZZ Yitzchak Gale. All rights reserved.
16+For licensing information, see the BSD3-style license in the file
17+LICENSE that was originally distributed by the author together with
18+this file. -}
2019
2120module Data.Time.LocalTime.TimeZone.Olson.Render
2221(
23− -- * Rendering Olson timezone data
22+ -- * Rendering Olson timezone files
2423 -- | If any of the transition times or leap second times specified
2524 -- require more than a 32-bit integer to represent as a Unix
2625 -- timestamp, or if a POSIX-style TZ string is specified, timezone
2726 -- data is rendered using Version 2 format. Otherwise, the timezone data
2827 -- is rendered using Version 1 format.
28+ renderTimeZoneSeriesToOlsonFile,
29+ timeZoneSeriesToOlson,
2930 renderOlsonToFile,
31+ verifyOlsonLimits,
3032 putOlson,
31− splitOlson
33+ extractOlsonV1
3234)
3335where
3436
3537import Data.Time.LocalTime.TimeZone.Olson.Types
38+import Data.Time.LocalTime.TimeZone.Series (TimeZoneSeries(TimeZoneSeries))
39+import Data.Time (TimeZone(TimeZone, timeZoneSummerOnly, timeZoneName))
40+import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds)
3641import Data.Binary.Put (Put, runPut, putByteString, putWord8, flush,
3742 putWord32be, putWord64be)
3843import qualified Data.ByteString as B
@@ -40,78 +45,117 @@ import qualified Data.ByteString.Lazy as L
4045import Data.List (partition, sortBy, sort, group)
4146import Data.Ord (comparing)
4247import Data.Word (Word8)
43−import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe)
48+import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe, catMaybes)
4449import Data.Monoid (mempty)
45−import Control.Monad (guard, replicateM_)
50+import Control.Monad (guard, replicateM_, unless)
4651
52+-- | Render a @TimeZoneSeries@ as a binary Olson timezone file.
53+--
54+-- If the values in the Olson timezone data exceed the standard size
55+-- limits (see 'defaultLimits'), this function throws an
56+-- exception. For other behavior, use 'timeZoneSeriesToOlson',
57+-- 'verifyOlsonLimits', 'putOlson' and 'Data.Binary.Put.runPut'
58+-- directly.
59+renderTimeZoneSeriesToOlsonFile :: FilePath -> TimeZoneSeries -> IO ()
60+renderTimeZoneSeriesToOlsonFile fp = renderOlsonToFile fp .
61+ fromMaybe (error "Cannot render TimeZoneSeries: default is summer time") .
62+ timeZoneSeriesToOlson
63+
64+-- | Convert a @TimeZoneSeries@ to @OlsonData@ for rendering.
65+timeZoneSeriesToOlson :: TimeZoneSeries -> Maybe OlsonData
66+timeZoneSeriesToOlson (TimeZoneSeries dflt pairs)
67+ | timeZoneSummerOnly dflt && not (all timeZoneSummerOnly $ map snd pairs)
68+ = Nothing
69+ | otherwise = Just $
70+ OlsonData
71+ [Transition secs ttinfo |
72+ (t, tz) <- reverse pairs,
73+ let secs = round $ utcTimeToPOSIXSeconds t,
74+ ttinfo <- maybeToList $ lookup (mkTT tz) ttAssocs]
75+ ttinfos
76+ []
77+ Nothing
78+ where
79+ mkTT (TimeZone offset isdst abbr) =
80+ TtInfo (offset*60) isdst Wall abbr
81+ dfltTT = mkTT dflt
82+ ttAssocs = (dfltTT, 0) :
83+ zip (uniq . sort . filter (/= dfltTT) $ map (mkTT . snd) pairs) [1..]
84+ ttinfos = map fst ttAssocs
85+
86+-- | Check whether @OlsonData@ is within size limits.
87+verifyOlsonLimits :: SizeLimits -> OlsonData -> Bool
88+verifyOlsonLimits limits (OlsonData transs ttinfos leaps _) =
89+ withinLimit maxTimes transs &&
90+ withinLimit maxTypes ttinfos &&
91+ withinLimit maxLeaps leaps &&
92+ withinLimit maxAbbrChars abbrChars
93+ where
94+ withinLimit limit items = maybe True (null . flip drop items) $
95+ limit limits
96+ abbrChars = concat abbrStrs ++ map (const '\NUL') abbrStrs
97+ abbrStrs = map tt_abbr ttinfos
4798
4899-- | Render Olson timezone data as a binary Olson timezone file
100+--
101+-- If the values in the Olson timezone data exceed the standard size
102+-- limits (see 'defaultLimits'), this function throws an
103+-- exception. For other behavior, use 'verifyOlsonLimits', 'putOlson'
104+-- and 'Data.Binary.Put.runPut' directly.
49105renderOlsonToFile :: FilePath -> OlsonData -> IO ()
50−renderOlsonToFile fp = L.writeFile fp . runPut . putOlson
106+renderOlsonToFile fp olson = do
107+ unless (verifyOlsonLimits defaultLimits olson) $
108+ error "Olson timezone data exceeds size limits"
109+ L.writeFile fp . runPut . putOlson $ olson
51110
52111-- | Render Olson timezone data in binary Olson timezone file format
53112-- as a lazy @ByteString@
54−putOlson :: OlsonData -> Put
55−putOlson olson = do
56− putASCII "TZif"
57− putWord8 version
58− putByteString . B.pack $ replicate 15 0 -- padding nulls
59− putOlsonParts version olson1 olson2 posix
60− flush
113+putOlson olson@(OlsonData _ _ _ posix)
114+ | fitsInVersion1 = putOlsonPart 0 put32bitIntegral olson
115+ | otherwise = do putOlsonPart 50 put32bitIntegral olson1
116+ putOlsonPart 50 put64bitIntegral olson
117+ putPosixTZ posix
61118 where
62− (olson1, olson2, posix) = splitOlson olson
63− version
64− | olson2 /= mempty = 50
65− | otherwise = maybe 0 (const 50) $ posix >>= guard . not . null
66−
67−-- | Split Olson timezone data into three parts: timezone data that can
68−-- be rendered using Version 1 format, timezone data that can only be
69−-- rendered using Version 2 format, and the POSIX-style TZ string
70−-- if specified
71−splitOlson :: OlsonData -> (OlsonData, OlsonData, Maybe String)
72−splitOlson (OlsonData transs ttinfos leaps posix) =
73− (OlsonData transs1 ttinfos1 leaps1 Nothing,
74− OlsonData transs2 ttinfos2 leaps2 Nothing,
75− posix)
119+ olson1 = extractOlsonV1 olson
120+ fitsInVersion1 = fmap null posix /= Just False &&
121+ olson1 == olson {olsonPosixTZ = Nothing}
122+
123+-- | Extract Olson timezone data that can be rendered using Version 1 format
124+extractOlsonV1 :: OlsonData -> OlsonData
125+extractOlsonV1 (OlsonData transs ttinfos leaps _)
126+ | allV1 = OlsonData transs ttinfos leaps Nothing
127+ | otherwise = OlsonData transs1 ttinfos1 leaps1 Nothing
76128 where
77129 cutoff = 0x80000000 -- 2^31
78− ( leaps1 , leaps2 ) = partition ((>= cutoff) . leapTime) leaps
79− (transs1', transs2') = partition ((>= cutoff) . transTime) transs
80− assoc1 = mkAssoc [0] transs1'
81− assoc2 = mkAssoc [] transs2'
82− transs1 = mkTranss transs1' assoc1
83− transs2 = mkTranss transs2' assoc2
84− ttinfos1 = mkTtinfos assoc1
85− ttinfos2 = mkTtinfos assoc2
86− mkAssoc prepend transs' = zip
130+ fitsIn32bits x = x < cutoff && x >= negate cutoff
131+ leaps1 = filter (fitsIn32bits . leapTime) leaps
132+ transs1' = filter (fitsIn32bits . transTime) transs
133+ allV1 = length leaps1 == length leaps && length transs1' == length transs
134+ assoc1 = zip
87135 (sortBy (comparing $ fmap tt_ttype . listToMaybe . flip drop ttinfos) .
88− uniq . sort . (prepend ++) $ map transIndex transs')
136+ uniq . sort . (0 :) $ map transIndex transs1')
89137 [0..]
90− mkTranss transs' assoc = [t {transIndex = i} |
91− t <- transs', i <- maybeToList $ lookup (transIndex t) assoc]
92− mkTtinfos assoc = map snd . dropWhile (isNothing . fst) .
93− sortBy (comparing fst) $ zip (map (flip lookup assoc) [0..]) ttinfos
94−
95−putOlsonParts :: Word8 -> OlsonData -> OlsonData -> Maybe String -> Put
96−putOlsonParts 0 olson1 _ _ = putOlsonPart put32bitIntegral olson1
97−putOlsonParts _ olson1 olson2 posix = do
98− putOlsonPart put32bitIntegral olson1
99− putOlsonPart put64bitIntegral olson2
100− putPosixTZ posix
101−
102−putOlsonPart :: (Integer -> Put) -> OlsonData -> Put
103−putOlsonPart putTime (OlsonData transs ttinfos leaps _) = do
138+ transs1 = [t {transIndex = i} |
139+ t <- transs1', i <- maybeToList $ lookup (transIndex t) assoc1]
140+ ttinfos1 = map snd . dropWhile (isNothing . fst) .
141+ sortBy (comparing fst) $ zip (map (flip lookup assoc1) [0..]) ttinfos
142+
143+putOlsonPart :: Word8 -> (Integer -> Put) -> OlsonData -> Put
144+putOlsonPart version putTime (OlsonData transs ttinfos leaps _) = do
145+ putASCII "magic number" "TZif"
146+ putWord8 version
147+ putByteString . B.pack $ replicate 15 0 -- padding nulls
104148 replicateM_ 2 $ putCount ttinfosWithTtype
105− -- tzh_ttisgmtcnt
106− -- tzh_ttisstdcnt
107− putCount leaps -- tzh_leapcnt
108− putCount transs -- tzh_timecnt
109− putCount ttinfos -- tzh_typecnt
110− putCount abbrChars -- tzh_charcnt
149+ -- tzh_ttisgmtcnt
150+ -- tzh_ttisstdcnt
151+ putCount leaps -- tzh_leapcnt
152+ putCount transs -- tzh_timecnt
153+ putCount ttinfos -- tzh_typecnt
154+ put32bitIntegral abbrChars -- tzh_charcnt
111155 mapM_ (putTime . transTime ) transs
112156 mapM_ (put8bitIntegral . transIndex) transs
113157 mapM_ putTtInfo ttinfosIndexed
114− putASCII abbrChars
158+ mapM_ putAbbr abbrStrings
115159 mapM_ (putLeapInfo putTime) leaps
116160 mapM_ (putBool . (== Std) . tt_ttype) ttinfosWithTtype -- isstd
117161 mapM_ (putBool . (== UTC) . tt_ttype) ttinfosWithTtype -- isgmt
@@ -119,16 +163,18 @@ putOlsonPart putTime (OlsonData transs ttinfos leaps _) = do
119163 putCount = put32bitIntegral . length
120164 ttinfosWithTtype = takeWhile ((<= UTC) . tt_ttype) ttinfosIndexed
121165 abbrStrings = uniq . sort $ map tt_abbr ttinfos
122− abbrChars = concatMap (++ "\NUL") abbrStrings
166+ abbrChars = sum (map length abbrStrings) + length abbrStrings
167+ putAbbr abbr = putASCII "time zone abbreviation" abbr >> putWord8 0
168+ abbrAssocs = zip abbrStrings . scanl (+) 0 $
169+ map ((+ 1) . length) abbrStrings
123170 ttinfosIndexed = [TtInfo gmtoff isdst ttype i |
124171 TtInfo gmtoff isdst ttype abbr <- ttinfos,
125− i <- maybeToList . lookup abbr . zip abbrStrings .
126− scanl (+) 0 $ map ((+ 1) . length) abbrStrings]
172+ i <- maybeToList $ lookup abbr abbrAssocs]
127173
128174putPosixTZ :: Maybe String -> Put
129175putPosixTZ posix = do
130176 putWord8 10
131− putASCII $ fromMaybe "" posix
177+ putASCII "POSIX TZ string"$ fromMaybe "" posix
132178 putWord8 10
133179
134180putTtInfo :: TtInfo Int -> Put
@@ -161,5 +207,11 @@ putBool True = putWord8 1
161207uniq :: Eq a => [a] -> [a]
162208uniq = map head . group
163209
164−putASCII :: String -> Put
165−putASCII = putByteString . B.pack . map (fromIntegral . fromEnum)
210+putASCII :: String -> String -> Put
211+putASCII what =
212+ putByteString . B.pack . map (fromIntegral . verify . fromEnum)
213+ where
214+ verify c
215+ | c >= 32 && c <= 126 = c
216+ | otherwise = error $ "Cannot render TimeZoneSeries: " ++
217+ what ++ " contains non-ASCII characters"