Debian Codegraph @

src/Network/WebSockets/Extensions/PermessageDeflate.hs

raw
1 --------------------------------------------------------------------------------
2 {-# LANGUAGE OverloadedStrings #-}
3 {-# LANGUAGE RecordWildCards #-}
4 {-# LANGUAGE TupleSections #-}
5 module Network.WebSockets.Extensions.PermessageDeflate
6 ( defaultPermessageDeflate
7 , PermessageDeflate(..)
8 , negotiateDeflate
9
10 -- * Considered internal
11 , makeMessageInflater
12 , makeMessageDeflater
13 ) where
14
15
16 --------------------------------------------------------------------------------
17 import Control.Applicative ((<$>))
18 import Control.Exception (throwIO)
19 import Control.Monad (foldM, unless)
20 import qualified Data.ByteString as B
21 import qualified Data.ByteString.Char8 as B8
22 import qualified Data.ByteString.Lazy as BL
23 import qualified Data.ByteString.Lazy.Char8 as BL8
24 import qualified Data.ByteString.Lazy.Internal as BL
25 import Data.Int (Int64)
26 import Data.Monoid
27 import qualified Data.Streaming.Zlib as Zlib
28 import Network.WebSockets.Connection.Options
29 import Network.WebSockets.Extensions
30 import Network.WebSockets.Extensions.Description
31 import Network.WebSockets.Http
32 import Network.WebSockets.Types
33 import Prelude
34 import Text.Read (readMaybe)
35
36
37 --------------------------------------------------------------------------------
38 -- | Convert the parameters to an 'ExtensionDescription' that we can put in a
39 -- 'Sec-WebSocket-Extensions' header.
40 toExtensionDescription :: PermessageDeflate -> ExtensionDescription
41 toExtensionDescription PermessageDeflate {..} = ExtensionDescription
42 { extName = "permessage-deflate"
43 , extParams =
44 [("server_no_context_takeover", Nothing) | serverNoContextTakeover] ++
45 [("client_no_context_takeover", Nothing) | clientNoContextTakeover] ++
46 [("server_max_window_bits", param serverMaxWindowBits) | serverMaxWindowBits /= 15] ++
47 [("client_max_window_bits", param clientMaxWindowBits) | clientMaxWindowBits /= 15]
48 }
49 where
50 param = Just . B8.pack . show
51
52
53 --------------------------------------------------------------------------------
54 toHeaders :: PermessageDeflate -> Headers
55 toHeaders pmd =
56 [ ( "Sec-WebSocket-Extensions"
57 , encodeExtensionDescriptions [toExtensionDescription pmd]
58 )
59 ]
60
61
62 --------------------------------------------------------------------------------
63 negotiateDeflate
64 :: SizeLimit -> Maybe PermessageDeflate -> NegotiateExtension
65 negotiateDeflate messageLimit pmd0 exts0 = do
66 (headers, pmd1) <- negotiateDeflateOpts exts0 pmd0
67 return Extension
68 { extHeaders = headers
69 , extParse = \parseRaw -> do
70 inflate <- makeMessageInflater messageLimit pmd1
71 return $ do
72 msg <- parseRaw
73 case msg of
74 Nothing -> return Nothing
75 Just m -> fmap Just (inflate m)
76
77 , extWrite = \writeRaw -> do
78 deflate <- makeMessageDeflater pmd1
79 return $ \msgs ->
80 mapM deflate msgs >>= writeRaw
81 }
82 where
83 negotiateDeflateOpts
84 :: ExtensionDescriptions
85 -> Maybe PermessageDeflate
86 -> Either String (Headers, Maybe PermessageDeflate)
87
88 negotiateDeflateOpts (ext : _) (Just x)
89 | extName ext == "x-webkit-deflate-frame" = Right
90 ([("Sec-WebSocket-Extensions", "x-webkit-deflate-frame")], Just x)
91
92 negotiateDeflateOpts (ext : _) (Just x)
93 | extName ext == "permessage-deflate" = do
94 x' <- foldM setParam x (extParams ext)
95 Right (toHeaders x', Just x')
96
97 negotiateDeflateOpts (_ : exts) (Just x) =
98 negotiateDeflateOpts exts (Just x)
99
100 negotiateDeflateOpts _ _ = Right ([], Nothing)
101
102
103 --------------------------------------------------------------------------------
104 setParam
105 :: PermessageDeflate -> ExtensionParam -> Either String PermessageDeflate
106 setParam pmd ("server_no_context_takeover", _) =
107 Right pmd {serverNoContextTakeover = True}
108
109 setParam pmd ("client_no_context_takeover", _) =
110 Right pmd {clientNoContextTakeover = True}
111
112 setParam pmd ("server_max_window_bits", Nothing) =
113 Right pmd {serverMaxWindowBits = 15}
114
115 setParam pmd ("server_max_window_bits", Just param) = do
116 w <- parseWindow param
117 Right pmd {serverMaxWindowBits = w}
118
119 setParam pmd ("client_max_window_bits", Nothing) = do
120 Right pmd {clientMaxWindowBits = 15}
121
122 setParam pmd ("client_max_window_bits", Just param) = do
123 w <- parseWindow param
124 Right pmd {clientMaxWindowBits = w}
125
126 setParam pmd (_, _) = Right pmd
127
128
129 --------------------------------------------------------------------------------
130 parseWindow :: B.ByteString -> Either String Int
131 parseWindow bs8 = case readMaybe (B8.unpack bs8) of
132 Just w
133 | w >= 8 && w <= 15 -> Right w
134 | otherwise -> Left $ "Window out of bounds: " ++ show w
135 Nothing -> Left $ "Can't parse window: " ++ show bs8
136
137
138 --------------------------------------------------------------------------------
139 -- | If the window_bits parameter is set to 8, we must set it to 9 instead.
140 --
141 -- Related issues:
142 -- - https://github.com/haskell/zlib/issues/11
143 -- - https://github.com/madler/zlib/issues/94
144 --
145 -- Quote from zlib manual:
146 --
147 -- For the current implementation of deflate(), a windowBits value of 8 (a
148 -- window size of 256 bytes) is not supported. As a result, a request for 8 will
149 -- result in 9 (a 512-byte window). In that case, providing 8 to inflateInit2()
150 -- will result in an error when the zlib header with 9 is checked against the
151 -- initialization of inflate(). The remedy is to not use 8 with deflateInit2()
152 -- with this initialization, or at least in that case use 9 with inflateInit2().
153 fixWindowBits :: Int -> Int
154 fixWindowBits n
155 | n < 9 = 9
156 | n > 15 = 15
157 | otherwise = n
158
159
160 --------------------------------------------------------------------------------
161 appTailL :: BL.ByteString
162 appTailL = BL.pack [0x00,0x00,0xff,0xff]
163
164
165 --------------------------------------------------------------------------------
166 maybeStrip :: BL.ByteString -> BL.ByteString
167 maybeStrip x | appTailL `BL.isSuffixOf` x = BL.take (BL.length x - 4) x
168 maybeStrip x = x
169
170
171 --------------------------------------------------------------------------------
172 rejectExtensions :: Message -> IO Message
173 rejectExtensions (DataMessage rsv1 rsv2 rsv3 _) | rsv1 || rsv2 || rsv3 =
174 throwIO $ CloseRequest 1002 "Protocol Error"
175 rejectExtensions x = return x
176
177
178 --------------------------------------------------------------------------------
179 makeMessageDeflater
180 :: Maybe PermessageDeflate -> IO (Message -> IO Message)
181 makeMessageDeflater Nothing = return rejectExtensions
182 makeMessageDeflater (Just pmd)
183 | serverNoContextTakeover pmd = do
184 return $ \msg -> do
185 ptr <- initDeflate pmd
186 deflateMessageWith (deflateBody ptr) msg
187 | otherwise = do
188 ptr <- initDeflate pmd
189 return $ \msg ->
190 deflateMessageWith (deflateBody ptr) msg
191 where
192 ----------------------------------------------------------------------------
193 initDeflate :: PermessageDeflate -> IO Zlib.Deflate
194 initDeflate PermessageDeflate {..} =
195 Zlib.initDeflate
196 pdCompressionLevel
197 (Zlib.WindowBits (- (fixWindowBits serverMaxWindowBits)))
198
199
200 ----------------------------------------------------------------------------
201 deflateMessageWith
202 :: (BL.ByteString -> IO BL.ByteString)
203 -> Message -> IO Message
204 deflateMessageWith deflater (DataMessage False False False (Text x _)) = do
205 x' <- deflater x
206 return (DataMessage True False False (Text x' Nothing))
207 deflateMessageWith deflater (DataMessage False False False (Binary x)) = do
208 x' <- deflater x
209 return (DataMessage True False False (Binary x'))
210 deflateMessageWith _ x = return x
211
212
213 ----------------------------------------------------------------------------
214 deflateBody :: Zlib.Deflate -> BL.ByteString -> IO BL.ByteString
215 deflateBody ptr = fmap maybeStrip . go . BL.toChunks
216 where
217 go [] =
218 dePopper (Zlib.flushDeflate ptr)
219 go (c : cs) = do
220 chunk <- Zlib.feedDeflate ptr c >>= dePopper
221 (chunk <>) <$> go cs
222
223
224 --------------------------------------------------------------------------------
225 dePopper :: Zlib.Popper -> IO BL.ByteString
226 dePopper p = p >>= \res -> case res of
227 Zlib.PRDone -> return BL.empty
228 Zlib.PRNext c -> BL.chunk c <$> dePopper p
229 Zlib.PRError x -> throwIO $ CloseRequest 1002 (BL8.pack (show x))
230
231
232 --------------------------------------------------------------------------------
233 makeMessageInflater
234 :: SizeLimit -> Maybe PermessageDeflate
235 -> IO (Message -> IO Message)
236 makeMessageInflater _ Nothing = return rejectExtensions
237 makeMessageInflater messageLimit (Just pmd)
238 | clientNoContextTakeover pmd =
239 return $ \msg -> do
240 ptr <- initInflate pmd
241 inflateMessageWith (inflateBody ptr) msg
242 | otherwise = do
243 ptr <- initInflate pmd
244 return $ \msg ->
245 inflateMessageWith (inflateBody ptr) msg
246 where
247 --------------------------------------------------------------------------------
248 initInflate :: PermessageDeflate -> IO Zlib.Inflate
249 initInflate PermessageDeflate {..} =
250 Zlib.initInflate
251 (Zlib.WindowBits (- (fixWindowBits clientMaxWindowBits)))
252
253
254 ----------------------------------------------------------------------------
255 inflateMessageWith
256 :: (BL.ByteString -> IO BL.ByteString)
257 -> Message -> IO Message
258 inflateMessageWith inflater (DataMessage True a b (Text x _)) = do
259 x' <- inflater x
260 return (DataMessage False a b (Text x' Nothing))
261 inflateMessageWith inflater (DataMessage True a b (Binary x)) = do
262 x' <- inflater x
263 return (DataMessage False a b (Binary x'))
264 inflateMessageWith _ x = return x
265
266
267 ----------------------------------------------------------------------------
268 inflateBody :: Zlib.Inflate -> BL.ByteString -> IO BL.ByteString
269 inflateBody ptr =
270 go 0 . BL.toChunks . (<> appTailL)
271 where
272 go :: Int64 -> [B.ByteString] -> IO BL.ByteString
273 go size0 [] = do
274 chunk <- Zlib.flushInflate ptr
275 checkSize (fromIntegral (B.length chunk) + size0)
276 return (BL.fromStrict chunk)
277 go size0 (c : cs) = do
278 chunk <- Zlib.feedInflate ptr c >>= dePopper
279 let size1 = size0 + BL.length chunk
280 checkSize size1
281 (chunk <>) <$> go size1 cs
282
283
284 ----------------------------------------------------------------------------
285 checkSize :: Int64 -> IO ()
286 checkSize size = unless (atMostSizeLimit size messageLimit) $ throwIO $
287 ParseException $ "Message of size " ++ show size ++ " exceeded limit"