Network.DNS

This module implements an API for accessing the Domain Name Service (DNS) resolver service via the standard libresolv system library on Unix systems.

High level API

queryA :: Name -> IO [(TTL, IPv4)]

Query A record (see RFC 1035, section 3.4.1).

This query returns only exact matches (modulo foldCaseName). E.g. in case of CNAME responses even if the answer section would contain A records for the hostnames pointed to by the CNAME. You can use query if you need more control.

>>> queryA (Name "www.google.com")
[(TTL 72,IPv4 0xd83acde4)]

queryAAAA :: Name -> IO [(TTL, IPv6)]

Query AAAA records (see RFC 3596).

This query returns only exact matches (modulo foldCaseName). E.g. in case of CNAME responses even if the answer section would contain A records for the hostnames pointed to by the CNAME. You can use query if you need more control.

>>> queryAAAA (Name "www.google.com")
[(TTL 299,IPv6 0x2a0014504001081e 0x2004)]

queryCNAME :: Name -> IO [(TTL, Name)]

Query CNAME records (see RFC 1035, section 3.3.1).

>>> queryCNAME (Name "hackage.haskell.org")
[(TTL 299,Name "j.global-ssl.fastly.net.")]

querySRV :: Name -> IO [(TTL, SRV Name)]

Query SRV records (see RFC 2782).

>>> querySRV (Name "_imap._tcp.gmail.com")
[(TTL 21599,SRV {srvPriority = 0, srvWeight = 0, srvPort = 0, srvTarget = Name "."})]

queryTXT :: Name -> IO [(TTL, [CharStr])]

Query TXT records (see RFC 1035, section 3.3.14).

>>> queryTXT (Name "_mirrors.hackage.haskell.org")
[(TTL 299,["0.urlbase=http://hackage.fpcomplete.com/",
           "1.urlbase=http://objects-us-west-1.dream.io/hackage-mirror/"])]

Mid-level API

query :: IsLabels n => Class -> n -> TypeSym -> IO (Msg n)

Send a query via res_query(3) and decode its response into a Msg

Throws DnsException in case of encoding or decoding errors. May throw other IO exceptions in case of network errors.

Example

>>> query classIN (Name "_mirrors.hackage.haskell.org") TypeTXT
Just (Msg{msgHeader = MsgHeader{mhId    = 56694,
                                mhFlags = MsgHeaderFlags{mhQR = IsResponse, mhOpcode = 0, mhAA = False,
                                                         mhTC = False, mhRD = True, mhRA = True, mhZ = False,
                                                         mhAD = False, mhCD = False, mhRCode = 0},
                                mhQDCount = 1, mhANCount = 1, mhNSCount = 0, mhARCount = 1},
          msgQD = [MsgQuestion (Name "_mirrors.hackage.haskell.org.") (Type 16) (Class 1)],
          msgAN = [MsgRR{rrName  = Name "_mirrors.hackage.haskell.org.",
                         rrClass = Class 1, rrTTL = TTL 299,
                         rrData  = RDataTXT ["0.urlbase=http://hackage.fpcomplete.com/",
                                             "1.urlbase=http://objects-us-west-1.dream.io/hackage-mirror/"]}],
          msgNS = [],
          msgAR = [MsgRR{rrName = Name ".", rrClass = Class 512, rrTTL = TTL 32768, rrData = RDataOPT ""}]
      })

Low-level API

queryRaw :: Class -> Name -> Type -> IO ByteString

Send a query via res_query(3), the return value is the raw binary response message.

You can use decodeMessage to decode the response message.

sendRaw :: ByteString -> IO ByteString

Send a raw preformatted query via res_send(3).

mkQueryRaw :: Class -> Name -> Type -> IO ByteString

Use res_mkquery(3) to construct a DNS query message.

decodeMessage :: IsLabels n => ByteString -> Maybe (Msg n)

Decode a raw DNS message (query or response)

Returns Nothing on decoding failures.

encodeMessage :: IsLabels n => Msg n -> Maybe ByteString

Construct a raw DNS message (query or response)

May return Nothing in input parameters are detected to be invalid.

mkQueryMsg :: IsLabels n => Class -> n -> Type -> Msg n

Construct a DNS query Msg in the style of mkQueryRaw

Types

Basic types

Names/Labels

type Label = ByteString

A DNS Label

Must be non-empty and at most 63 octets.

data Labels

A domain-name as per RFC 1035, section 3.3 expressed as list of Labels.

See also Name

Constructors

!Label :.: !Labels infixr 5

Root

Instances

Eq Labels

Methods

(==) :: Labels -> Labels -> Bool

(/=) :: Labels -> Labels -> Bool

Ord Labels

Methods

compare :: Labels -> Labels -> Ordering

(<) :: Labels -> Labels -> Bool

(<=) :: Labels -> Labels -> Bool

(>) :: Labels -> Labels -> Bool

(>=) :: Labels -> Labels -> Bool

max :: Labels -> Labels -> Labels

min :: Labels -> Labels -> Labels

Read Labels

Methods

readsPrec :: Int -> ReadS Labels

readList :: ReadS [Labels]

readPrec :: ReadPrec Labels

readListPrec :: ReadPrec [Labels]

Show Labels

Methods

showsPrec :: Int -> Labels -> ShowS

show :: Labels -> String

showList :: [Labels] -> ShowS

IsLabels Labels

Methods

toLabels :: Labels -> Maybe Labels

fromLabels :: Labels -> Labels

class IsLabels s where

Types that represent domain-name as per RFC 1035, section 3.3 and can be converted to and from Labels.

Minimal complete definition

toLabels, fromLabels

Methods

toLabels :: s -> Maybe Labels

fromLabels :: Labels -> s

Instances

IsLabels Labels

Methods

toLabels :: Labels -> Maybe Labels

fromLabels :: Labels -> Labels

IsLabels Name

Methods

toLabels :: Name -> Maybe Labels

fromLabels :: Labels -> Name

newtype Name

<domain-name> as per RFC 1035, section 3.3.

A domain-name represented as a series of labels separated by dots.

See also Labels for list-based representation.

NOTE: The Labels type is able to properly represent domain names whose components contain dots which the Name representation cannot.

Constructors

Name ByteString

Instances

Eq Name

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Ord Name

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Read Name

Methods

readsPrec :: Int -> ReadS Name

readList :: ReadS [Name]

readPrec :: ReadPrec Name

readListPrec :: ReadPrec [Name]

Show Name

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

IsLabels Name

Methods

toLabels :: Name -> Maybe Labels

fromLabels :: Labels -> Name

caseFoldName :: Name -> Name

Normalise Name

This function case folds Names as described in in RFC 4343, section 3 by subtracting 0x20 from all octets in the inclusive range [0x61..0x7A] (i.e. mapping ['a'..'z'] to ['A'..'Z']).

This operation is idempotent.

Character strings

newtype CharStr

<character-string> as per RFC 1035, section 3.3.

A sequence of up to 255 octets

The limit of 255 octets is caused by the encoding which uses by a prefixed octet denoting the length.

Constructors

CharStr ByteString

Instances

Eq CharStr

Methods

(==) :: CharStr -> CharStr -> Bool

(/=) :: CharStr -> CharStr -> Bool

Ord CharStr

Methods

compare :: CharStr -> CharStr -> Ordering

(<) :: CharStr -> CharStr -> Bool

(<=) :: CharStr -> CharStr -> Bool

(>) :: CharStr -> CharStr -> Bool

(>=) :: CharStr -> CharStr -> Bool

max :: CharStr -> CharStr -> CharStr

min :: CharStr -> CharStr -> CharStr

Read CharStr

Methods

readsPrec :: Int -> ReadS CharStr

readList :: ReadS [CharStr]

readPrec :: ReadPrec CharStr

readListPrec :: ReadPrec [CharStr]

Show CharStr

Methods

showsPrec :: Int -> CharStr -> ShowS

show :: CharStr -> String

showList :: [CharStr] -> ShowS

IsString CharStr

Methods

fromString :: String -> CharStr

Binary CharStr

Methods

put :: CharStr -> Put

get :: Get CharStr

putList :: [CharStr] -> Put

IP addresses

data IPv4

An IPv4 address

The IP address is represented in network order, i.e. 127.0.0.1 is represented as (IPv4 0x7f000001).

Constructors

IPv4 !Word32

Instances

Eq IPv4

Methods

(==) :: IPv4 -> IPv4 -> Bool

(/=) :: IPv4 -> IPv4 -> Bool

Ord IPv4

Methods

compare :: IPv4 -> IPv4 -> Ordering

(<) :: IPv4 -> IPv4 -> Bool

(<=) :: IPv4 -> IPv4 -> Bool

(>) :: IPv4 -> IPv4 -> Bool

(>=) :: IPv4 -> IPv4 -> Bool

max :: IPv4 -> IPv4 -> IPv4

min :: IPv4 -> IPv4 -> IPv4

Read IPv4

Methods

readsPrec :: Int -> ReadS IPv4

readList :: ReadS [IPv4]

readPrec :: ReadPrec IPv4

readListPrec :: ReadPrec [IPv4]

Show IPv4

Methods

showsPrec :: Int -> IPv4 -> ShowS

show :: IPv4 -> String

showList :: [IPv4] -> ShowS

Binary IPv4

Methods

put :: IPv4 -> Put

get :: Get IPv4

putList :: [IPv4] -> Put

data IPv6

An IPv6 address

The IP address is represented in network order, i.e. 2606:2800:220:1:248:1893:25c8:1946 is represented as (IPv6 0x2606280002200001 0x248189325c81946).

Constructors

IPv6 !Word64 !Word64

Instances

Eq IPv6

Methods

(==) :: IPv6 -> IPv6 -> Bool

(/=) :: IPv6 -> IPv6 -> Bool

Ord IPv6

Methods

compare :: IPv6 -> IPv6 -> Ordering

(<) :: IPv6 -> IPv6 -> Bool

(<=) :: IPv6 -> IPv6 -> Bool

(>) :: IPv6 -> IPv6 -> Bool

(>=) :: IPv6 -> IPv6 -> Bool

max :: IPv6 -> IPv6 -> IPv6

min :: IPv6 -> IPv6 -> IPv6

Read IPv6

Methods

readsPrec :: Int -> ReadS IPv6

readList :: ReadS [IPv6]

readPrec :: ReadPrec IPv6

readListPrec :: ReadPrec [IPv6]

Show IPv6

Methods

showsPrec :: Int -> IPv6 -> ShowS

show :: IPv6 -> String

showList :: [IPv6] -> ShowS

Binary IPv6

Methods

put :: IPv6 -> Put

get :: Get IPv6

putList :: [IPv6] -> Put

RR TTL & Class

newtype TTL

Cache time-to-live expressed in seconds

Constructors

TTL Int32

Instances

Eq TTL

Methods

(==) :: TTL -> TTL -> Bool

(/=) :: TTL -> TTL -> Bool

Ord TTL

Methods

compare :: TTL -> TTL -> Ordering

(<) :: TTL -> TTL -> Bool

(<=) :: TTL -> TTL -> Bool

(>) :: TTL -> TTL -> Bool

(>=) :: TTL -> TTL -> Bool

max :: TTL -> TTL -> TTL

min :: TTL -> TTL -> TTL

Read TTL

Methods

readsPrec :: Int -> ReadS TTL

readList :: ReadS [TTL]

readPrec :: ReadPrec TTL

readListPrec :: ReadPrec [TTL]

Show TTL

Methods

showsPrec :: Int -> TTL -> ShowS

show :: TTL -> String

showList :: [TTL] -> ShowS

Binary TTL

Methods

put :: TTL -> Put

get :: Get TTL

putList :: [TTL] -> Put

newtype Class

DNS CLASS code as per RFC 1035, section 3.2.4

The most commonly used value is classIN.

Constructors

Class Word16

Instances

Eq Class

Methods

(==) :: Class -> Class -> Bool

(/=) :: Class -> Class -> Bool

Ord Class

Methods

compare :: Class -> Class -> Ordering

(<) :: Class -> Class -> Bool

(<=) :: Class -> Class -> Bool

(>) :: Class -> Class -> Bool

(>=) :: Class -> Class -> Bool

max :: Class -> Class -> Class

min :: Class -> Class -> Class

Read Class

Methods

readsPrec :: Int -> ReadS Class

readList :: ReadS [Class]

readPrec :: ReadPrec Class

readListPrec :: ReadPrec [Class]

Show Class

Methods

showsPrec :: Int -> Class -> ShowS

show :: Class -> String

showList :: [Class] -> ShowS

Binary Class

Methods

put :: Class -> Put

get :: Get Class

putList :: [Class] -> Put

classIN :: Class

The Class constant for IN (Internet)

Message types

newtype Type

Raw DNS record type code

See also TypeSym

Constructors

Type Word16

Instances

Eq Type

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Ord Type

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Read Type

Methods

readsPrec :: Int -> ReadS Type

readList :: ReadS [Type]

readPrec :: ReadPrec Type

readListPrec :: ReadPrec [Type]

Show Type

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

Binary Type

Methods

put :: Type -> Put

get :: Get Type

putList :: [Type] -> Put

data TypeSym

Symbolic DNS record type

Constructors

TypeA

RFC 1035

TypeAAAA

RFC 3596

TypeAFSDB

RFC 1183

TypeANY

RFC 1035 (query)

TypeCAA

RFC 6844

TypeCNAME

RFC 1035

TypeDNSKEY

RFC 4034

TypeDS

RFC 4034

TypeHINFO

RFC 1035

TypeMX

RFC 1035

TypeNAPTR

RFC 2915

TypeNS

RFC 1035

TypeNSEC

RFC 4034

TypeNSEC3

RFC 5155

TypeNSEC3PARAM

RFC 5155

TypeOPT

RFC 6891 (meta)

TypePTR

RFC 1035

TypeRRSIG

RFC 4034

TypeSOA

RFC 1035

TypeSPF

RFC 4408

TypeSRV

RFC 2782

TypeSSHFP

RFC 4255

TypeTXT

RFC 1035

TypeURI

RFC 7553

Instances

Bounded TypeSym

Methods

minBound :: TypeSym

maxBound :: TypeSym

Enum TypeSym

Methods

succ :: TypeSym -> TypeSym

pred :: TypeSym -> TypeSym

toEnum :: Int -> TypeSym

fromEnum :: TypeSym -> Int

enumFrom :: TypeSym -> [TypeSym]

enumFromThen :: TypeSym -> TypeSym -> [TypeSym]

enumFromTo :: TypeSym -> TypeSym -> [TypeSym]

enumFromThenTo :: TypeSym -> TypeSym -> TypeSym -> [TypeSym]

Eq TypeSym

Methods

(==) :: TypeSym -> TypeSym -> Bool

(/=) :: TypeSym -> TypeSym -> Bool

Ord TypeSym

Methods

compare :: TypeSym -> TypeSym -> Ordering

(<) :: TypeSym -> TypeSym -> Bool

(<=) :: TypeSym -> TypeSym -> Bool

(>) :: TypeSym -> TypeSym -> Bool

(>=) :: TypeSym -> TypeSym -> Bool

max :: TypeSym -> TypeSym -> TypeSym

min :: TypeSym -> TypeSym -> TypeSym

Read TypeSym

Methods

readsPrec :: Int -> ReadS TypeSym

readList :: ReadS [TypeSym]

readPrec :: ReadPrec TypeSym

readListPrec :: ReadPrec [TypeSym]

Show TypeSym

Methods

showsPrec :: Int -> TypeSym -> ShowS

show :: TypeSym -> String

showList :: [TypeSym] -> ShowS

typeFromSym :: TypeSym -> Type

Convert symbolic TypeSym to numeric Type code

typeToSym :: Type -> Maybe TypeSym

Convert Type code to symbolic TypeSym

Messages

data Msg l

Represents a DNS message as per RFC 1035

Constructors

Msg

Fields

• msgHeader :: !MsgHeader
• msgQD :: [MsgQuestion l]
• msgAN, msgNS, msgAR :: [MsgRR l]

Instances

Functor Msg

Methods

fmap :: (a -> b) -> Msg a -> Msg b

(<$) :: a -> Msg b -> Msg a

Foldable Msg

Methods

fold :: Monoid m => Msg m -> m

foldMap :: Monoid m => (a -> m) -> Msg a -> m

foldr :: (a -> b -> b) -> b -> Msg a -> b

foldr' :: (a -> b -> b) -> b -> Msg a -> b

foldl :: (b -> a -> b) -> b -> Msg a -> b

foldl' :: (b -> a -> b) -> b -> Msg a -> b

foldr1 :: (a -> a -> a) -> Msg a -> a

foldl1 :: (a -> a -> a) -> Msg a -> a

toList :: Msg a -> [a]

null :: Msg a -> Bool

length :: Msg a -> Int

elem :: Eq a => a -> Msg a -> Bool

maximum :: Ord a => Msg a -> a

minimum :: Ord a => Msg a -> a

sum :: Num a => Msg a -> a

product :: Num a => Msg a -> a

Traversable Msg

Methods

traverse :: Applicative f => (a -> f b) -> Msg a -> f (Msg b)

sequenceA :: Applicative f => Msg (f a) -> f (Msg a)

mapM :: Monad m => (a -> m b) -> Msg a -> m (Msg b)

sequence :: Monad m => Msg (m a) -> m (Msg a)

Read l => Read (Msg l)

Methods

readsPrec :: Int -> ReadS (Msg l)

readList :: ReadS [Msg l]

readPrec :: ReadPrec (Msg l)

readListPrec :: ReadPrec [Msg l]

Show l => Show (Msg l)

Methods

showsPrec :: Int -> Msg l -> ShowS

show :: Msg l -> String

showList :: [Msg l] -> ShowS

Binary l => Binary (Msg l)

Methods

put :: Msg l -> Put

get :: Get (Msg l)

putList :: [Msg l] -> Put

data MsgHeader

DNS message header section as per RFC 1035, section 4.1.1

Constructors

MsgHeader

Fields

• mhId :: !Word16
• mhFlags :: !MsgHeaderFlags
• mhQDCount :: !Word16
• mhANCount :: !Word16
• mhNSCount :: !Word16
• mhARCount :: !Word16

Instances

Read MsgHeader

Methods

readsPrec :: Int -> ReadS MsgHeader

readList :: ReadS [MsgHeader]

readPrec :: ReadPrec MsgHeader

readListPrec :: ReadPrec [MsgHeader]

Show MsgHeader

Methods

showsPrec :: Int -> MsgHeader -> ShowS

show :: MsgHeader -> String

showList :: [MsgHeader] -> ShowS

Binary MsgHeader

Methods

put :: MsgHeader -> Put

get :: Get MsgHeader

putList :: [MsgHeader] -> Put

data MsgHeaderFlags

DNS message header flags as per RFC 1035, section 4.1.1

Constructors

MsgHeaderFlags

Fields

• mhQR :: !QR
• mhOpcode :: !Word8
• mhAA :: !Bool
• mhTC :: !Bool
• mhRD :: !Bool
• mhRA :: !Bool
• mhZ :: !Bool
• mhAD :: !Bool
• mhCD :: !Bool
• mhRCode :: !Word8

Instances

Read MsgHeaderFlags

Methods

readsPrec :: Int -> ReadS MsgHeaderFlags

readList :: ReadS [MsgHeaderFlags]

readPrec :: ReadPrec MsgHeaderFlags

readListPrec :: ReadPrec [MsgHeaderFlags]

Show MsgHeaderFlags

Methods

showsPrec :: Int -> MsgHeaderFlags -> ShowS

show :: MsgHeaderFlags -> String

showList :: [MsgHeaderFlags] -> ShowS

Binary MsgHeaderFlags

Methods

put :: MsgHeaderFlags -> Put

get :: Get MsgHeaderFlags

putList :: [MsgHeaderFlags] -> Put

data MsgQuestion l

DNS message header section as per RFC 1035, section 4.1.2

Constructors

MsgQuestion !l !Type !Class

Instances

Functor MsgQuestion

Methods

fmap :: (a -> b) -> MsgQuestion a -> MsgQuestion b

(<$) :: a -> MsgQuestion b -> MsgQuestion a

Foldable MsgQuestion

Methods

fold :: Monoid m => MsgQuestion m -> m

foldMap :: Monoid m => (a -> m) -> MsgQuestion a -> m

foldr :: (a -> b -> b) -> b -> MsgQuestion a -> b

foldr' :: (a -> b -> b) -> b -> MsgQuestion a -> b

foldl :: (b -> a -> b) -> b -> MsgQuestion a -> b

foldl' :: (b -> a -> b) -> b -> MsgQuestion a -> b

foldr1 :: (a -> a -> a) -> MsgQuestion a -> a

foldl1 :: (a -> a -> a) -> MsgQuestion a -> a

toList :: MsgQuestion a -> [a]

null :: MsgQuestion a -> Bool

length :: MsgQuestion a -> Int

elem :: Eq a => a -> MsgQuestion a -> Bool

maximum :: Ord a => MsgQuestion a -> a

minimum :: Ord a => MsgQuestion a -> a

sum :: Num a => MsgQuestion a -> a

product :: Num a => MsgQuestion a -> a

Traversable MsgQuestion

Methods

traverse :: Applicative f => (a -> f b) -> MsgQuestion a -> f (MsgQuestion b)

sequenceA :: Applicative f => MsgQuestion (f a) -> f (MsgQuestion a)

mapM :: Monad m => (a -> m b) -> MsgQuestion a -> m (MsgQuestion b)

sequence :: Monad m => MsgQuestion (m a) -> m (MsgQuestion a)

Eq l => Eq (MsgQuestion l)

Methods

(==) :: MsgQuestion l -> MsgQuestion l -> Bool

(/=) :: MsgQuestion l -> MsgQuestion l -> Bool

Read l => Read (MsgQuestion l)

Methods

readsPrec :: Int -> ReadS (MsgQuestion l)

readList :: ReadS [MsgQuestion l]

readPrec :: ReadPrec (MsgQuestion l)

readListPrec :: ReadPrec [MsgQuestion l]

Show l => Show (MsgQuestion l)

Methods

showsPrec :: Int -> MsgQuestion l -> ShowS

show :: MsgQuestion l -> String

showList :: [MsgQuestion l] -> ShowS

Binary l => Binary (MsgQuestion l)

Methods

put :: MsgQuestion l -> Put

get :: Get (MsgQuestion l)

putList :: [MsgQuestion l] -> Put

data MsgRR l

DNS resource record section as per RFC 1035, section 4.1.3

Constructors

MsgRR

Fields

• rrName :: !l
• rrClass :: !Class
• rrTTL :: !TTL
• rrData :: !(RData l)

Instances

Functor MsgRR

Methods

fmap :: (a -> b) -> MsgRR a -> MsgRR b

(<$) :: a -> MsgRR b -> MsgRR a

Foldable MsgRR

Methods

fold :: Monoid m => MsgRR m -> m

foldMap :: Monoid m => (a -> m) -> MsgRR a -> m

foldr :: (a -> b -> b) -> b -> MsgRR a -> b

foldr' :: (a -> b -> b) -> b -> MsgRR a -> b

foldl :: (b -> a -> b) -> b -> MsgRR a -> b

foldl' :: (b -> a -> b) -> b -> MsgRR a -> b

foldr1 :: (a -> a -> a) -> MsgRR a -> a

foldl1 :: (a -> a -> a) -> MsgRR a -> a

toList :: MsgRR a -> [a]

null :: MsgRR a -> Bool

length :: MsgRR a -> Int

elem :: Eq a => a -> MsgRR a -> Bool

maximum :: Ord a => MsgRR a -> a

minimum :: Ord a => MsgRR a -> a

sum :: Num a => MsgRR a -> a

product :: Num a => MsgRR a -> a

Traversable MsgRR

Methods

traverse :: Applicative f => (a -> f b) -> MsgRR a -> f (MsgRR b)

sequenceA :: Applicative f => MsgRR (f a) -> f (MsgRR a)

mapM :: Monad m => (a -> m b) -> MsgRR a -> m (MsgRR b)

sequence :: Monad m => MsgRR (m a) -> m (MsgRR a)

Eq l => Eq (MsgRR l)

Methods

(==) :: MsgRR l -> MsgRR l -> Bool

(/=) :: MsgRR l -> MsgRR l -> Bool

Read l => Read (MsgRR l)

Methods

readsPrec :: Int -> ReadS (MsgRR l)

readList :: ReadS [MsgRR l]

readPrec :: ReadPrec (MsgRR l)

readListPrec :: ReadPrec [MsgRR l]

Show l => Show (MsgRR l)

Methods

showsPrec :: Int -> MsgRR l -> ShowS

show :: MsgRR l -> String

showList :: [MsgRR l] -> ShowS

Binary l => Binary (MsgRR l)

Methods

put :: MsgRR l -> Put

get :: Get (MsgRR l)

putList :: [MsgRR l] -> Put

data RData l

DNS resource record data (see also MsgRR and TypeSym)

Constructors

RDataA !IPv4

RDataAAAA !IPv6

RDataCNAME !l

RDataPTR !l

RDataHINFO !CharStr !CharStr

RDataNS !l

RDataMX !Word16 !l

RDataTXT ![CharStr]

RDataSPF ![CharStr]

RDataSOA !l !l !Word32 !Word32 !Word32 !Word32 !Word32

RDataSRV !(SRV l)

RDataAFSDB !Word16 !l

RDataNAPTR !Word16 !Word16 !CharStr !CharStr !CharStr !l

RDataURI !Word16 !Word16 !ByteString

RDataRRSIG !Word16 !Word8 !Word8 !Word32 !Word32 !Word32 !Word16 !l !ByteString

RDataDNSKEY !Word16 !Word8 !Word8 !ByteString

RDataDS !Word16 !Word8 !Word8 !ByteString

RDataNSEC !l !(Set Type)

RDataSSHFP !Word8 !Word8 !ByteString

RDataNSEC3PARAM !Word8 !Word8 !Word16 !CharStr

RDataNSEC3 !Word8 !Word8 !Word16 !CharStr !CharStr !(Set Type)

RDataCAA !Word8 !CharStr !ByteString

RDataOPT !ByteString

RData !Type !ByteString

Unknown/undecoded resource record type

Instances

Functor RData

Methods

fmap :: (a -> b) -> RData a -> RData b

(<$) :: a -> RData b -> RData a

Foldable RData

Methods

fold :: Monoid m => RData m -> m

foldMap :: Monoid m => (a -> m) -> RData a -> m

foldr :: (a -> b -> b) -> b -> RData a -> b

foldr' :: (a -> b -> b) -> b -> RData a -> b

foldl :: (b -> a -> b) -> b -> RData a -> b

foldl' :: (b -> a -> b) -> b -> RData a -> b

foldr1 :: (a -> a -> a) -> RData a -> a

foldl1 :: (a -> a -> a) -> RData a -> a

toList :: RData a -> [a]

null :: RData a -> Bool

length :: RData a -> Int

elem :: Eq a => a -> RData a -> Bool

maximum :: Ord a => RData a -> a

minimum :: Ord a => RData a -> a

sum :: Num a => RData a -> a

product :: Num a => RData a -> a

Traversable RData

Methods

traverse :: Applicative f => (a -> f b) -> RData a -> f (RData b)

sequenceA :: Applicative f => RData (f a) -> f (RData a)

mapM :: Monad m => (a -> m b) -> RData a -> m (RData b)

sequence :: Monad m => RData (m a) -> m (RData a)

Eq l => Eq (RData l)

Methods

(==) :: RData l -> RData l -> Bool

(/=) :: RData l -> RData l -> Bool

Read l => Read (RData l)

Methods

readsPrec :: Int -> ReadS (RData l)

readList :: ReadS [RData l]

readPrec :: ReadPrec (RData l)

readListPrec :: ReadPrec [RData l]

Show l => Show (RData l)

Methods

showsPrec :: Int -> RData l -> ShowS

show :: RData l -> String

showList :: [RData l] -> ShowS

rdType :: RData l -> Either Type TypeSym

Extract the resource record type of a RData object

data SRV l

SRV Record data as per RFC 2782

Constructors

SRV

Fields

• srvPriority :: !Word16
• srvWeight :: !Word16
• srvPort :: !Word16
• srvTarget :: !l

Instances

Functor SRV

Methods

fmap :: (a -> b) -> SRV a -> SRV b

(<$) :: a -> SRV b -> SRV a

Foldable SRV

Methods

fold :: Monoid m => SRV m -> m

foldMap :: Monoid m => (a -> m) -> SRV a -> m

foldr :: (a -> b -> b) -> b -> SRV a -> b

foldr' :: (a -> b -> b) -> b -> SRV a -> b

foldl :: (b -> a -> b) -> b -> SRV a -> b

foldl' :: (b -> a -> b) -> b -> SRV a -> b

foldr1 :: (a -> a -> a) -> SRV a -> a

foldl1 :: (a -> a -> a) -> SRV a -> a

toList :: SRV a -> [a]

null :: SRV a -> Bool

length :: SRV a -> Int

elem :: Eq a => a -> SRV a -> Bool

maximum :: Ord a => SRV a -> a

minimum :: Ord a => SRV a -> a

sum :: Num a => SRV a -> a

product :: Num a => SRV a -> a

Traversable SRV

Methods

traverse :: Applicative f => (a -> f b) -> SRV a -> f (SRV b)

sequenceA :: Applicative f => SRV (f a) -> f (SRV a)

mapM :: Monad m => (a -> m b) -> SRV a -> m (SRV b)

sequence :: Monad m => SRV (m a) -> m (SRV a)

Eq l => Eq (SRV l)

Methods

(==) :: SRV l -> SRV l -> Bool

(/=) :: SRV l -> SRV l -> Bool

Read l => Read (SRV l)

Methods

readsPrec :: Int -> ReadS (SRV l)

readList :: ReadS [SRV l]

readPrec :: ReadPrec (SRV l)

readListPrec :: ReadPrec [SRV l]

Show l => Show (SRV l)

Methods

showsPrec :: Int -> SRV l -> ShowS

show :: SRV l -> String

showList :: [SRV l] -> ShowS

Binary l => Binary (SRV l)

Methods

put :: SRV l -> Put

get :: Get (SRV l)

putList :: [SRV l] -> Put