{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}

module Network.QUIC.Types.Packet where

import Data.Ix

import Network.QUIC.Imports
import Network.QUIC.Types.Ack
import Network.QUIC.Types.CID
import Network.QUIC.Types.Frame
import Network.QUIC.Types.Time

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

-- | QUIC version.
newtype Version = Version Word32 deriving (Version -> Version -> Bool
(Version -> Version -> Bool)
-> (Version -> Version -> Bool) -> Eq Version
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Version -> Version -> Bool
$c/= :: Version -> Version -> Bool
== :: Version -> Version -> Bool
$c== :: Version -> Version -> Bool
Eq, Eq Version
Eq Version
-> (Version -> Version -> Ordering)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Version)
-> (Version -> Version -> Version)
-> Ord Version
Version -> Version -> Bool
Version -> Version -> Ordering
Version -> Version -> Version
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Version -> Version -> Version
$cmin :: Version -> Version -> Version
max :: Version -> Version -> Version
$cmax :: Version -> Version -> Version
>= :: Version -> Version -> Bool
$c>= :: Version -> Version -> Bool
> :: Version -> Version -> Bool
$c> :: Version -> Version -> Bool
<= :: Version -> Version -> Bool
$c<= :: Version -> Version -> Bool
< :: Version -> Version -> Bool
$c< :: Version -> Version -> Bool
compare :: Version -> Version -> Ordering
$ccompare :: Version -> Version -> Ordering
$cp1Ord :: Eq Version
Ord, Int -> Version -> ShowS
[Version] -> ShowS
Version -> String
(Int -> Version -> ShowS)
-> (Version -> String) -> ([Version] -> ShowS) -> Show Version
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Version] -> ShowS
$cshowList :: [Version] -> ShowS
show :: Version -> String
$cshow :: Version -> String
showsPrec :: Int -> Version -> ShowS
$cshowsPrec :: Int -> Version -> ShowS
Show)

pattern Negotiation      :: Version
pattern $bNegotiation :: Version
$mNegotiation :: forall r. Version -> (Void# -> r) -> (Void# -> r) -> r
Negotiation       = Version 0
pattern Version1         :: Version
pattern $bVersion1 :: Version
$mVersion1 :: forall r. Version -> (Void# -> r) -> (Void# -> r) -> r
Version1          = Version 1
pattern Draft29          :: Version
pattern $bDraft29 :: Version
$mDraft29 :: forall r. Version -> (Void# -> r) -> (Void# -> r) -> r
Draft29           = Version 0xff00001d
pattern GreasingVersion  :: Version
pattern $bGreasingVersion :: Version
$mGreasingVersion :: forall r. Version -> (Void# -> r) -> (Void# -> r) -> r
GreasingVersion   = Version 0x0a0a0a0a
pattern GreasingVersion2 :: Version
pattern $bGreasingVersion2 :: Version
$mGreasingVersion2 :: forall r. Version -> (Void# -> r) -> (Void# -> r) -> r
GreasingVersion2  = Version 0x1a2a3a4a

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

data PacketI = PacketIV VersionNegotiationPacket
             | PacketIR RetryPacket
             | PacketIC CryptPacket EncryptionLevel
             | PacketIB BrokenPacket
             deriving (PacketI -> PacketI -> Bool
(PacketI -> PacketI -> Bool)
-> (PacketI -> PacketI -> Bool) -> Eq PacketI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketI -> PacketI -> Bool
$c/= :: PacketI -> PacketI -> Bool
== :: PacketI -> PacketI -> Bool
$c== :: PacketI -> PacketI -> Bool
Eq, Int -> PacketI -> ShowS
[PacketI] -> ShowS
PacketI -> String
(Int -> PacketI -> ShowS)
-> (PacketI -> String) -> ([PacketI] -> ShowS) -> Show PacketI
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketI] -> ShowS
$cshowList :: [PacketI] -> ShowS
show :: PacketI -> String
$cshow :: PacketI -> String
showsPrec :: Int -> PacketI -> ShowS
$cshowsPrec :: Int -> PacketI -> ShowS
Show)

-- Not used internally. Only for 'encodePacket'.
data PacketO = PacketOV VersionNegotiationPacket
             | PacketOR RetryPacket
             | PacketOP PlainPacket
             deriving (PacketO -> PacketO -> Bool
(PacketO -> PacketO -> Bool)
-> (PacketO -> PacketO -> Bool) -> Eq PacketO
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketO -> PacketO -> Bool
$c/= :: PacketO -> PacketO -> Bool
== :: PacketO -> PacketO -> Bool
$c== :: PacketO -> PacketO -> Bool
Eq, Int -> PacketO -> ShowS
[PacketO] -> ShowS
PacketO -> String
(Int -> PacketO -> ShowS)
-> (PacketO -> String) -> ([PacketO] -> ShowS) -> Show PacketO
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketO] -> ShowS
$cshowList :: [PacketO] -> ShowS
show :: PacketO -> String
$cshow :: PacketO -> String
showsPrec :: Int -> PacketO -> ShowS
$cshowsPrec :: Int -> PacketO -> ShowS
Show)

data VersionNegotiationPacket = VersionNegotiationPacket CID CID [Version]
                              deriving (VersionNegotiationPacket -> VersionNegotiationPacket -> Bool
(VersionNegotiationPacket -> VersionNegotiationPacket -> Bool)
-> (VersionNegotiationPacket -> VersionNegotiationPacket -> Bool)
-> Eq VersionNegotiationPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionNegotiationPacket -> VersionNegotiationPacket -> Bool
$c/= :: VersionNegotiationPacket -> VersionNegotiationPacket -> Bool
== :: VersionNegotiationPacket -> VersionNegotiationPacket -> Bool
$c== :: VersionNegotiationPacket -> VersionNegotiationPacket -> Bool
Eq, Int -> VersionNegotiationPacket -> ShowS
[VersionNegotiationPacket] -> ShowS
VersionNegotiationPacket -> String
(Int -> VersionNegotiationPacket -> ShowS)
-> (VersionNegotiationPacket -> String)
-> ([VersionNegotiationPacket] -> ShowS)
-> Show VersionNegotiationPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VersionNegotiationPacket] -> ShowS
$cshowList :: [VersionNegotiationPacket] -> ShowS
show :: VersionNegotiationPacket -> String
$cshow :: VersionNegotiationPacket -> String
showsPrec :: Int -> VersionNegotiationPacket -> ShowS
$cshowsPrec :: Int -> VersionNegotiationPacket -> ShowS
Show)

data RetryPacket = RetryPacket Version CID CID Token (Either CID (ByteString,ByteString))
                 deriving (RetryPacket -> RetryPacket -> Bool
(RetryPacket -> RetryPacket -> Bool)
-> (RetryPacket -> RetryPacket -> Bool) -> Eq RetryPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RetryPacket -> RetryPacket -> Bool
$c/= :: RetryPacket -> RetryPacket -> Bool
== :: RetryPacket -> RetryPacket -> Bool
$c== :: RetryPacket -> RetryPacket -> Bool
Eq, Int -> RetryPacket -> ShowS
[RetryPacket] -> ShowS
RetryPacket -> String
(Int -> RetryPacket -> ShowS)
-> (RetryPacket -> String)
-> ([RetryPacket] -> ShowS)
-> Show RetryPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RetryPacket] -> ShowS
$cshowList :: [RetryPacket] -> ShowS
show :: RetryPacket -> String
$cshow :: RetryPacket -> String
showsPrec :: Int -> RetryPacket -> ShowS
$cshowsPrec :: Int -> RetryPacket -> ShowS
Show)

data BrokenPacket = BrokenPacket deriving (BrokenPacket -> BrokenPacket -> Bool
(BrokenPacket -> BrokenPacket -> Bool)
-> (BrokenPacket -> BrokenPacket -> Bool) -> Eq BrokenPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BrokenPacket -> BrokenPacket -> Bool
$c/= :: BrokenPacket -> BrokenPacket -> Bool
== :: BrokenPacket -> BrokenPacket -> Bool
$c== :: BrokenPacket -> BrokenPacket -> Bool
Eq, Int -> BrokenPacket -> ShowS
[BrokenPacket] -> ShowS
BrokenPacket -> String
(Int -> BrokenPacket -> ShowS)
-> (BrokenPacket -> String)
-> ([BrokenPacket] -> ShowS)
-> Show BrokenPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BrokenPacket] -> ShowS
$cshowList :: [BrokenPacket] -> ShowS
show :: BrokenPacket -> String
$cshow :: BrokenPacket -> String
showsPrec :: Int -> BrokenPacket -> ShowS
$cshowsPrec :: Int -> BrokenPacket -> ShowS
Show)

data Header = Initial   Version  CID CID Token
            | RTT0      Version  CID CID
            | Handshake Version  CID CID
            | Short              CID
            deriving (Header -> Header -> Bool
(Header -> Header -> Bool)
-> (Header -> Header -> Bool) -> Eq Header
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Header -> Header -> Bool
$c/= :: Header -> Header -> Bool
== :: Header -> Header -> Bool
$c== :: Header -> Header -> Bool
Eq, Int -> Header -> ShowS
[Header] -> ShowS
Header -> String
(Int -> Header -> ShowS)
-> (Header -> String) -> ([Header] -> ShowS) -> Show Header
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Header] -> ShowS
$cshowList :: [Header] -> ShowS
show :: Header -> String
$cshow :: Header -> String
showsPrec :: Int -> Header -> ShowS
$cshowsPrec :: Int -> Header -> ShowS
Show)

headerMyCID :: Header -> CID
headerMyCID :: Header -> CID
headerMyCID (Initial   Version
_ CID
cid CID
_ Token
_) = CID
cid
headerMyCID (RTT0      Version
_ CID
cid CID
_)   = CID
cid
headerMyCID (Handshake Version
_ CID
cid CID
_)   = CID
cid
headerMyCID (Short       CID
cid)     = CID
cid

headerPeerCID :: Header -> CID
headerPeerCID :: Header -> CID
headerPeerCID (Initial   Version
_ CID
_ CID
cid Token
_) = CID
cid
headerPeerCID (RTT0      Version
_ CID
_ CID
cid)   = CID
cid
headerPeerCID (Handshake Version
_ CID
_ CID
cid)   = CID
cid
headerPeerCID  Short{}              = Bytes -> CID
CID Bytes
""

data PlainPacket = PlainPacket Header Plain deriving (PlainPacket -> PlainPacket -> Bool
(PlainPacket -> PlainPacket -> Bool)
-> (PlainPacket -> PlainPacket -> Bool) -> Eq PlainPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PlainPacket -> PlainPacket -> Bool
$c/= :: PlainPacket -> PlainPacket -> Bool
== :: PlainPacket -> PlainPacket -> Bool
$c== :: PlainPacket -> PlainPacket -> Bool
Eq, Int -> PlainPacket -> ShowS
[PlainPacket] -> ShowS
PlainPacket -> String
(Int -> PlainPacket -> ShowS)
-> (PlainPacket -> String)
-> ([PlainPacket] -> ShowS)
-> Show PlainPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PlainPacket] -> ShowS
$cshowList :: [PlainPacket] -> ShowS
show :: PlainPacket -> String
$cshow :: PlainPacket -> String
showsPrec :: Int -> PlainPacket -> ShowS
$cshowsPrec :: Int -> PlainPacket -> ShowS
Show)
data CryptPacket = CryptPacket Header Crypt deriving (CryptPacket -> CryptPacket -> Bool
(CryptPacket -> CryptPacket -> Bool)
-> (CryptPacket -> CryptPacket -> Bool) -> Eq CryptPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CryptPacket -> CryptPacket -> Bool
$c/= :: CryptPacket -> CryptPacket -> Bool
== :: CryptPacket -> CryptPacket -> Bool
$c== :: CryptPacket -> CryptPacket -> Bool
Eq, Int -> CryptPacket -> ShowS
[CryptPacket] -> ShowS
CryptPacket -> String
(Int -> CryptPacket -> ShowS)
-> (CryptPacket -> String)
-> ([CryptPacket] -> ShowS)
-> Show CryptPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CryptPacket] -> ShowS
$cshowList :: [CryptPacket] -> ShowS
show :: CryptPacket -> String
$cshow :: CryptPacket -> String
showsPrec :: Int -> CryptPacket -> ShowS
$cshowsPrec :: Int -> CryptPacket -> ShowS
Show)

data Plain = Plain {
    Plain -> Flags Raw
plainFlags        :: Flags Raw
  , Plain -> Int
plainPacketNumber :: PacketNumber
  , Plain -> [Frame]
plainFrames       :: [Frame]
  , Plain -> Int
plainMarks        :: Int
  } deriving (Plain -> Plain -> Bool
(Plain -> Plain -> Bool) -> (Plain -> Plain -> Bool) -> Eq Plain
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Plain -> Plain -> Bool
$c/= :: Plain -> Plain -> Bool
== :: Plain -> Plain -> Bool
$c== :: Plain -> Plain -> Bool
Eq, Int -> Plain -> ShowS
[Plain] -> ShowS
Plain -> String
(Int -> Plain -> ShowS)
-> (Plain -> String) -> ([Plain] -> ShowS) -> Show Plain
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Plain] -> ShowS
$cshowList :: [Plain] -> ShowS
show :: Plain -> String
$cshow :: Plain -> String
showsPrec :: Int -> Plain -> ShowS
$cshowsPrec :: Int -> Plain -> ShowS
Show)

defaultPlainMarks :: Int
defaultPlainMarks :: Int
defaultPlainMarks = Int
0

setIllegalReservedBits :: Int -> Int
setIllegalReservedBits :: Int -> Int
setIllegalReservedBits = (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
0)

setUnknownFrame :: Int -> Int
setUnknownFrame :: Int -> Int
setUnknownFrame = (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
1)

setNoFrames :: Int -> Int
setNoFrames :: Int -> Int
setNoFrames = (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
2)

setNoPaddings :: Int -> Int
setNoPaddings :: Int -> Int
setNoPaddings = (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
8)

set4bytesPN :: Int -> Int
set4bytesPN :: Int -> Int
set4bytesPN = (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
9)

isIllegalReservedBits :: Int -> Bool
isIllegalReservedBits :: Int -> Bool
isIllegalReservedBits = (Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
0)

isUnknownFrame :: Int -> Bool
isUnknownFrame :: Int -> Bool
isUnknownFrame = (Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
1)

isNoFrames :: Int -> Bool
isNoFrames :: Int -> Bool
isNoFrames = (Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
2)

isNoPaddings :: Int -> Bool
isNoPaddings :: Int -> Bool
isNoPaddings = (Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
8)

is4bytesPN :: Int -> Bool
is4bytesPN :: Int -> Bool
is4bytesPN = (Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
9)

data Crypt = Crypt {
    Crypt -> Int
cryptPktNumOffset :: Int
  , Crypt -> Token
cryptPacket       :: ByteString
  , Crypt -> Int
cryptMarks        :: Int
  } deriving (Crypt -> Crypt -> Bool
(Crypt -> Crypt -> Bool) -> (Crypt -> Crypt -> Bool) -> Eq Crypt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Crypt -> Crypt -> Bool
$c/= :: Crypt -> Crypt -> Bool
== :: Crypt -> Crypt -> Bool
$c== :: Crypt -> Crypt -> Bool
Eq, Int -> Crypt -> ShowS
[Crypt] -> ShowS
Crypt -> String
(Int -> Crypt -> ShowS)
-> (Crypt -> String) -> ([Crypt] -> ShowS) -> Show Crypt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Crypt] -> ShowS
$cshowList :: [Crypt] -> ShowS
show :: Crypt -> String
$cshow :: Crypt -> String
showsPrec :: Int -> Crypt -> ShowS
$cshowsPrec :: Int -> Crypt -> ShowS
Show)

isCryptLogged :: Crypt -> Bool
isCryptLogged :: Crypt -> Bool
isCryptLogged  Crypt
crypt = Crypt -> Int
cryptMarks Crypt
crypt Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
0

isCryptDelayed :: Crypt -> Bool
isCryptDelayed :: Crypt -> Bool
isCryptDelayed Crypt
crypt = Crypt -> Int
cryptMarks Crypt
crypt Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
1

setCryptLogged :: Crypt -> Crypt
setCryptLogged :: Crypt -> Crypt
setCryptLogged  Crypt
crypt = Crypt
crypt { cryptMarks :: Int
cryptMarks = Crypt -> Int
cryptMarks Crypt
crypt Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
0 }

setCryptDelayed :: Crypt -> Crypt
setCryptDelayed :: Crypt -> Crypt
setCryptDelayed Crypt
crypt = Crypt
crypt { cryptMarks :: Int
cryptMarks = Crypt -> Int
cryptMarks Crypt
crypt Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`setBit` Int
1 }

data StatelessReset = StatelessReset deriving (StatelessReset -> StatelessReset -> Bool
(StatelessReset -> StatelessReset -> Bool)
-> (StatelessReset -> StatelessReset -> Bool) -> Eq StatelessReset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatelessReset -> StatelessReset -> Bool
$c/= :: StatelessReset -> StatelessReset -> Bool
== :: StatelessReset -> StatelessReset -> Bool
$c== :: StatelessReset -> StatelessReset -> Bool
Eq, Int -> StatelessReset -> ShowS
[StatelessReset] -> ShowS
StatelessReset -> String
(Int -> StatelessReset -> ShowS)
-> (StatelessReset -> String)
-> ([StatelessReset] -> ShowS)
-> Show StatelessReset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StatelessReset] -> ShowS
$cshowList :: [StatelessReset] -> ShowS
show :: StatelessReset -> String
$cshow :: StatelessReset -> String
showsPrec :: Int -> StatelessReset -> ShowS
$cshowsPrec :: Int -> StatelessReset -> ShowS
Show)

data ReceivedPacket = ReceivedPacket {
    ReceivedPacket -> CryptPacket
rpCryptPacket     :: CryptPacket
  , ReceivedPacket -> TimeMicrosecond
rpTimeRecevied    :: TimeMicrosecond
  , ReceivedPacket -> Int
rpReceivedBytes   :: Int
  , ReceivedPacket -> EncryptionLevel
rpEncryptionLevel :: EncryptionLevel
  } deriving (ReceivedPacket -> ReceivedPacket -> Bool
(ReceivedPacket -> ReceivedPacket -> Bool)
-> (ReceivedPacket -> ReceivedPacket -> Bool) -> Eq ReceivedPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReceivedPacket -> ReceivedPacket -> Bool
$c/= :: ReceivedPacket -> ReceivedPacket -> Bool
== :: ReceivedPacket -> ReceivedPacket -> Bool
$c== :: ReceivedPacket -> ReceivedPacket -> Bool
Eq, Int -> ReceivedPacket -> ShowS
[ReceivedPacket] -> ShowS
ReceivedPacket -> String
(Int -> ReceivedPacket -> ShowS)
-> (ReceivedPacket -> String)
-> ([ReceivedPacket] -> ShowS)
-> Show ReceivedPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReceivedPacket] -> ShowS
$cshowList :: [ReceivedPacket] -> ShowS
show :: ReceivedPacket -> String
$cshow :: ReceivedPacket -> String
showsPrec :: Int -> ReceivedPacket -> ShowS
$cshowsPrec :: Int -> ReceivedPacket -> ShowS
Show)

mkReceivedPacket :: CryptPacket -> TimeMicrosecond -> Int -> EncryptionLevel -> ReceivedPacket
mkReceivedPacket :: CryptPacket
-> TimeMicrosecond -> Int -> EncryptionLevel -> ReceivedPacket
mkReceivedPacket CryptPacket
cpkt TimeMicrosecond
tim Int
bytes EncryptionLevel
lvl = ReceivedPacket :: CryptPacket
-> TimeMicrosecond -> Int -> EncryptionLevel -> ReceivedPacket
ReceivedPacket {
    rpCryptPacket :: CryptPacket
rpCryptPacket     = CryptPacket
cpkt
  , rpTimeRecevied :: TimeMicrosecond
rpTimeRecevied    = TimeMicrosecond
tim
  , rpReceivedBytes :: Int
rpReceivedBytes   = Int
bytes
  , rpEncryptionLevel :: EncryptionLevel
rpEncryptionLevel = EncryptionLevel
lvl
  }

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

data LongHeaderPacketType = InitialPacketType
                          | RTT0PacketType
                          | HandshakePacketType
                          | RetryPacketType
                          deriving (LongHeaderPacketType -> LongHeaderPacketType -> Bool
(LongHeaderPacketType -> LongHeaderPacketType -> Bool)
-> (LongHeaderPacketType -> LongHeaderPacketType -> Bool)
-> Eq LongHeaderPacketType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LongHeaderPacketType -> LongHeaderPacketType -> Bool
$c/= :: LongHeaderPacketType -> LongHeaderPacketType -> Bool
== :: LongHeaderPacketType -> LongHeaderPacketType -> Bool
$c== :: LongHeaderPacketType -> LongHeaderPacketType -> Bool
Eq, Int -> LongHeaderPacketType -> ShowS
[LongHeaderPacketType] -> ShowS
LongHeaderPacketType -> String
(Int -> LongHeaderPacketType -> ShowS)
-> (LongHeaderPacketType -> String)
-> ([LongHeaderPacketType] -> ShowS)
-> Show LongHeaderPacketType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LongHeaderPacketType] -> ShowS
$cshowList :: [LongHeaderPacketType] -> ShowS
show :: LongHeaderPacketType -> String
$cshow :: LongHeaderPacketType -> String
showsPrec :: Int -> LongHeaderPacketType -> ShowS
$cshowsPrec :: Int -> LongHeaderPacketType -> ShowS
Show)

data EncryptionLevel = InitialLevel
                     | RTT0Level
                     | HandshakeLevel
                     | RTT1Level
                     deriving (EncryptionLevel -> EncryptionLevel -> Bool
(EncryptionLevel -> EncryptionLevel -> Bool)
-> (EncryptionLevel -> EncryptionLevel -> Bool)
-> Eq EncryptionLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EncryptionLevel -> EncryptionLevel -> Bool
$c/= :: EncryptionLevel -> EncryptionLevel -> Bool
== :: EncryptionLevel -> EncryptionLevel -> Bool
$c== :: EncryptionLevel -> EncryptionLevel -> Bool
Eq, Eq EncryptionLevel
Eq EncryptionLevel
-> (EncryptionLevel -> EncryptionLevel -> Ordering)
-> (EncryptionLevel -> EncryptionLevel -> Bool)
-> (EncryptionLevel -> EncryptionLevel -> Bool)
-> (EncryptionLevel -> EncryptionLevel -> Bool)
-> (EncryptionLevel -> EncryptionLevel -> Bool)
-> (EncryptionLevel -> EncryptionLevel -> EncryptionLevel)
-> (EncryptionLevel -> EncryptionLevel -> EncryptionLevel)
-> Ord EncryptionLevel
EncryptionLevel -> EncryptionLevel -> Bool
EncryptionLevel -> EncryptionLevel -> Ordering
EncryptionLevel -> EncryptionLevel -> EncryptionLevel
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EncryptionLevel -> EncryptionLevel -> EncryptionLevel
$cmin :: EncryptionLevel -> EncryptionLevel -> EncryptionLevel
max :: EncryptionLevel -> EncryptionLevel -> EncryptionLevel
$cmax :: EncryptionLevel -> EncryptionLevel -> EncryptionLevel
>= :: EncryptionLevel -> EncryptionLevel -> Bool
$c>= :: EncryptionLevel -> EncryptionLevel -> Bool
> :: EncryptionLevel -> EncryptionLevel -> Bool
$c> :: EncryptionLevel -> EncryptionLevel -> Bool
<= :: EncryptionLevel -> EncryptionLevel -> Bool
$c<= :: EncryptionLevel -> EncryptionLevel -> Bool
< :: EncryptionLevel -> EncryptionLevel -> Bool
$c< :: EncryptionLevel -> EncryptionLevel -> Bool
compare :: EncryptionLevel -> EncryptionLevel -> Ordering
$ccompare :: EncryptionLevel -> EncryptionLevel -> Ordering
$cp1Ord :: Eq EncryptionLevel
Ord, Ord EncryptionLevel
Ord EncryptionLevel
-> ((EncryptionLevel, EncryptionLevel) -> [EncryptionLevel])
-> ((EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int)
-> ((EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int)
-> ((EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Bool)
-> ((EncryptionLevel, EncryptionLevel) -> Int)
-> ((EncryptionLevel, EncryptionLevel) -> Int)
-> Ix EncryptionLevel
(EncryptionLevel, EncryptionLevel) -> Int
(EncryptionLevel, EncryptionLevel) -> [EncryptionLevel]
(EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Bool
(EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (EncryptionLevel, EncryptionLevel) -> Int
$cunsafeRangeSize :: (EncryptionLevel, EncryptionLevel) -> Int
rangeSize :: (EncryptionLevel, EncryptionLevel) -> Int
$crangeSize :: (EncryptionLevel, EncryptionLevel) -> Int
inRange :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Bool
$cinRange :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Bool
unsafeIndex :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int
$cunsafeIndex :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int
index :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int
$cindex :: (EncryptionLevel, EncryptionLevel) -> EncryptionLevel -> Int
range :: (EncryptionLevel, EncryptionLevel) -> [EncryptionLevel]
$crange :: (EncryptionLevel, EncryptionLevel) -> [EncryptionLevel]
$cp1Ix :: Ord EncryptionLevel
Ix, Int -> EncryptionLevel -> ShowS
[EncryptionLevel] -> ShowS
EncryptionLevel -> String
(Int -> EncryptionLevel -> ShowS)
-> (EncryptionLevel -> String)
-> ([EncryptionLevel] -> ShowS)
-> Show EncryptionLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EncryptionLevel] -> ShowS
$cshowList :: [EncryptionLevel] -> ShowS
show :: EncryptionLevel -> String
$cshow :: EncryptionLevel -> String
showsPrec :: Int -> EncryptionLevel -> ShowS
$cshowsPrec :: Int -> EncryptionLevel -> ShowS
Show)

packetEncryptionLevel :: Header -> EncryptionLevel
packetEncryptionLevel :: Header -> EncryptionLevel
packetEncryptionLevel Initial{}   = EncryptionLevel
InitialLevel
packetEncryptionLevel RTT0{}      = EncryptionLevel
RTT0Level
packetEncryptionLevel Handshake{} = EncryptionLevel
HandshakeLevel
packetEncryptionLevel Short{}     = EncryptionLevel
RTT1Level

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

newtype Flags a = Flags Word8 deriving (Flags a -> Flags a -> Bool
(Flags a -> Flags a -> Bool)
-> (Flags a -> Flags a -> Bool) -> Eq (Flags a)
forall a. Flags a -> Flags a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flags a -> Flags a -> Bool
$c/= :: forall a. Flags a -> Flags a -> Bool
== :: Flags a -> Flags a -> Bool
$c== :: forall a. Flags a -> Flags a -> Bool
Eq, Int -> Flags a -> ShowS
[Flags a] -> ShowS
Flags a -> String
(Int -> Flags a -> ShowS)
-> (Flags a -> String) -> ([Flags a] -> ShowS) -> Show (Flags a)
forall a. Int -> Flags a -> ShowS
forall a. [Flags a] -> ShowS
forall a. Flags a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flags a] -> ShowS
$cshowList :: forall a. [Flags a] -> ShowS
show :: Flags a -> String
$cshow :: forall a. Flags a -> String
showsPrec :: Int -> Flags a -> ShowS
$cshowsPrec :: forall a. Int -> Flags a -> ShowS
Show)

data Protected
data Raw

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

type EncodedPacketNumber = Word32