{-|
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.
-}
{-# OPTIONS_GHC -Wno-duplicate-exports #-}
{-# LANGUAGE
    MagicHash
  , RecordWildCards
  , UndecidableInstances
  #-}

module Net.DNSBase.RData.TLSA
    ( -- * TLSA and SMIMEA
      X_tlsa(.., T_TLSA, T_SMIMEA
            , tlsaUsage, tlsaSelector, tlsaMtype, tlsaAssocData
            , smimeaUsage, smimeaSelector, smimeaMtype, smimeaAssocData)
    , type XtlsaConName
      -- *** @T_TLSA@ record pattern synonym fields
    , T_tlsa
    , tlsaUsage, tlsaSelector, tlsaMtype, tlsaAssocData
      -- *** @T_SMIMEA@ record pattern synonym fields
    , T_smimea
    , 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.
--
-- Note that @T_tlsa@ is just a type alias!  The 'T_TLSA' record pattern
-- synonym and its fields are bundled with the underlying 'X_tlsa'
-- data type.  In many cases it is sufficient to import just
-- @X_tlsa(..)@, but if you also need the type alias, it needs to be
-- imported separately:
--
-- > import Net.DNSBase (X_tlsa(..), T_tlsa)
--
type T_tlsa      = X_tlsa N_tlsa

-- | X_tlsa specialised to @SMIMEA@ records.
--
-- Note that @T_smimea@ is just a type alias!  The 'T_SMIMEA' record pattern
-- synonym and its fields are bundled with the underlying 'X_tlsa'
-- data type.  In many cases it is sufficient to import just
-- @X_tlsa(..)@, but if you also need the type alias, it needs to be
-- imported separately:
--
-- > import Net.DNSBase (X_tlsa(..), T_smimea)
--
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 $bT_TLSA :: Word8 -> Word8 -> Word8 -> ShortByteString -> T_tlsa
$mT_TLSA :: forall {r}.
T_tlsa
-> (Word8 -> Word8 -> Word8 -> ShortByteString -> r)
-> ((# #) -> r)
-> r
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 $bT_SMIMEA :: Word8 -> Word8 -> Word8 -> ShortByteString -> T_smimea
$mT_SMIMEA :: forall {r}.
T_smimea
-> (Word8 -> Word8 -> Word8 -> ShortByteString -> r)
-> ((# #) -> r)
-> r
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).
--
-- >                      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                  /
-- > /                                                               /
-- > +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
--
-- 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.
--
-- Note that @T_tlsa@ and @T_smime@ are just type aliases!  The
-- 'T_TLSA' and 'T_SMIMEA' record pattern synonyms and their
-- fields are bundled with the underlying 'X_tlsa' data type.  In
-- many cases it is sufficient to import just @X_tlsa(..)@, but if
-- you also need the type aliases, they need to be imported
-- separately:
--
-- > import Net.DNSBase (X_tlsa(..), T_tlsa, T_smimea)
--
-- 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
x_tlsaUsage     :: Word8           -- ^ Certificate Usage
    , forall (n :: Nat). X_tlsa n -> Word8
x_tlsaSelector  :: Word8           -- ^ Selector
    , forall (n :: Nat). X_tlsa n -> Word8
x_tlsaMtype     :: Word8           -- ^ Matching Type
    , forall (n :: Nat). X_tlsa n -> ShortByteString
x_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
x_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
x_tlsaUsage :: Word8
x_tlsaSelector :: Word8
x_tlsaMtype :: Word8
x_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
x_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
x_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
x_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
x_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
x_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
x_tlsaUsage :: Word8
x_tlsaSelector :: Word8
x_tlsaMtype :: Word8
x_tlsaAssocData :: ShortByteString
..} =
        Word8 -> Builder -> Builder
forall a. Presentable a => a -> Builder -> Builder
present     Word8
x_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
x_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
x_tlsaMtype
        (Builder -> Builder) -> (Builder -> Builder) -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Builder -> Builder
presentAd ShortByteString
x_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
x_tlsaUsage :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaSelector :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaMtype :: forall (n :: Nat). X_tlsa n -> Word8
x_tlsaAssocData :: forall (n :: Nat). X_tlsa n -> ShortByteString
x_tlsaUsage :: Word8
x_tlsaSelector :: Word8
x_tlsaMtype :: Word8
x_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
x_tlsaUsage
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> Word8 -> SizedBuilder
mbWord8           Word8
x_tlsaSelector
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> Word8 -> SizedBuilder
mbWord8           Word8
x_tlsaMtype
        SizedBuilder -> SizedBuilder -> SizedBuilder
forall a. Semigroup a => a -> a -> a
<> ShortByteString -> SizedBuilder
mbShortByteString ShortByteString
x_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
        x_tlsaUsage     <- SGet Word8
get8
        x_tlsaSelector  <- get8
        x_tlsaMtype     <- get8
        x_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