@@ -2,63 +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.
14−
15−{-
16−Copyright (c) 2010 Yitzchak Gale. All rights reserved.
17−
18−Redistribution and use in source and binary forms, with or without
19−modification, are permitted provided that the following conditions are
20−met:
21−
22− * Redistributions of source code must retain the above copyright
23− notice, this list of conditions and the following disclaimer.
24−
25− * Redistributions in binary form must reproduce the above
26− copyright notice, this list of conditions and the following
27− disclaimer in the documentation and/or other materials provided
28− with the distribution.
29−
30− * Neither the name of Yitzchak Gale nor the names of other
31− contributors may be used to endorse or promote products derived
32− from this software without specific prior written permission.
33−
34−THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35−"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36−LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37−A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38−OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39−SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40−LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41−DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42−THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43−(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44−OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45−----------------------------------------------------------------------------}
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>.
14+
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. -}
4619
4720module Data.Time.LocalTime.TimeZone.Olson.Render
4821(
49− -- * Rendering Olson timezone data
22+ -- * Rendering Olson timezone files
5023 -- | If any of the transition times or leap second times specified
5124 -- require more than a 32-bit integer to represent as a Unix
5225 -- timestamp, or if a POSIX-style TZ string is specified, timezone
5326 -- data is rendered using Version 2 format. Otherwise, the timezone data
5427 -- is rendered using Version 1 format.
28+ renderTimeZoneSeriesToOlsonFile,
29+ timeZoneSeriesToOlson,
5530 renderOlsonToFile,
31+ verifyOlsonLimits,
5632 putOlson,
57− splitOlson
33+ extractOlsonV1
5834)
5935where
6036
6137import 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)
6241import Data.Binary.Put (Put, runPut, putByteString, putWord8, flush,
6342 putWord32be, putWord64be)
6443import qualified Data.ByteString as B
@@ -66,78 +45,117 @@ import qualified Data.ByteString.Lazy as L
6645import Data.List (partition, sortBy, sort, group)
6746import Data.Ord (comparing)
6847import Data.Word (Word8)
69−import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe)
48+import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe, catMaybes)
7049import Data.Monoid (mempty)
71−import Control.Monad (guard, replicateM_)
50+import Control.Monad (guard, replicateM_, unless)
7251
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
7398
7499-- | 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.
75105renderOlsonToFile :: FilePath -> OlsonData -> IO ()
76−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
77110
78111-- | Render Olson timezone data in binary Olson timezone file format
79112-- as a lazy @ByteString@
80−putOlson :: OlsonData -> Put
81−putOlson olson = do
82− putASCII "TZif"
83− putWord8 version
84− putByteString . B.pack $ replicate 15 0 -- padding nulls
85− putOlsonParts version olson1 olson2 posix
86− 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
87118 where
88− (olson1, olson2, posix) = splitOlson olson
89− version
90− | olson2 /= mempty = 50
91− | otherwise = maybe 0 (const 50) $ posix >>= guard . not . null
92−
93−-- | Split Olson timezone data into three parts: timezone data that can
94−-- be rendered using Version 1 format, timezone data that can only be
95−-- rendered using Version 2 format, and the POSIX-style TZ string
96−-- if specified
97−splitOlson :: OlsonData -> (OlsonData, OlsonData, Maybe String)
98−splitOlson (OlsonData transs ttinfos leaps posix) =
99− (OlsonData transs1 ttinfos1 leaps1 Nothing,
100− OlsonData transs2 ttinfos2 leaps2 Nothing,
101− 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
102128 where
103129 cutoff = 0x80000000 -- 2^31
104− ( leaps1 , leaps2 ) = partition ((>= cutoff) . leapTime) leaps
105− (transs1', transs2') = partition ((>= cutoff) . transTime) transs
106− assoc1 = mkAssoc [0] transs1'
107− assoc2 = mkAssoc [] transs2'
108− transs1 = mkTranss transs1' assoc1
109− transs2 = mkTranss transs2' assoc2
110− ttinfos1 = mkTtinfos assoc1
111− ttinfos2 = mkTtinfos assoc2
112− 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
113135 (sortBy (comparing $ fmap tt_ttype . listToMaybe . flip drop ttinfos) .
114− uniq . sort . (prepend ++) $ map transIndex transs')
136+ uniq . sort . (0 :) $ map transIndex transs1')
115137 [0..]
116− mkTranss transs' assoc = [t {transIndex = i} |
117− t <- transs', i <- maybeToList $ lookup (transIndex t) assoc]
118− mkTtinfos assoc = map snd . dropWhile (isNothing . fst) .
119− sortBy (comparing fst) $ zip (map (flip lookup assoc) [0..]) ttinfos
120−
121−putOlsonParts :: Word8 -> OlsonData -> OlsonData -> Maybe String -> Put
122−putOlsonParts 0 olson1 _ _ = putOlsonPart put32bitIntegral olson1
123−putOlsonParts _ olson1 olson2 posix = do
124− putOlsonPart put32bitIntegral olson1
125− putOlsonPart put64bitIntegral olson2
126− putPosixTZ posix
127−
128−putOlsonPart :: (Integer -> Put) -> OlsonData -> Put
129−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
130148 replicateM_ 2 $ putCount ttinfosWithTtype
131− -- tzh_ttisgmtcnt
132− -- tzh_ttisstdcnt
133− putCount leaps -- tzh_leapcnt
134− putCount transs -- tzh_timecnt
135− putCount ttinfos -- tzh_typecnt
136− 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
137155 mapM_ (putTime . transTime ) transs
138156 mapM_ (put8bitIntegral . transIndex) transs
139157 mapM_ putTtInfo ttinfosIndexed
140− putASCII abbrChars
158+ mapM_ putAbbr abbrStrings
141159 mapM_ (putLeapInfo putTime) leaps
142160 mapM_ (putBool . (== Std) . tt_ttype) ttinfosWithTtype -- isstd
143161 mapM_ (putBool . (== UTC) . tt_ttype) ttinfosWithTtype -- isgmt
@@ -145,16 +163,18 @@ putOlsonPart putTime (OlsonData transs ttinfos leaps _) = do
145163 putCount = put32bitIntegral . length
146164 ttinfosWithTtype = takeWhile ((<= UTC) . tt_ttype) ttinfosIndexed
147165 abbrStrings = uniq . sort $ map tt_abbr ttinfos
148− 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
149170 ttinfosIndexed = [TtInfo gmtoff isdst ttype i |
150171 TtInfo gmtoff isdst ttype abbr <- ttinfos,
151− i <- maybeToList . lookup abbr . zip abbrStrings .
152− scanl (+) 0 $ map ((+ 1) . length) abbrStrings]
172+ i <- maybeToList $ lookup abbr abbrAssocs]
153173
154174putPosixTZ :: Maybe String -> Put
155175putPosixTZ posix = do
156176 putWord8 10
157− putASCII $ fromMaybe "" posix
177+ putASCII "POSIX TZ string"$ fromMaybe "" posix
158178 putWord8 10
159179
160180putTtInfo :: TtInfo Int -> Put
@@ -187,5 +207,11 @@ putBool True = putWord8 1
187207uniq :: Eq a => [a] -> [a]
188208uniq = map head . group
189209
190−putASCII :: String -> Put
191−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"