{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE RecordWildCards #-}

module Network.HPACK.Table.Dynamic (
    DynamicTable (..),
    newDynamicTableForEncoding,
    newDynamicTableForDecoding,
    renewDynamicTable,
    huffmanDecoder,
    printDynamicTable,
    isDynamicTableEmpty,
    isSuitableSize,
    TableSizeAction (..),
    needChangeTableSize,
    setLimitForEncoding,
    resetLimitForEncoding,
    setHeaderListSizeLimit,
    getHeaderListSizeLimit,
    insertEntry,
    toDynamicEntry,
    CodeInfo (..),
    withDynamicTableForEncoding,
    withDynamicTableForDecoding,
    toIndexedEntry,
    fromHIndexToIndex,
    getRevIndex,
) where

import qualified Control.Exception as E
import Data.Array.Base (unsafeRead, unsafeWrite)
import Data.Array.IO (IOArray, newArray)
import qualified Data.ByteString.Char8 as BS
import Data.IORef

import Imports
import Network.HPACK.Huffman
import Network.HPACK.Table.Entry
import Network.HPACK.Table.RevIndex
import Network.HPACK.Table.Static
import Network.HPACK.Types

----------------------------------------------------------------

-- For decoder
{-# INLINE toIndexedEntry #-}
toIndexedEntry :: DynamicTable -> Index -> IO Entry
toIndexedEntry :: DynamicTable -> Int -> IO Entry
toIndexedEntry DynamicTable
dyntbl Int
idx
    | Int
idx Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = DecodeError -> IO Entry
forall e a. (HasCallStack, Exception e) => e -> IO a
E.throwIO (DecodeError -> IO Entry) -> DecodeError -> IO Entry
forall a b. (a -> b) -> a -> b
$ Int -> DecodeError
IndexOverrun Int
idx
    | Int
idx Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
staticTableSize = Entry -> IO Entry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Entry -> IO Entry) -> Entry -> IO Entry
forall a b. (a -> b) -> a -> b
$ Int -> Entry
toStaticEntry Int
idx
    | Bool
otherwise = DynamicTable -> Int -> IO Entry
toDynamicEntry DynamicTable
dyntbl Int
idx

-- For encoder
{-# INLINE fromHIndexToIndex #-}
fromHIndexToIndex :: DynamicTable -> HIndex -> IO Index
fromHIndexToIndex :: DynamicTable -> HIndex -> IO Int
fromHIndexToIndex DynamicTable
_ (SIndex Int
idx) = Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
idx
fromHIndexToIndex DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
..} (DIndex Int
didx) = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    x <- adj maxN (didx - off)
    -- Entries sit at off+1 .. off+n, so the relative position is 1 .. n.
    -- When the ring is full, n is maxN and the oldest entry is at off+maxN,
    -- which is off itself: the modulus makes that 0 rather than maxN, and 0
    -- is index 61 of the static table.  'toDynamicEntry', going the other
    -- way, lands on the right slot either way.
    let x' = if Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then Int
maxN else Int
x
    return $ x' + staticTableSize

----------------------------------------------------------------

type Table = IOArray Index Entry

{-
        offset
        v
   +-+-+-+-+-+-+-+-+
   | | | |z|y|x| | |
   +-+-+-+-+-+-+-+-+
          1 2 3      (numOfEntries = 3)

After insertion:

      offset
      v
   +-+-+-+-+-+-+-+-+
   | | |w|z|y|x| | |
   +-+-+-+-+-+-+-+-+
        1 2 3 4      (numOfEntries = 4)
-}

data CodeInfo = CIE EncodeInfo | CID DecodeInfo
data EncodeInfo
    = EncodeInfo
        RevIndex -- Reverse index
        -- The value informed by SETTINGS_HEADER_TABLE_SIZE.
        -- If 'Nothing', dynamic table size update is not necessary.
        -- Otherwise, dynamic table size update is sent
        -- and this value should be set to 'Nothing'.
        (IORef (Maybe Size))
data DecodeInfo
    = DecodeInfo
        HuffmanDecoder
        (IORef Size) -- The limit size

toEncodeInfo :: CodeInfo -> EncodeInfo
toEncodeInfo :: CodeInfo -> EncodeInfo
toEncodeInfo (CIE EncodeInfo
x) = EncodeInfo
x
toEncodeInfo CodeInfo
_ = [Char] -> EncodeInfo
forall a. HasCallStack => [Char] -> a
error [Char]
"toEncodeInfo"

toDecodeInfo :: CodeInfo -> DecodeInfo
toDecodeInfo :: CodeInfo -> DecodeInfo
toDecodeInfo (CID DecodeInfo
x) = DecodeInfo
x
toDecodeInfo CodeInfo
_ = [Char] -> DecodeInfo
forall a. HasCallStack => [Char] -> a
error [Char]
"toDecodeInfo"

-- | Type for dynamic table.
data DynamicTable = DynamicTable
    { DynamicTable -> CodeInfo
codeInfo :: CodeInfo
    , DynamicTable -> IORef Table
circularTable :: IORef Table
    -- ^ An array
    , DynamicTable -> IORef Int
offset :: IORef Index
    -- ^ Start point
    , DynamicTable -> IORef Int
numOfEntries :: IORef Int
    -- ^ The current number of entries
    , DynamicTable -> IORef Int
maxNumOfEntries :: IORef Int
    -- ^ The size of the array
    , DynamicTable -> IORef Int
dynamicTableSize :: IORef Size
    -- ^ The current dynamic table size (defined in HPACK)
    , DynamicTable -> IORef Int
maxDynamicTableSize :: IORef Size
    -- ^ The max dynamic table size (defined in HPACK)
    , DynamicTable -> IORef (Maybe Int)
headerListSizeLimit :: IORef (Maybe Size)
    -- ^ The limit on the decoded header list size, as defined in RFC 9113
    --   section 6.5.2 (the sum over each field of the length of its name,
    --   the length of its value, and 32). 'Nothing' means no limit. Used
    --   when decoding only.
    }

{-# INLINE adj #-}
adj :: Int -> Int -> IO Int
adj :: Int -> Int -> IO Int
adj Int
maxN Int
x
    | Int
maxN Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = DecodeError -> IO Int
forall e a. (HasCallStack, Exception e) => e -> IO a
E.throwIO DecodeError
TooSmallTableSize
    | Bool
otherwise =
        let ret :: Int
ret = (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
maxN) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
maxN
         in Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
ret

huffmanDecoder :: DynamicTable -> HuffmanDecoder
huffmanDecoder :: DynamicTable -> HuffmanDecoder
huffmanDecoder DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = HuffmanDecoder
dec
  where
    DecodeInfo HuffmanDecoder
dec IORef Int
_ = CodeInfo -> DecodeInfo
toDecodeInfo CodeInfo
codeInfo

----------------------------------------------------------------

-- | Printing 'DynamicTable'.
printDynamicTable :: DynamicTable -> IO ()
printDynamicTable :: DynamicTable -> IO ()
printDynamicTable DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    let beg = Int
off Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
        end = Int
off Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n
    tbl <- readIORef circularTable
    es <- mapM (adj maxN >=> unsafeRead tbl) [beg .. end]
    let ts = [Int] -> [Entry] -> [(Int, Entry)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1 ..] [Entry]
es
    mapM_ printEntry ts
    dsize <- readIORef dynamicTableSize
    maxdsize <- readIORef maxDynamicTableSize
    putStrLn $ "      Table size: " ++ show dsize ++ "/" ++ show maxdsize

printEntry :: (Index, Entry) -> IO ()
printEntry :: (Int, Entry) -> IO ()
printEntry (Int
i, Entry
e) = do
    [Char] -> IO ()
putStr [Char]
"[ "
    [Char] -> IO ()
putStr ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i
    [Char] -> IO ()
putStr [Char]
"] (s = "
    [Char] -> IO ()
putStr ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ Int -> [Char]
forall a. Show a => a -> [Char]
show (Int -> [Char]) -> Int -> [Char]
forall a b. (a -> b) -> a -> b
$ Entry -> Int
entrySize Entry
e
    [Char] -> IO ()
putStr [Char]
") "
    ByteString -> IO ()
BS.putStr (ByteString -> IO ()) -> ByteString -> IO ()
forall a b. (a -> b) -> a -> b
$ CI ByteString -> ByteString
forall s. CI s -> s
original (CI ByteString -> ByteString) -> CI ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Entry -> CI ByteString
entryHeaderName Entry
e
    [Char] -> IO ()
putStr [Char]
": "
    ByteString -> IO ()
BS.putStrLn (ByteString -> IO ()) -> ByteString -> IO ()
forall a b. (a -> b) -> a -> b
$ Entry -> ByteString
entryFieldValue Entry
e

----------------------------------------------------------------

isDynamicTableEmpty :: DynamicTable -> IO Bool
isDynamicTableEmpty :: DynamicTable -> IO Bool
isDynamicTableEmpty DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    n <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
numOfEntries
    return $ n == 0

isSuitableSize :: Size -> DynamicTable -> IO Bool
isSuitableSize :: Int -> DynamicTable -> IO Bool
isSuitableSize Int
siz DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    let DecodeInfo HuffmanDecoder
_ IORef Int
limref = CodeInfo -> DecodeInfo
toDecodeInfo CodeInfo
codeInfo
    lim <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
limref
    return $ siz <= lim

data TableSizeAction = Keep | Change Size | Ignore Size

needChangeTableSize :: DynamicTable -> IO TableSizeAction
needChangeTableSize :: DynamicTable -> IO TableSizeAction
needChangeTableSize DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    let EncodeInfo RevIndex
_ IORef (Maybe Int)
limref = CodeInfo -> EncodeInfo
toEncodeInfo CodeInfo
codeInfo
    mlim <- IORef (Maybe Int) -> IO (Maybe Int)
forall a. IORef a -> IO a
readIORef IORef (Maybe Int)
limref
    maxsiz <- readIORef maxDynamicTableSize
    return $ case mlim of
        Maybe Int
Nothing -> TableSizeAction
Keep
        Just Int
lim
            | Int
lim Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
maxsiz -> Int -> TableSizeAction
Change Int
lim
            | Bool
otherwise -> Int -> TableSizeAction
Ignore Int
maxsiz

-- | Setting the limit on the decoded header list size for decoding, as
--   defined in RFC 9113 section 6.5.2: the sum over each field of the
--   length of its name, the length of its value, and 32.  A field block
--   over the limit makes decoding throw 'TooLargeHeader'.  'Nothing'
--   means no limit, which is the default. A limit of zero is a limit,
--   too: every field exceeds it.
setHeaderListSizeLimit :: Maybe Int -> DynamicTable -> IO ()
setHeaderListSizeLimit :: Maybe Int -> DynamicTable -> IO ()
setHeaderListSizeLimit Maybe Int
lim DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} =
    IORef (Maybe Int) -> Maybe Int -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Maybe Int)
headerListSizeLimit Maybe Int
lim

-- | Getting the limit on the decoded header list size. 'Nothing' means no
--   limit.
getHeaderListSizeLimit :: DynamicTable -> IO (Maybe Int)
getHeaderListSizeLimit :: DynamicTable -> IO (Maybe Int)
getHeaderListSizeLimit DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = IORef (Maybe Int) -> IO (Maybe Int)
forall a. IORef a -> IO a
readIORef IORef (Maybe Int)
headerListSizeLimit

-- | When SETTINGS_HEADER_TABLE_SIZE is received from a peer,
--   its value should be set by this function.
setLimitForEncoding :: Size -> DynamicTable -> IO ()
setLimitForEncoding :: Int -> DynamicTable -> IO ()
setLimitForEncoding Int
siz DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    let EncodeInfo RevIndex
_ IORef (Maybe Int)
limref = CodeInfo -> EncodeInfo
toEncodeInfo CodeInfo
codeInfo
    IORef (Maybe Int) -> Maybe Int -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Maybe Int)
limref (Maybe Int -> IO ()) -> Maybe Int -> IO ()
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int
forall a. a -> Maybe a
Just Int
siz

resetLimitForEncoding :: DynamicTable -> IO ()
resetLimitForEncoding :: DynamicTable -> IO ()
resetLimitForEncoding DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    let EncodeInfo RevIndex
_ IORef (Maybe Int)
limref = CodeInfo -> EncodeInfo
toEncodeInfo CodeInfo
codeInfo
    IORef (Maybe Int) -> Maybe Int -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Maybe Int)
limref Maybe Int
forall a. Maybe a
Nothing

----------------------------------------------------------------

-- | Creating 'DynamicTable' for encoding.
newDynamicTableForEncoding
    :: Size
    -- ^ The dynamic table size
    -> IO DynamicTable
newDynamicTableForEncoding :: Int -> IO DynamicTable
newDynamicTableForEncoding Int
maxsiz = do
    rev <- IO RevIndex
newRevIndex
    lim <- newIORef Nothing
    let info = EncodeInfo -> CodeInfo
CIE (EncodeInfo -> CodeInfo) -> EncodeInfo -> CodeInfo
forall a b. (a -> b) -> a -> b
$ RevIndex -> IORef (Maybe Int) -> EncodeInfo
EncodeInfo RevIndex
rev IORef (Maybe Int)
lim
    newDynamicTable maxsiz info

-- | Creating 'DynamicTable' for decoding.
newDynamicTableForDecoding
    :: Size
    -- ^ The dynamic table size
    -> Size
    -- ^ The size of temporary buffer for Huffman decoding.
    --   A longer value is decoded in a buffer of its own.
    -> IO DynamicTable
newDynamicTableForDecoding :: Int -> Int -> IO DynamicTable
newDynamicTableForDecoding Int
maxsiz Int
huftmpsiz = do
    lim <- Int -> IO (IORef Int)
forall a. a -> IO (IORef a)
newIORef Int
maxsiz
    buf <- mallocPlainForeignPtrBytes huftmpsiz
    let decoder = ForeignPtr Word8 -> Int -> HuffmanDecoder
decodeH ForeignPtr Word8
buf Int
huftmpsiz
        info = DecodeInfo -> CodeInfo
CID (DecodeInfo -> CodeInfo) -> DecodeInfo -> CodeInfo
forall a b. (a -> b) -> a -> b
$ HuffmanDecoder -> IORef Int -> DecodeInfo
DecodeInfo HuffmanDecoder
decoder IORef Int
lim
    newDynamicTable maxsiz info

newDynamicTable :: Size -> CodeInfo -> IO DynamicTable
newDynamicTable :: Int -> CodeInfo -> IO DynamicTable
newDynamicTable Int
maxsiz CodeInfo
info = do
    tbl <- (Int, Int) -> Entry -> IO Table
forall i. Ix i => (i, i) -> Entry -> IO (IOArray i Entry)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (Int
0, Int
end) Entry
dummyEntry
    DynamicTable info
        <$> newIORef tbl -- circularTable
        <*> newIORef end -- offset
        <*> newIORef 0 -- numOfEntries
        <*> newIORef maxN -- maxNumOfEntries
        <*> newIORef 0 -- dynamicTableSize
        <*> newIORef maxsiz -- maxDynamicTableSize
        <*> newIORef Nothing -- headerListSizeLimit (no limit)
  where
    maxN :: Int
maxN = Int -> Int
maxNumbers Int
maxsiz
    end :: Int
end = Int
maxN Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1

-- | Renewing 'DynamicTable' with necessary entries copied.
renewDynamicTable :: Size -> DynamicTable -> IO ()
renewDynamicTable :: Int -> DynamicTable -> IO ()
renewDynamicTable Int
maxsiz dyntbl :: DynamicTable
dyntbl@DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    renew <- DynamicTable -> Int -> IO Bool
shouldRenew DynamicTable
dyntbl Int
maxsiz
    when renew $ do
        entries <- getEntries dyntbl
        let maxN = Int -> Int
maxNumbers Int
maxsiz
            end = Int
maxN Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
        newtbl <- newArray (0, end) dummyEntry
        writeIORef circularTable newtbl
        writeIORef offset end
        writeIORef numOfEntries 0
        writeIORef maxNumOfEntries maxN
        writeIORef dynamicTableSize 0
        writeIORef maxDynamicTableSize maxsiz
        case codeInfo of
            CIE (EncodeInfo RevIndex
rev IORef (Maybe Int)
_) -> RevIndex -> IO ()
renewRevIndex RevIndex
rev
            CodeInfo
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        copyEntries dyntbl entries

getEntries :: DynamicTable -> IO [Entry]
getEntries :: DynamicTable -> IO [Entry]
getEntries DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    table <- readIORef circularTable
    let readTable Int
i = Int -> Int -> IO Int
adj Int
maxN (Int
off Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) IO Int -> (Int -> IO Entry) -> IO Entry
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Table -> Int -> IO Entry
forall i. Ix i => IOArray i Entry -> Int -> IO Entry
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead Table
table
    forM [1 .. n] readTable

copyEntries :: DynamicTable -> [Entry] -> IO ()
copyEntries :: DynamicTable -> [Entry] -> IO ()
copyEntries DynamicTable
_ [] = () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
copyEntries dyntbl :: DynamicTable
dyntbl@DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} (Entry
e : [Entry]
es) = do
    dsize <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
dynamicTableSize
    maxdsize <- readIORef maxDynamicTableSize
    when (dsize + entrySize e <= maxdsize) $ do
        insertEnd e dyntbl
        copyEntries dyntbl es

-- | Is the size of 'DynamicTable' really changed?
shouldRenew :: DynamicTable -> Size -> IO Bool
shouldRenew :: DynamicTable -> Int -> IO Bool
shouldRenew DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} Int
maxsiz = do
    maxdsize <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxDynamicTableSize
    return $ maxdsize /= maxsiz

----------------------------------------------------------------

-- | Creating 'DynamicTable' for encoding,
--   performing the action and
--   clearing the 'DynamicTable'.
withDynamicTableForEncoding
    :: Size
    -- ^ The dynamic table size
    -> (DynamicTable -> IO a)
    -> IO a
withDynamicTableForEncoding :: forall a. Int -> (DynamicTable -> IO a) -> IO a
withDynamicTableForEncoding Int
maxsiz DynamicTable -> IO a
action =
    Int -> IO DynamicTable
newDynamicTableForEncoding Int
maxsiz IO DynamicTable -> (DynamicTable -> IO a) -> IO a
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= DynamicTable -> IO a
action

-- | Creating 'DynamicTable' for decoding,
--   performing the action and
--   clearing the 'DynamicTable'.
withDynamicTableForDecoding
    :: Size
    -- ^ The dynamic table size
    -> Size
    -- ^ The size of temporary buffer for Huffman decoding.
    --   A longer value is decoded in a buffer of its own.
    -> (DynamicTable -> IO a)
    -> IO a
withDynamicTableForDecoding :: forall a. Int -> Int -> (DynamicTable -> IO a) -> IO a
withDynamicTableForDecoding Int
maxsiz Int
huftmpsiz DynamicTable -> IO a
action =
    Int -> Int -> IO DynamicTable
newDynamicTableForDecoding Int
maxsiz Int
huftmpsiz IO DynamicTable -> (DynamicTable -> IO a) -> IO a
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= DynamicTable -> IO a
action

----------------------------------------------------------------

-- | Inserting 'Entry' to 'DynamicTable'.
--
-- Entries are evicted first and the new one added after, as RFC 7541
-- section 4.4 has it: "Before a new entry is added to the dynamic table,
-- entries are evicted from the end of the dynamic table until the size of
-- the dynamic table is less than or equal to (maximum size - new entry
-- size) or until the table is empty."  An entry larger than the table
-- empties it and is not added.
--
-- The order matters to the ring.  It has room for maxNumbers entries, and
-- the table holds that many whenever they are all close to the 32-octet
-- minimum -- at a size of 40 or 100, say.  Added first, the new entry
-- landed on the oldest one's slot, and the eviction that followed read that
-- slot back and took out the new entry instead, leaving a dummy.  After
-- evicting there is always a free slot: every entry is 32 octets or more,
-- so the entries left and the new one come to at most maxNumbers.
insertEntry :: Entry -> DynamicTable -> IO ()
insertEntry :: Entry -> DynamicTable -> IO ()
insertEntry Entry
e dyntbl :: DynamicTable
dyntbl@DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    es <- Int -> DynamicTable -> IO [Entry]
evictFor (Entry -> Int
entrySize Entry
e) DynamicTable
dyntbl
    -- Before the new entry goes in: the reverse index is keyed by name and
    -- value, so an evicted entry equal to the new one would take its
    -- mapping out with it.
    case codeInfo of
        CIE (EncodeInfo RevIndex
rev IORef (Maybe Int)
_) -> [Entry] -> RevIndex -> IO ()
deleteRevIndexList [Entry]
es RevIndex
rev
        CodeInfo
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    maxdsize <- readIORef maxDynamicTableSize
    when (entrySize e <= maxdsize) $ insertFront e dyntbl

-- | Evicting entries until one of the given size fits, or the table is
-- empty.
evictFor :: Size -> DynamicTable -> IO [Entry]
evictFor :: Int -> DynamicTable -> IO [Entry]
evictFor Int
siz dyntbl :: DynamicTable
dyntbl@DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = [Entry] -> IO [Entry]
evict []
  where
    evict :: [Entry] -> IO [Entry]
    evict :: [Entry] -> IO [Entry]
evict [Entry]
es = do
        n <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
numOfEntries
        dsize <- readIORef dynamicTableSize
        maxdsize <- readIORef maxDynamicTableSize
        if n == 0 || dsize + siz <= maxdsize
            then return es
            else do
                e <- removeEnd dyntbl
                evict (e : es)

insertFront :: Entry -> DynamicTable -> IO ()
insertFront :: Entry -> DynamicTable -> IO ()
insertFront Entry
e DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    dsize <- readIORef dynamicTableSize
    table <- readIORef circularTable
    let i = Int
off
        dsize' = Int
dsize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Entry -> Int
entrySize Entry
e
    if maxN == 0
        then return ()
        else do
            off' <- adj maxN (off - 1)
            unsafeWrite table i e
            writeIORef offset off'
            writeIORef numOfEntries $ n + 1
            writeIORef dynamicTableSize dsize'
            case codeInfo of
                CIE (EncodeInfo RevIndex
rev IORef (Maybe Int)
_) -> Entry -> HIndex -> RevIndex -> IO ()
insertRevIndex Entry
e (Int -> HIndex
DIndex Int
i) RevIndex
rev
                CodeInfo
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

----------------------------------------------------------------

-- Used in copyEntries.
insertEnd :: Entry -> DynamicTable -> IO ()
insertEnd :: Entry -> DynamicTable -> IO ()
insertEnd Entry
e DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    dsize <- readIORef dynamicTableSize
    table <- readIORef circularTable
    i <- adj maxN (off + n + 1)
    let dsize' = Int
dsize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Entry -> Int
entrySize Entry
e
    unsafeWrite table i e
    writeIORef numOfEntries $ n + 1
    writeIORef dynamicTableSize dsize'
    case codeInfo of
        CIE (EncodeInfo RevIndex
rev IORef (Maybe Int)
_) -> Entry -> HIndex -> RevIndex -> IO ()
insertRevIndex Entry
e (Int -> HIndex
DIndex Int
i) RevIndex
rev
        CodeInfo
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

----------------------------------------------------------------

removeEnd :: DynamicTable -> IO Entry
removeEnd :: DynamicTable -> IO Entry
removeEnd DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    i <- adj maxN (off + n)
    table <- readIORef circularTable
    e <- unsafeRead table i
    unsafeWrite table i dummyEntry -- let the entry GCed
    dsize <- readIORef dynamicTableSize
    let dsize' = Int
dsize Int -> Int -> Int
forall a. Num a => a -> a -> a
- Entry -> Int
entrySize Entry
e
    writeIORef numOfEntries (n - 1)
    writeIORef dynamicTableSize dsize'
    return e

----------------------------------------------------------------

{-# INLINE toDynamicEntry #-}
toDynamicEntry :: DynamicTable -> Index -> IO Entry
toDynamicEntry :: DynamicTable -> Int -> IO Entry
toDynamicEntry DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} Int
idx = do
    maxN <- IORef Int -> IO Int
forall a. IORef a -> IO a
readIORef IORef Int
maxNumOfEntries
    off <- readIORef offset
    n <- readIORef numOfEntries
    when (idx > n + staticTableSize) $ E.throwIO $ IndexOverrun idx
    didx <- adj maxN (idx + off - staticTableSize)
    table <- readIORef circularTable
    unsafeRead table didx

----------------------------------------------------------------

{-# INLINE getRevIndex #-}
getRevIndex :: DynamicTable -> RevIndex
getRevIndex :: DynamicTable -> RevIndex
getRevIndex DynamicTable{IORef Int
IORef (Maybe Int)
IORef Table
CodeInfo
circularTable :: DynamicTable -> IORef Table
codeInfo :: DynamicTable -> CodeInfo
dynamicTableSize :: DynamicTable -> IORef Int
headerListSizeLimit :: DynamicTable -> IORef (Maybe Int)
maxDynamicTableSize :: DynamicTable -> IORef Int
maxNumOfEntries :: DynamicTable -> IORef Int
numOfEntries :: DynamicTable -> IORef Int
offset :: DynamicTable -> IORef Int
codeInfo :: CodeInfo
circularTable :: IORef Table
offset :: IORef Int
numOfEntries :: IORef Int
maxNumOfEntries :: IORef Int
dynamicTableSize :: IORef Int
maxDynamicTableSize :: IORef Int
headerListSizeLimit :: IORef (Maybe Int)
..} = RevIndex
rev
  where
    EncodeInfo RevIndex
rev IORef (Maybe Int)
_ = CodeInfo -> EncodeInfo
toEncodeInfo CodeInfo
codeInfo