@@ -2,20 +2,20 @@
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−{- Copyright (c) 2010 Yitzchak Gale. All rights reserved. For
16−licensing information, see the BSD3-style license in the file LICENSE
17−that was originally distributed by the author together with this file.
18−-}
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. -}
1919
2020module Data.Time.LocalTime.TimeZone.Olson.Render
2121(
@@ -25,13 +25,19 @@ module Data.Time.LocalTime.TimeZone.Olson.Render
2525 -- timestamp, or if a POSIX-style TZ string is specified, timezone
2626 -- data is rendered using Version 2 format. Otherwise, the timezone data
2727 -- is rendered using Version 1 format.
28+ renderTimeZoneSeriesToOlsonFile,
29+ timeZoneSeriesToOlson,
2830 renderOlsonToFile,
31+ verifyOlsonLimits,
2932 putOlson,
30− splitOlson
33+ extractOlsonV1
3134)
3235where
3336
3437import 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)
3541import Data.Binary.Put (Put, runPut, putByteString, putWord8, flush,
3642 putWord32be, putWord64be)
3743import qualified Data.ByteString as B
@@ -39,78 +45,117 @@ import qualified Data.ByteString.Lazy as L
3945import Data.List (partition, sortBy, sort, group)
4046import Data.Ord (comparing)
4147import Data.Word (Word8)
42−import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe)
48+import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe, catMaybes)
4349import Data.Monoid (mempty)
44−import Control.Monad (guard, replicateM_)
50+import Control.Monad (guard, replicateM_, unless)
4551
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
4698
4799-- | 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.
48105renderOlsonToFile :: FilePath -> OlsonData -> IO ()
49−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
50110
51111-- | Render Olson timezone data in binary Olson timezone file format
52112-- as a lazy @ByteString@
53−putOlson :: OlsonData -> Put
54−putOlson olson = do
55− putASCII "TZif"
56− putWord8 version
57− putByteString . B.pack $ replicate 15 0 -- padding nulls
58− putOlsonParts version olson1 olson2 posix
59− 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
60118 where
61− (olson1, olson2, posix) = splitOlson olson
62− version
63− | olson2 /= mempty = 50
64− | otherwise = maybe 0 (const 50) $ posix >>= guard . not . null
65−
66−-- | Split Olson timezone data into three parts: timezone data that can
67−-- be rendered using Version 1 format, timezone data that can only be
68−-- rendered using Version 2 format, and the POSIX-style TZ string
69−-- if specified
70−splitOlson :: OlsonData -> (OlsonData, OlsonData, Maybe String)
71−splitOlson (OlsonData transs ttinfos leaps posix) =
72− (OlsonData transs1 ttinfos1 leaps1 Nothing,
73− OlsonData transs2 ttinfos2 leaps2 Nothing,
74− 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
75128 where
76129 cutoff = 0x80000000 -- 2^31
77− ( leaps1 , leaps2 ) = partition ((>= cutoff) . leapTime) leaps
78− (transs1', transs2') = partition ((>= cutoff) . transTime) transs
79− assoc1 = mkAssoc [0] transs1'
80− assoc2 = mkAssoc [] transs2'
81− transs1 = mkTranss transs1' assoc1
82− transs2 = mkTranss transs2' assoc2
83− ttinfos1 = mkTtinfos assoc1
84− ttinfos2 = mkTtinfos assoc2
85− 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
86135 (sortBy (comparing $ fmap tt_ttype . listToMaybe . flip drop ttinfos) .
87− uniq . sort . (prepend ++) $ map transIndex transs')
136+ uniq . sort . (0 :) $ map transIndex transs1')
88137 [0..]
89− mkTranss transs' assoc = [t {transIndex = i} |
90− t <- transs', i <- maybeToList $ lookup (transIndex t) assoc]
91− mkTtinfos assoc = map snd . dropWhile (isNothing . fst) .
92− sortBy (comparing fst) $ zip (map (flip lookup assoc) [0..]) ttinfos
93−
94−putOlsonParts :: Word8 -> OlsonData -> OlsonData -> Maybe String -> Put
95−putOlsonParts 0 olson1 _ _ = putOlsonPart put32bitIntegral olson1
96−putOlsonParts _ olson1 olson2 posix = do
97− putOlsonPart put32bitIntegral olson1
98− putOlsonPart put64bitIntegral olson2
99− putPosixTZ posix
100−
101−putOlsonPart :: (Integer -> Put) -> OlsonData -> Put
102−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
103148 replicateM_ 2 $ putCount ttinfosWithTtype
104− -- tzh_ttisgmtcnt
105− -- tzh_ttisstdcnt
106− putCount leaps -- tzh_leapcnt
107− putCount transs -- tzh_timecnt
108− putCount ttinfos -- tzh_typecnt
109− 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
110155 mapM_ (putTime . transTime ) transs
111156 mapM_ (put8bitIntegral . transIndex) transs
112157 mapM_ putTtInfo ttinfosIndexed
113− putASCII abbrChars
158+ mapM_ putAbbr abbrStrings
114159 mapM_ (putLeapInfo putTime) leaps
115160 mapM_ (putBool . (== Std) . tt_ttype) ttinfosWithTtype -- isstd
116161 mapM_ (putBool . (== UTC) . tt_ttype) ttinfosWithTtype -- isgmt
@@ -118,16 +163,18 @@ putOlsonPart putTime (OlsonData transs ttinfos leaps _) = do
118163 putCount = put32bitIntegral . length
119164 ttinfosWithTtype = takeWhile ((<= UTC) . tt_ttype) ttinfosIndexed
120165 abbrStrings = uniq . sort $ map tt_abbr ttinfos
121− 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
122170 ttinfosIndexed = [TtInfo gmtoff isdst ttype i |
123171 TtInfo gmtoff isdst ttype abbr <- ttinfos,
124− i <- maybeToList . lookup abbr . zip abbrStrings .
125− scanl (+) 0 $ map ((+ 1) . length) abbrStrings]
172+ i <- maybeToList $ lookup abbr abbrAssocs]
126173
127174putPosixTZ :: Maybe String -> Put
128175putPosixTZ posix = do
129176 putWord8 10
130− putASCII $ fromMaybe "" posix
177+ putASCII "POSIX TZ string"$ fromMaybe "" posix
131178 putWord8 10
132179
133180putTtInfo :: TtInfo Int -> Put
@@ -160,5 +207,11 @@ putBool True = putWord8 1
160207uniq :: Eq a => [a] -> [a]
161208uniq = map head . group
162209
163−putASCII :: String -> Put
164−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"