{-|
Module      : Net.DNSBase.RData.TLSA
Description : DANE-style key/certificate records (TLSA, SMIMEA, SSHFP, OPENPGPKEY)
Copyright   : (c) Viktor Dukhovni, 2026
License     : BSD-3-Clause
Maintainer  : ietf-dane@dukhovni.org
Stability   : unstable

Four DANE-style records that publish cryptographic identifiers
via DNS.  'T_tlsa' (RFC 6698) carries TLS certificate
associations; 'T_smimea' (RFC 8162) carries the same for
S/MIME — both share the wire format of the underlying 'X_tlsa'
representation.  'T_sshfp' (RFC 4255) carries SSH host-key
fingerprints.  'T_openpgpkey' (RFC 7929) carries an OpenPGP
transferable public key.
-}
{-# LANGUAGE
    MagicHash
  , RecordWildCards
  , UndecidableInstances
  #-}

module Net.DNSBase.RData.TLSA
    ( -- * TLSA and SMIMEA
      X_tlsa(.., T_TLSA, T_SMIMEA)
    , type XtlsaConName, T_tlsa, T_smimea
      -- *** 'T_TLSA' fields
    , tlsaUsage
    , tlsaSelector
    , tlsaMtype
    , tlsaAssocData
      -- *** 'T_SMIMEA' fields
    , smimeaUsage
    , smimeaSelector
    , smimeaMtype
    , smimeaAssocData
      -- * SSHFP
    , T_sshfp(..)
      -- * OPENPGPKEY
    , T_openpgpkey(..)
    ) where

import GHC.Exts (proxy#)
import GHC.TypeLits as TL (TypeError, ErrorMessage(..))
import GHC.TypeLits (KnownSymbol, Symbol, symbolVal')

import Net.DNSBase.Internal.Util

import Net.DNSBase.Bytes
import Net.DNSBase.Decode.State
import Net.DNSBase.Encode.Metric
import Net.DNSBase.Encode.State
import Net.DNSBase.Nat16
import Net.DNSBase.Present
import Net.DNSBase.RData
import Net.DNSBase.RRTYPE

type XtlsaConName :: Nat -> Symbol
type family XtlsaConName n where
    XtlsaConName N_tlsa   = "T_TLSA"
    XtlsaConName N_smimea = "T_SMIMEA"
    XtlsaConName n        = TypeError
                     ( ShowType n
                       :<>: TL.Text " is not a TLSA or SMIMEA RRTYPE" )

-- | X_tlsa specialised to @TLSA@ records.
type T_tlsa      = X_tlsa N_tlsa
-- | X_tlsa specialised to @SMIMEA@ records.
type T_smimea    = X_tlsa N_smimea

-- | Record pattern synonym viewing the shared 'X_tlsa' record as a
-- @TLSA@ (DANE for TLS) record, RFC 6698.  Fields: 'tlsaUsage',
-- 'tlsaSelector', 'tlsaMtype', 'tlsaAssocData'.  Not coercible to/from
-- 'T_smimea': the role of 'X_tlsa' is /nominal/ because TLSA and SMIMEA
-- bind to different protocols and the shared wire format is
-- coincidental.
pattern T_TLSA :: Word8 -- ^ Certificate Usage
               -> Word8 -- ^ Selector
               -> Word8 -- ^ Matching Type
               -> ShortByteString -- ^ Certificate Association Data
               -> T_tlsa
pattern $mT_TLSA :: forall {r}.
T_tlsa
-> (Word8 -> Word8 -> Word8 -> ShortByteString -> r)
-> ((# #) -> r)
-> r
$bT_TLSA :: Word8 -> Word8 -> Word8 -> ShortByteString -> T_tlsa
T_TLSA { T_tlsa -> Word8
tlsaUsage, T_tlsa -> Word8
tlsaSelector, T_tlsa -> Word8
tlsaMtype, T_tlsa -> ShortByteString
tlsaAssocData }
      = (X_TLSA tlsaUsage tlsaSelector tlsaMtype tlsaAssocData :: T_tlsa)
{-# COMPLETE T_TLSA #-}

-- | Record pattern synonym viewing the shared 'X_tlsa' record as an
-- @SMIMEA@ (DANE for S/MIME) record, RFC 8162.  Fields: 'smimeaUsage',
-- 'smimeaSelector', 'smimeaMtype', 'smimeaAssocData'.  Not coercible
-- to/from 'T_tlsa' (see 'T_TLSA' note).
pattern T_SMIMEA :: Word8 -- ^ Certificate Usage
                 -> Word8 -- ^ Selector
                 -> Word8 -- ^ Matching Type
                 -> ShortByteString -- ^ Certificate Association Data
                 -> T_smimea
pattern $mT_SMIMEA :: forall {r}.
T_smimea
-> (Word8 -> Word8 -> Word8 -> ShortByteString -> r)
-> ((# #) -> r)
-> r
$bT_SMIMEA :: Word8 -> Word8 -> Word8 -> ShortByteString -> T_smimea
T_SMIMEA { T_smimea -> Word8
smimeaUsage, T_smimea -> Word8
smimeaSelector, T_smimea -> Word8
smimeaMtype, T_smimea -> ShortByteString
smimeaAssocData }
      = (X_TLSA smimeaUsage smimeaSelector smimeaMtype smimeaAssocData :: T_smimea)
{-# COMPLETE T_SMIMEA #-}

-- | Shared wire-format representation for DANE certificate-binding
-- records: the @TLSA@ record
-- ([RFC 6698 section 2.1](https://tools.ietf.org/html/rfc6698#section-2.1),
-- DANE for TLS) and the @SMIMEA@ record
-- ([RFC 8162 section 2](https://tools.ietf.org/html/rfc8162#section-2),
-- DANE for S/MIME).  The type parameter @n@ (either 'N_tlsa' or
-- 'N_smimea') determines the RR type.  Each has its own type synonym
-- ('T_tlsa', 'T_smimea') and matching record pattern synonym
-- ('T_TLSA', 'T_SMIMEA') with the corresponding field-name prefix
-- (@tlsa@, @smimea@).  The role of 'X_tlsa' is /nominal/: the wire
-- format is shared but the two RR types bind to different protocols,
-- so 'T_tlsa' and 'T_smimea' are not coercible.
--
-- >                      1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
-- >  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-- > |  Cert. Usage  |   Selector    | Matching Type |               /
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+               /
-- > /                                                               /
-- > /                 Certificate Association Data                  /
-- > /                                                               /
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
--
-- If a received message carries a payload shorter than 3 bytes the
-- record is returned as an opaque RData of the corresponding
-- RRTYPE with the truncated bytes as its value; DANE validators
-- should treat such records as present but "unusable".
--
-- Derived 'Ord' is canonical
-- ([RFC 4034 section 6.2](https://datatracker.ietf.org/doc/html/rfc4034#section-6.2)).
--
-- See 'T_sshfp' for the SSH host-key fingerprint record and
-- 'T_openpgpkey' for the OpenPGP key record — both also live in
-- this module.
type X_tlsa :: Nat -> Type
type role X_tlsa nominal
data X_tlsa n = X_TLSA
    { forall (n :: Nat). X_tlsa n -> Word8
_tlsaUsage     :: Word8           -- ^ Certificate Usage
    , forall (n :: Nat). X_tlsa n -> Word8
_tlsaSelector  :: Word8           -- ^ Selector
    , forall (n :: Nat). X_tlsa n -> Word8
_tlsaMtype     :: Word8           -- ^ Matching Type
    , forall (n :: Nat). X_tlsa n -> ShortByteString
_tlsaAssocData :: ShortByteString -- ^ Certificate Association Data
    }
deriving instance (KnownSymbol (XtlsaConName n)) => Eq (X_tlsa n)
deriving instance (KnownSymbol (XtlsaConName n)) => Ord (X_tlsa n)

instance (Nat16 n, KnownSymbol (XtlsaConName n)) => Show (X_tlsa n) where
    showsPrec :: Int -> X_tlsa n -> ShowS
showsPrec Int
p X_TLSA{Word8
ShortByteString
_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
_tlsaUsage :: Word8
_tlsaSelector :: Word8
_tlsaMtype :: Word8
_tlsaAssocData :: ShortByteString
..} = Int -> ShowS -> ShowS
showsP Int
p (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString (Proxy# (XtlsaConName n) -> String
forall (n :: Symbol). KnownSymbol n => Proxy# n -> String
symbolVal' (forall {k} (a :: k). Proxy# a
forall (a :: Symbol). Proxy# a
proxy# @(XtlsaConName n))) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ShowS
forall a. Show a => a -> ShowS
shows' Word8
_tlsaUsage    ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ShowS
forall a. Show a => a -> ShowS
shows' Word8
_tlsaSelector ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ShowS
forall a. Show a => a -> ShowS
shows' Word8
_tlsaMtype    ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ShowS
showAd ShortByteString
_tlsaAssocData
      where
        showAd :: ShortByteString -> ShowS
showAd = forall a. Show a => a -> ShowS
shows @Bytes16 (Bytes16 -> ShowS)
-> (ShortByteString -> Bytes16) -> ShortByteString -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Bytes16
forall a b. Coercible a b => a -> b
coerce

instance (KnownSymbol (XtlsaConName n)) => Presentable (X_tlsa n) where
    present :: X_tlsa n -> Builder -> Builder
present X_TLSA{Word8
ShortByteString
_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
_tlsaUsage :: Word8
_tlsaSelector :: Word8
_tlsaMtype :: Word8
_tlsaAssocData :: ShortByteString
..} =
        Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
present     Word8
_tlsaUsage
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
presentSp Word8
_tlsaSelector
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
presentSp Word8
_tlsaMtype
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Builder -> Builder
presentAd ShortByteString
_tlsaAssocData
      where
        presentAd :: ShortByteString -> Builder -> Builder
presentAd = forall a. Presentable a => a -> Builder -> Builder
presentSp @Bytes16 (Bytes16 -> Builder -> Builder)
-> (ShortByteString -> Bytes16)
-> ShortByteString
-> Builder
-> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Bytes16
forall a b. Coercible a b => a -> b
coerce

instance (Nat16 n, KnownSymbol (XtlsaConName n)) => KnownRData (X_tlsa n) where
    rdType :: forall b -> (b ~ X_tlsa n) => RRTYPE
rdType _ = Word16 -> RRTYPE
RRTYPE (Word16 -> RRTYPE) -> Word16 -> RRTYPE
forall a b. (a -> b) -> a -> b
$ natToWord16 n
    {-# INLINE rdType #-}
    rdEncode :: forall s. X_tlsa n -> SPut s RData
rdEncode X_TLSA{Word8
ShortByteString
_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
_tlsaUsage :: Word8
_tlsaSelector :: Word8
_tlsaMtype :: Word8
_tlsaAssocData :: ShortByteString
..} = SizedBuilder -> SPut s RData
forall r s. ErrorContext r => SizedBuilder -> SPut s r
putSizedBuilder (SizedBuilder -> SPut s RData) -> SizedBuilder -> SPut s RData
forall a b. (a -> b) -> a -> b
$
        Word8 -> SizedBuilder
mbWord8              Word8
_tlsaUsage
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> Word8 -> SizedBuilder
mbWord8           Word8
_tlsaSelector
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> Word8 -> SizedBuilder
mbWord8           Word8
_tlsaMtype
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> ShortByteString -> SizedBuilder
mbShortByteString ShortByteString
_tlsaAssocData
    rdDecode :: forall b ->
(b ~ X_tlsa n) => RDataExtensionVal (X_tlsa n) -> Int -> SGet RData
rdDecode _ RDataExtensionVal (X_tlsa n)
_ = SGet RData -> Int -> SGet RData
forall a b. a -> b -> a
const do
        _tlsaUsage     <- SGet Word8
get8
        _tlsaSelector  <- get8
        _tlsaMtype     <- get8
        _tlsaAssocData <- getShortByteString
        pure $ RData (X_TLSA{..} :: X_tlsa n)

-- | The @SSHFP@ resource record
-- ([RFC 4255 section 3.1](https://www.rfc-editor.org/rfc/rfc4255.html#section-3.1))
-- — a fingerprint of an SSH host public key.  Three fields: an
-- 8-bit /algorithm/ tag (matches the SSH key algorithm), an 8-bit
-- /fingerprint type/ tag (SHA-1, SHA-256, ...), and the
-- fingerprint bytes.
--
-- >                     1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
-- > 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-- > |   algorithm   |    fp type    |                               /
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               /
-- > /                                                               /
-- > /                          fingerprint                          /
-- > /                                                               /
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
--
-- See 'X_tlsa' / 'T_openpgpkey' for the other DANE-style records
-- in this module.
data T_sshfp = T_SSHFP
    { T_sshfp -> Word8
sshfpKeyAlgor :: Word8
    , T_sshfp -> Word8
sshfpHashType :: Word8
    , T_sshfp -> ShortByteString
sshfpKeyValue :: ShortByteString
    } deriving (T_sshfp -> T_sshfp -> Bool
(T_sshfp -> T_sshfp -> Bool)
-> (T_sshfp -> T_sshfp -> Bool) -> Eq T_sshfp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: T_sshfp -> T_sshfp -> Bool
== :: T_sshfp -> T_sshfp -> Bool
$c/= :: T_sshfp -> T_sshfp -> Bool
/= :: T_sshfp -> T_sshfp -> Bool
Eq, Eq T_sshfp
Eq T_sshfp =>
(T_sshfp -> T_sshfp -> Ordering)
-> (T_sshfp -> T_sshfp -> Bool)
-> (T_sshfp -> T_sshfp -> Bool)
-> (T_sshfp -> T_sshfp -> Bool)
-> (T_sshfp -> T_sshfp -> Bool)
-> (T_sshfp -> T_sshfp -> T_sshfp)
-> (T_sshfp -> T_sshfp -> T_sshfp)
-> Ord T_sshfp
T_sshfp -> T_sshfp -> Bool
T_sshfp -> T_sshfp -> Ordering
T_sshfp -> T_sshfp -> T_sshfp
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
$ccompare :: T_sshfp -> T_sshfp -> Ordering
compare :: T_sshfp -> T_sshfp -> Ordering
$c< :: T_sshfp -> T_sshfp -> Bool
< :: T_sshfp -> T_sshfp -> Bool
$c<= :: T_sshfp -> T_sshfp -> Bool
<= :: T_sshfp -> T_sshfp -> Bool
$c> :: T_sshfp -> T_sshfp -> Bool
> :: T_sshfp -> T_sshfp -> Bool
$c>= :: T_sshfp -> T_sshfp -> Bool
>= :: T_sshfp -> T_sshfp -> Bool
$cmax :: T_sshfp -> T_sshfp -> T_sshfp
max :: T_sshfp -> T_sshfp -> T_sshfp
$cmin :: T_sshfp -> T_sshfp -> T_sshfp
min :: T_sshfp -> T_sshfp -> T_sshfp
Ord)

instance Show T_sshfp where
    showsPrec :: Int -> T_sshfp -> ShowS
showsPrec Int
p T_SSHFP{Word8
ShortByteString
sshfpKeyAlgor :: T_sshfp -> Word8
sshfpHashType :: T_sshfp -> Word8
sshfpKeyValue :: T_sshfp -> ShortByteString
sshfpKeyAlgor :: Word8
sshfpHashType :: Word8
sshfpKeyValue :: ShortByteString
..} = Int -> ShowS -> ShowS
showsP Int
p (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"T_SSHFP "
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ShowS
forall a. Show a => a -> ShowS
shows' Word8
sshfpKeyAlgor ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ShowS
forall a. Show a => a -> ShowS
shows' Word8
sshfpHashType ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ShowS
showKv ShortByteString
sshfpKeyValue
      where
        showKv :: ShortByteString -> ShowS
showKv = forall a. Show a => a -> ShowS
shows @Bytes16 (Bytes16 -> ShowS)
-> (ShortByteString -> Bytes16) -> ShortByteString -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Bytes16
forall a b. Coercible a b => a -> b
coerce

instance Presentable T_sshfp where
    present :: T_sshfp -> Builder -> Builder
present T_SSHFP{Word8
ShortByteString
sshfpKeyAlgor :: T_sshfp -> Word8
sshfpHashType :: T_sshfp -> Word8
sshfpKeyValue :: T_sshfp -> ShortByteString
sshfpKeyAlgor :: Word8
sshfpHashType :: Word8
sshfpKeyValue :: ShortByteString
..} =
        Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
present     Word8
sshfpKeyAlgor
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
presentSp Word8
sshfpHashType
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Builder -> Builder
presentKv ShortByteString
sshfpKeyValue
      where
        presentKv :: ShortByteString -> Builder -> Builder
presentKv = forall a. Presentable a => a -> Builder -> Builder
presentSp @Bytes16 (Bytes16 -> Builder -> Builder)
-> (ShortByteString -> Bytes16)
-> ShortByteString
-> Builder
-> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Bytes16
forall a b. Coercible a b => a -> b
coerce

instance KnownRData T_sshfp where
    rdType :: forall b -> (b ~ T_sshfp) => RRTYPE
rdType _ = RRTYPE
SSHFP
    {-# INLINE rdType #-}
    rdEncode :: forall s. T_sshfp -> SPut s RData
rdEncode T_SSHFP{Word8
ShortByteString
sshfpKeyAlgor :: T_sshfp -> Word8
sshfpHashType :: T_sshfp -> Word8
sshfpKeyValue :: T_sshfp -> ShortByteString
sshfpKeyAlgor :: Word8
sshfpHashType :: Word8
sshfpKeyValue :: ShortByteString
..} = SizedBuilder -> SPut s RData
forall r s. ErrorContext r => SizedBuilder -> SPut s r
putSizedBuilder (SizedBuilder -> SPut s RData) -> SizedBuilder -> SPut s RData
forall a b. (a -> b) -> a -> b
$
        Word8 -> SizedBuilder
mbWord8              Word8
sshfpKeyAlgor
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> Word8 -> SizedBuilder
mbWord8           Word8
sshfpHashType
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> ShortByteString -> SizedBuilder
mbShortByteString ShortByteString
sshfpKeyValue
    rdDecode :: forall b ->
(b ~ T_sshfp) => RDataExtensionVal T_sshfp -> Int -> SGet RData
rdDecode _ RDataExtensionVal T_sshfp
_ = SGet RData -> Int -> SGet RData
forall a b. a -> b -> a
const do
        sshfpKeyAlgor <- SGet Word8
get8
        sshfpHashType <- get8
        sshfpKeyValue <- getShortByteString
        return $ RData T_SSHFP{..}

-- | The @OPENPGPKEY@ resource record
-- ([RFC 7929 section 2.2](https://www.rfc-editor.org/rfc/rfc7929.html#section-2.2))
-- — an OpenPGP transferable public key, carried as raw bytes (no
-- ASCII armor, no base64).  Single-field; presented in
-- base64 form.
--
-- See 'X_tlsa' / 'T_sshfp' for the other DANE-style records in
-- this module.
data T_openpgpkey = T_OPENPGPKEY
    { T_openpgpkey -> ShortByteString
openpgpKey :: ShortByteString
    } deriving (T_openpgpkey -> T_openpgpkey -> Bool
(T_openpgpkey -> T_openpgpkey -> Bool)
-> (T_openpgpkey -> T_openpgpkey -> Bool) -> Eq T_openpgpkey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: T_openpgpkey -> T_openpgpkey -> Bool
== :: T_openpgpkey -> T_openpgpkey -> Bool
$c/= :: T_openpgpkey -> T_openpgpkey -> Bool
/= :: T_openpgpkey -> T_openpgpkey -> Bool
Eq, Eq T_openpgpkey
Eq T_openpgpkey =>
(T_openpgpkey -> T_openpgpkey -> Ordering)
-> (T_openpgpkey -> T_openpgpkey -> Bool)
-> (T_openpgpkey -> T_openpgpkey -> Bool)
-> (T_openpgpkey -> T_openpgpkey -> Bool)
-> (T_openpgpkey -> T_openpgpkey -> Bool)
-> (T_openpgpkey -> T_openpgpkey -> T_openpgpkey)
-> (T_openpgpkey -> T_openpgpkey -> T_openpgpkey)
-> Ord T_openpgpkey
T_openpgpkey -> T_openpgpkey -> Bool
T_openpgpkey -> T_openpgpkey -> Ordering
T_openpgpkey -> T_openpgpkey -> T_openpgpkey
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
$ccompare :: T_openpgpkey -> T_openpgpkey -> Ordering
compare :: T_openpgpkey -> T_openpgpkey -> Ordering
$c< :: T_openpgpkey -> T_openpgpkey -> Bool
< :: T_openpgpkey -> T_openpgpkey -> Bool
$c<= :: T_openpgpkey -> T_openpgpkey -> Bool
<= :: T_openpgpkey -> T_openpgpkey -> Bool
$c> :: T_openpgpkey -> T_openpgpkey -> Bool
> :: T_openpgpkey -> T_openpgpkey -> Bool
$c>= :: T_openpgpkey -> T_openpgpkey -> Bool
>= :: T_openpgpkey -> T_openpgpkey -> Bool
$cmax :: T_openpgpkey -> T_openpgpkey -> T_openpgpkey
max :: T_openpgpkey -> T_openpgpkey -> T_openpgpkey
$cmin :: T_openpgpkey -> T_openpgpkey -> T_openpgpkey
min :: T_openpgpkey -> T_openpgpkey -> T_openpgpkey
Ord)

instance Show T_openpgpkey where
    showsPrec :: Int -> T_openpgpkey -> ShowS
showsPrec Int
p T_OPENPGPKEY{ShortByteString
openpgpKey :: T_openpgpkey -> ShortByteString
openpgpKey :: ShortByteString
..} = Int -> ShowS -> ShowS
showsP Int
p (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"T_OPENPGPKEY " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> ShowS
shows @Bytes64 (ShortByteString -> Bytes64
forall a b. Coercible a b => a -> b
coerce ShortByteString
openpgpKey)

instance Presentable T_openpgpkey where
    present :: T_openpgpkey -> Builder -> Builder
present T_OPENPGPKEY{ShortByteString
openpgpKey :: T_openpgpkey -> ShortByteString
openpgpKey :: ShortByteString
..} = forall a. Presentable a => a -> Builder -> Builder
present @Bytes64 (ShortByteString -> Bytes64
forall a b. Coercible a b => a -> b
coerce ShortByteString
openpgpKey)

instance KnownRData T_openpgpkey where
    rdType :: forall b -> (b ~ T_openpgpkey) => RRTYPE
rdType _ = RRTYPE
OPENPGPKEY
    {-# INLINE rdType #-}
    rdEncode :: forall s. T_openpgpkey -> SPut s RData
rdEncode T_OPENPGPKEY{ShortByteString
openpgpKey :: T_openpgpkey -> ShortByteString
openpgpKey :: ShortByteString
..} = SizedBuilder -> SPut s RData
forall r s. ErrorContext r => SizedBuilder -> SPut s r
putSizedBuilder (SizedBuilder -> SPut s RData) -> SizedBuilder -> SPut s RData
forall a b. (a -> b) -> a -> b
$
        ShortByteString -> SizedBuilder
mbShortByteString ShortByteString
openpgpKey
    rdDecode :: forall b ->
(b ~ T_openpgpkey) =>
RDataExtensionVal T_openpgpkey -> Int -> SGet RData
rdDecode _ RDataExtensionVal T_openpgpkey
_ = T_openpgpkey -> RData
forall a. KnownRData a => a -> RData
RData (T_openpgpkey -> RData)
-> (ShortByteString -> T_openpgpkey) -> ShortByteString -> RData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> T_openpgpkey
T_OPENPGPKEY (ShortByteString -> RData)
-> (Int -> SGet ShortByteString) -> Int -> SGet RData
forall (m :: * -> *) b c a.
Functor m =>
(b -> c) -> (a -> m b) -> a -> m c
<.> Int -> SGet ShortByteString
getShortNByteString