8f78022 · typeable/wai

40 sendGoaway e

41 | Just (ConnectionError err msg) <- E.fromException e = do

42 csid <- readIORef currentStreamId

43− let frame = goawayFrame csid err msg

43+ let !frame = goawayFrame csid err msg

44 enqueueControl outputQ 0 $ OGoaway frame

45 | otherwise = return ()

46

47 sendReset err sid = do

48− let frame = resetFrame err sid

48+ let !frame = resetFrame err sid

49 enqueueControl outputQ 0 $ OFrame frame

50

51 loop = do

176 Nothing -> return ()

177 unless (testAck flags) $ do

178 modifyIORef' http2settings $ \old -> updateSettings old alist

179− let frame = settingsFrame setAck []

179+ let !frame = settingsFrame setAck []

180 enqueueControl outputQ 0 $ OSettings frame alist

181 return True

182

184 if testAck flags then

185 E.throwIO $ ConnectionError ProtocolError "the ack flag of this ping frame must not be set"

186 else do

187− let frame = pingFrame bs

187+ let !frame = pingFrame bs

188 enqueueControl outputQ 0 $ OFrame frame

189 return True

190

194

195control FrameWindowUpdate header bs Context{connectionWindow} = do

196 WindowUpdateFrame n <- guardIt $ decodeWindowUpdateFrame header bs

197− w <- (n +) <$> atomically (readTVar connectionWindow)

197+ !w <- (n +) <$> atomically (readTVar connectionWindow)

198 when (isWindowOverflow w) $ E.throwIO $ ConnectionError FlowControlError "control window should be less than 2^31"

199 atomically $ writeTVar connectionWindow w

200 return True

225 Just p -> do

226 checkPriority p streamNumber

227 return p

228− let endOfStream = testEndStream flags

228+ let !endOfStream = testEndStream flags

229− endOfHeader = testEndHeader flags

229+ !endOfHeader = testEndHeader flags

230 if endOfHeader then do

231 hdr <- hpackDecodeHeader frag ctx

232 return $ if endOfStream then

241 -- trailer is not supported.

242 -- let's read and ignore it.

243 HeadersFrame _ _ <- guardIt $ decodeHeadersFrame header bs

244− let endOfStream = testEndStream flags

244+ let !endOfStream = testEndStream flags

245 if endOfStream then do

246 atomically $ writeTQueue q ""

247 return HalfClosed

255 Context{outputQ} s@(Open (Body q))

256 Stream{streamNumber,streamBodyLength,streamContentLength} = do

257 DataFrame body <- guardIt $ decodeDataFrame header bs

258− let endOfStream = testEndStream flags

258+ let !endOfStream = testEndStream flags

259 len0 <- readIORef streamBodyLength

260 let !len = len0 + payloadLength

261 writeIORef streamBodyLength len

262 when (payloadLength /= 0) $ do

263− let frame1 = windowUpdateFrame 0 payloadLength

263+ let !frame1 = windowUpdateFrame 0 payloadLength

264− frame2 = windowUpdateFrame streamNumber payloadLength

264+ !frame2 = windowUpdateFrame streamNumber payloadLength

265− frame = frame1 `BS.append` frame2

265+ !frame = frame1 `BS.append` frame2

266 enqueueControl outputQ 0 $ OFrame frame

267 atomically $ writeTQueue q body

268 if endOfStream then do

276 return s

277

278stream FrameContinuation FrameHeader{flags} frag ctx (Open (Continued rfrags siz n endOfStream pri)) _ = do

279− let endOfHeader = testEndHeader flags

279+ let !endOfHeader = testEndHeader flags

280− rfrags' = frag : rfrags

280+ !rfrags' = frag : rfrags

281− siz' = siz + BS.length frag

281+ !siz' = siz + BS.length frag

282− n' = n + 1

282+ !n' = n + 1

283 when (siz' > 51200) $ -- fixme: hard coding: 50K

284 E.throwIO $ ConnectionError EnhanceYourCalm "Header is too big"

285 when (n' > 10) $ -- fixme: hard coding

286 E.throwIO $ ConnectionError EnhanceYourCalm "Header is too fragmented"

287 if endOfHeader then do

288− let hdrblk = BS.concat $ reverse rfrags'

288+ let !hdrblk = BS.concat $ reverse rfrags'

289 hdr <- hpackDecodeHeader hdrblk ctx

290 return $ if endOfStream then

291 Open (NoBody hdr pri)

296

297stream FrameWindowUpdate header@FrameHeader{streamId} bs _ s Stream{streamWindow} = do

298 WindowUpdateFrame n <- guardIt $ decodeWindowUpdateFrame header bs

299− w <- (n +) <$> atomically (readTVar streamWindow)

299+ !w <- (n +) <$> atomically (readTVar streamWindow)

300 when (isWindowOverflow w) $

301 E.throwIO $ StreamError FlowControlError streamId

302 atomically $ writeTVar streamWindow w

304

305stream FrameRSTStream header bs ctx _ strm = do

306 RSTStreamFrame e <- guardIt $ decoderstStreamFrame header bs

307− let cc = Reset e

307+ let !cc = Reset e

308 closed ctx strm cc

309 return $ Closed cc -- will be written to streamState again

310