Data.IP

iproute-1.7.1: IP Routing Table

Safe Haskell | None
Language | Haskell2010

Data.IP

Contents

- Documentation
  - IP data
  - IP range data
  - Address class

Description

Data structures to express IPv4, IPv6 and IP range.

Synopsis

- data IP
  - = IPv4 {
    - ipv4 :: IPv4
    }
  - | IPv6 {
    - ipv6 :: IPv6
    }
- data IPv4
- toIPv4 :: [Int] -> IPv4
- fromIPv4 :: IPv4 -> [Int]
- fromHostAddress :: HostAddress -> IPv4
- toHostAddress :: IPv4 -> HostAddress
- data IPv6
- toIPv6 :: [Int] -> IPv6
- toIPv6b :: [Int] -> IPv6
- fromIPv6 :: IPv6 -> [Int]
- fromIPv6b :: IPv6 -> [Int]
- fromHostAddress6 :: HostAddress6 -> IPv6
- toHostAddress6 :: IPv6 -> HostAddress6
- data IPRange
  - = IPv4Range {
    - ipv4range :: AddrRange IPv4
    }
  - | IPv6Range {
    - ipv6range :: AddrRange IPv6
    }
- data AddrRange a
- class Eq a => Addr a where
- makeAddrRange :: Addr a => a -> Int -> AddrRange a
- (>:>) :: Addr a => AddrRange a -> AddrRange a -> Bool
- isMatchedTo :: Addr a => a -> AddrRange a -> Bool
- addrRangePair :: Addr a => AddrRange a -> (a, Int)
- ipv4RangeToIPv6 :: AddrRange IPv4 -> AddrRange IPv6
- ipv4ToIPv6 :: IPv4 -> IPv6

# Documentation

## IP data

data IP #

A unified IP data for `IPv4` and `IPv6`. To create this, use the data constructors. Or use `read` `"192.0.2.1"` :: `IP`, for example. Also, `"192.0.2.1"` can be used as literal with OverloadedStrings.

    >>> (read "192.0.2.1" :: IP) == IPv4 (read "192.0.2.1" :: IPv4)
    True
    >>> (read "2001:db8:00:00:00:00:00:01" :: IP) == IPv6 (read "2001:db8:00:00:00:00:00:01" :: IPv6)
    True

Constructors

IPv4 |
Fields ipv4 :: IPv4
IPv6 |
Fields ipv6 :: IPv6

Instances

Enum IP # |
Methods succ :: IP -> IP # pred :: IP -> IP # toEnum :: Int -> IP # fromEnum :: IP -> Int # enumFrom :: IP -> [IP] # enumFromThen :: IP -> IP -> [IP] # enumFromTo :: IP -> IP -> [IP] # enumFromThenTo :: IP -> IP -> IP -> [IP] #
Eq IP # | Equality over IP addresses. Correctly compare IPv4 and IPv4-embedded-in-IPv6 addresses.
    >>> (read "2001:db8:00:00:00:00:00:01" :: IP) == (read "2001:db8:00:00:00:00:00:01" :: IP)
    True
    >>> (read "2001:db8:00:00:00:00:00:01" :: IP) == (read "2001:db8:00:00:00:00:00:05" :: IP)
    False
    >>> (read "127.0.0.1" :: IP) == (read "127.0.0.1" :: IP)
    True
    >>> (read "127.0.0.1" :: IP) == (read "10.0.0.1" :: IP)
    False
    >>> (read "::ffff:127.0.0.1" :: IP) == (read "127.0.0.1" :: IP)
    True
    >>> (read "::ffff:127.0.0.1" :: IP) == (read "127.0.0.9" :: IP)
    False
    >>> (read "::ffff:127.0.0.1" :: IP) >= (read "127.0.0.1" :: IP)
    True
    >>> (read "::ffff:127.0.0.1" :: IP) <= (read "127.0.0.1" :: IP)
    True
Methods (==) :: IP -> IP -> Bool # (/=) :: IP -> IP -> Bool #
Data IP # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IP -> c IP # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IP # toConstr :: IP -> Constr # dataTypeOf :: IP -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IP) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IP) # gmapT :: (forall b. Data b => b -> b) -> IP -> IP # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r # gmapQ :: (forall d. Data d => d -> u) -> IP -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IP -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IP -> m IP # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IP -> m IP # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IP -> m IP #
Ord IP # |
Methods compare :: IP -> IP -> Ordering # (<) :: IP -> IP -> Bool # (<=) :: IP -> IP -> Bool # (>) :: IP -> IP -> Bool # (>=) :: IP -> IP -> Bool # max :: IP -> IP -> IP # min :: IP -> IP -> IP #
Read IP # |
Methods readsPrec :: Int -> ReadS IP # readList :: ReadS [IP] # readPrec :: ReadPrec IP # readListPrec :: ReadPrec [IP] #
Show IP # |
Methods showsPrec :: Int -> IP -> ShowS # show :: IP -> String # showList :: [IP] -> ShowS #
IsString IP # |
Methods fromString :: String -> IP #
Generic IP # |
Associated Types type Rep IP :: * -> * # Methods from :: IP -> Rep IP x # to :: Rep IP x -> IP #
type Rep IP # |
type Rep IP = D1 (MetaData "IP" "Data.IP.Addr" "iproute-1.7.1-9hsGfRvggCmFA0ueZi5Sd9" False) ((:+:) (C1 (MetaCons "IPv4" PrefixI True) (S1 (MetaSel (Just Symbol "ipv4") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IPv4))) (C1 (MetaCons "IPv6" PrefixI True) (S1 (MetaSel (Just Symbol "ipv6") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IPv6))))

data IPv4 #

The abstract data type to express an IPv4 address. To create this, use `toIPv4`. Or use `read` `"192.0.2.1"` :: `IPv4`, for example. Also, `"192.0.2.1"` can be used as literal with OverloadedStrings.

    >>> read "192.0.2.1" :: IPv4
    192.0.2.1

Instances

Bounded IPv4 # |
Methods minBound :: IPv4 # maxBound :: IPv4 #
Enum IPv4 # |
Methods succ :: IPv4 -> IPv4 # pred :: IPv4 -> IPv4 # toEnum :: Int -> IPv4 # fromEnum :: IPv4 -> Int # enumFrom :: IPv4 -> [IPv4] # enumFromThen :: IPv4 -> IPv4 -> [IPv4] # enumFromTo :: IPv4 -> IPv4 -> [IPv4] # enumFromThenTo :: IPv4 -> IPv4 -> IPv4 -> [IPv4] #
Eq IPv4 # |
Methods (==) :: IPv4 -> IPv4 -> Bool # (/=) :: IPv4 -> IPv4 -> Bool #
Data IPv4 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPv4 -> c IPv4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IPv4 # toConstr :: IPv4 -> Constr # dataTypeOf :: IPv4 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IPv4) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv4) # gmapT :: (forall b. Data b => b -> b) -> IPv4 -> IPv4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r # gmapQ :: (forall d. Data d => d -> u) -> IPv4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IPv4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPv4 -> m IPv4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPv4 -> m IPv4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPv4 -> m IPv4 #
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 #
IsString IPv4 # |
Methods fromString :: String -> IPv4 #
Generic IPv4 # |
Associated Types type Rep IPv4 :: * -> * # Methods from :: IPv4 -> Rep IPv4 x # to :: Rep IPv4 x -> IPv4 #
Addr IPv4 # |
Methods masked :: IPv4 -> IPv4 -> IPv4 # intToMask :: Int -> IPv4 #
Routable IPv4 # |
Methods intToTBit :: Int -> IPv4 # isZero :: IPv4 -> IPv4 -> Bool #
Read (AddrRange IPv4) # |
Methods readsPrec :: Int -> ReadS (AddrRange IPv4) # readList :: ReadS [AddrRange IPv4] # readPrec :: ReadPrec (AddrRange IPv4) # readListPrec :: ReadPrec [AddrRange IPv4] #
IsString (AddrRange IPv4) # |
Methods fromString :: String -> AddrRange IPv4 #
type Rep IPv4 # |
type Rep IPv4

toIPv4 :: [Int] -> IPv4 #

The `toIPv4` function takes a list of `Int` and returns `IPv4`.

    >>> toIPv4 [192,0,2,1]
    192.0.2.1

fromIPv4 :: IPv4 -> [Int] #

The `fromIPv4` function converts `IPv4` to a list of `Int`.

    >>> fromIPv4 (toIPv4 [192,0,2,1])
    [192,0,2,1]

fromHostAddress :: HostAddress -> IPv4 #

The `fromHostAddress` function converts `HostAddress` to `IPv4`.

toHostAddress :: IPv4 -> HostAddress #

The `toHostAddress` function converts `IPv4` to `HostAddress`.

data IPv6 #

The abstract data type to express an IPv6 address. To create this, use `toIPv6`. Or use `read` `"2001:DB8::1"` :: `IPv6`, for example. Also, `"2001:DB8::1"` can be used as literal with OverloadedStrings.

    >>> read "2001:db8:00:00:00:00:00:01" :: IPv6
    2001:db8::1
    >>> read "2001:db8:11e:c00::101" :: IPv6
    2001:db8:11e:c00::101
    >>> read "2001:db8:11e:c00:aa:bb:192.0.2.1" :: IPv6
    2001:db8:11e:c00:aa:bb:c000:201
    >>> read "2001:db8::192.0.2.1" :: IPv6
    2001:db8::c000:201
    >>> read "0::ffff:192.0.2.1" :: IPv6
    ::ffff:192.0.2.1
    >>> read "0::0:c000:201" :: IPv6
    ::192.0.2.1
    >>> read "::0.0.0.1" :: IPv6
    ::1

Instances

Bounded IPv6 # |
Methods minBound :: IPv6 # maxBound :: IPv6 #
Enum IPv6 # |
Methods succ :: IPv6 -> IPv6 # pred :: IPv6 -> IPv6 # toEnum :: Int -> IPv6 # fromEnum :: IPv6 -> Int # enumFrom :: IPv6 -> [IPv6] # enumFromThen :: IPv6 -> IPv6 -> [IPv6] # enumFromTo :: IPv6 -> IPv6 -> [IPv6] # enumFromThenTo :: IPv6 -> IPv6 -> IPv6 -> [IPv6] #
Eq IPv6 # |
Methods (==) :: IPv6 -> IPv6 -> Bool # (/=) :: IPv6 -> IPv6 -> Bool #
Data IPv6 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPv6 -> c IPv6 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IPv6 # toConstr :: IPv6 -> Constr # dataTypeOf :: IPv6 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IPv6) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv6) # gmapT :: (forall b. Data b => b -> b) -> IPv6 -> IPv6 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r # gmapQ :: (forall d. Data d => d -> u) -> IPv6 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IPv6 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPv6 -> m IPv6 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPv6 -> m IPv6 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPv6 -> m IPv6 #
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 #
IsString IPv6 # |
Methods fromString :: String -> IPv6 #
Generic IPv6 # |
Associated Types type Rep IPv6 :: * -> * # Methods from :: IPv6 -> Rep IPv6 x # to :: Rep IPv6 x -> IPv6 #
Addr IPv6 # |
Methods masked :: IPv6 -> IPv6 -> IPv6 # intToMask :: Int -> IPv6 #
Routable IPv6 # |
Methods intToTBit :: Int -> IPv6 # isZero :: IPv6 -> IPv6 -> Bool #
Read (AddrRange IPv6) # |
Methods readsPrec :: Int -> ReadS (AddrRange IPv6) # readList :: ReadS [AddrRange IPv6] # readPrec :: ReadPrec (AddrRange IPv6) # readListPrec :: ReadPrec [AddrRange IPv6] #
IsString (AddrRange IPv6) # |
Methods fromString :: String -> AddrRange IPv6 #
type Rep IPv6 # |
type Rep IPv6

toIPv6 :: [Int] -> IPv6 #

The `toIPv6` function takes a list of `Int` and returns `IPv6`.

    >>> toIPv6 [0x2001,0xDB8,0,0,0,0,0,1]
    2001:db8::1

toIPv6b :: [Int] -> IPv6 #

The `toIPv6b` function takes a list of `Int` where each member repserents a single byte and returns `IPv6`.

    >>> toIPv6b [0x20,0x01,0xD,0xB8,0,0,0,0,0,0,0,0,0,0,0,1]
    2001:db8::1

fromIPv6 :: IPv6 -> [Int] #

The `toIPv6` function converts `IPv6` to a list of `Int`.

    >>> fromIPv6 (toIPv6 [0x2001,0xDB8,0,0,0,0,0,1])
    [8193,3512,0,0,0,0,0,1]

fromIPv6b :: IPv6 -> [Int] #

The `fromIPv6b` function converts `IPv6` to a list of `Int` where each member represents a single byte.

    >>> fromIPv6b (toIPv6b [0x20,0x01,0xD,0xB8,0,0,0,0,0,0,0,0,0,0,0,1])
    [32,1,13,184,0,0,0,0,0,0,0,0,0,0,0,1]

fromHostAddress6 :: HostAddress6 -> IPv6 #

The `fromHostAddress6` function converts `HostAddress6` to `IPv6`.

toHostAddress6 :: IPv6 -> HostAddress6 #

The `toHostAddress6` function converts `IPv6` to `HostAddress6`.

## IP range data

data IPRange #

A unified data for `AddrRange` `IPv4` and `AddrRange` `IPv6`. To create this, use `read` `"192.0.2.0/24"` :: `IPRange`. Also, `"192.0.2.0/24"` can be used as literal with OverloadedStrings.

    >>> (read "192.0.2.1/24" :: IPRange) == IPv4Range (read "192.0.2.0/24" :: AddrRange IPv4)
    True
    >>> (read "2001:db8:00:00:00:00:00:01/48" :: IPRange) == IPv6Range (read "2001:db8:00:00:00:00:00:01/48" :: AddrRange IPv6)
    True

Constructors

IPv4Range |
Fields ipv4range :: AddrRange IPv4
IPv6Range |
Fields ipv6range :: AddrRange IPv6

Instances

Eq IPRange # |
Methods (==) :: IPRange -> IPRange -> Bool # (/=) :: IPRange -> IPRange -> Bool #
Data IPRange # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPRange -> c IPRange # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IPRange # toConstr :: IPRange -> Constr # dataTypeOf :: IPRange -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IPRange) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPRange) # gmapT :: (forall b. Data b => b -> b) -> IPRange -> IPRange # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPRange -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPRange -> r # gmapQ :: (forall d. Data d => d -> u) -> IPRange -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IPRange -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPRange -> m IPRange # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPRange -> m IPRange # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPRange -> m IPRange #
Ord IPRange # |
Methods compare :: IPRange -> IPRange -> Ordering # (<) :: IPRange -> IPRange -> Bool # (<=) :: IPRange -> IPRange -> Bool # (>) :: IPRange -> IPRange -> Bool # (>=) :: IPRange -> IPRange -> Bool # max :: IPRange -> IPRange -> IPRange # min :: IPRange -> IPRange -> IPRange #
Read IPRange # |
Methods readsPrec :: Int -> ReadS IPRange # readList :: ReadS [IPRange] # readPrec :: ReadPrec IPRange # readListPrec :: ReadPrec [IPRange] #
Show IPRange # |
Methods showsPrec :: Int -> IPRange -> ShowS # show :: IPRange -> String # showList :: [IPRange] -> ShowS #
IsString IPRange # |
Methods fromString :: String -> IPRange #
Generic IPRange # |
Associated Types type Rep IPRange :: * -> * # Methods from :: IPRange -> Rep IPRange x # to :: Rep IPRange x -> IPRange #
type Rep IPRange # |
type Rep IPRange = D1 (MetaData "IPRange" "Data.IP.Range" "iproute-1.7.1-9hsGfRvggCmFA0ueZi5Sd9" False) ((:+:) (C1 (MetaCons "IPv4Range" PrefixI True) (S1 (MetaSel (Just Symbol "ipv4range") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AddrRange IPv4)))) (C1 (MetaCons "IPv6Range" PrefixI True) (S1 (MetaSel (Just Symbol "ipv6range") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AddrRange IPv6)))))

data AddrRange a #

The Addr range consists of an address, a contiguous mask, and mask length. The contiguous mask and the mask length are essentially same information but contained for pre calculation.

To create this, use `makeAddrRange` or `read` `"192.0.2.0/24"` :: `AddrRange` `IPv4`. Also, `"192.0.2.0/24"` can be used as literal with OverloadedStrings.

    >>> read "192.0.2.1/24" :: AddrRange IPv4
    192.0.2.0/24
    >>> read "2001:db8:00:00:00:00:00:01/48" :: AddrRange IPv6
    2001:db8::/48

Instances

Eq a => Eq (AddrRange a) # |
Methods (==) :: AddrRange a -> AddrRange a -> Bool # (/=) :: AddrRange a -> AddrRange a -> Bool #
Data a => Data (AddrRange a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AddrRange a -> c (AddrRange a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AddrRange a) # toConstr :: AddrRange a -> Constr # dataTypeOf :: AddrRange a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (AddrRange a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AddrRange a)) # gmapT :: (forall b. Data b => b -> b) -> AddrRange a -> AddrRange a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AddrRange a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AddrRange a -> r # gmapQ :: (forall d. Data d => d -> u) -> AddrRange a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AddrRange a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AddrRange a -> m (AddrRange a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AddrRange a -> m (AddrRange a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AddrRange a -> m (AddrRange a) #
Ord a => Ord (AddrRange a) # |
Methods compare :: AddrRange a -> AddrRange a -> Ordering # (<) :: AddrRange a -> AddrRange a -> Bool # (<=) :: AddrRange a -> AddrRange a -> Bool # (>) :: AddrRange a -> AddrRange a -> Bool # (>=) :: AddrRange a -> AddrRange a -> Bool # max :: AddrRange a -> AddrRange a -> AddrRange a # min :: AddrRange a -> AddrRange a -> AddrRange a #
Read (AddrRange IPv6) # |
Methods readsPrec :: Int -> ReadS (AddrRange IPv6) # readList :: ReadS [AddrRange IPv6] # readPrec :: ReadPrec (AddrRange IPv6) # readListPrec :: ReadPrec [AddrRange IPv6] #
Read (AddrRange IPv4) # |
Methods readsPrec :: Int -> ReadS (AddrRange IPv4) # readList :: ReadS [AddrRange IPv4] # readPrec :: ReadPrec (AddrRange IPv4) # readListPrec :: ReadPrec [AddrRange IPv4] #
Show a => Show (AddrRange a) # |
Methods showsPrec :: Int -> AddrRange a -> ShowS # show :: AddrRange a -> String # showList :: [AddrRange a] -> ShowS #
IsString (AddrRange IPv6) # |
Methods fromString :: String -> AddrRange IPv6 #
IsString (AddrRange IPv4) # |
Methods fromString :: String -> AddrRange IPv4 #
Generic (AddrRange a) # |
Associated Types type Rep (AddrRange a) :: * -> * # Methods from :: AddrRange a -> Rep (AddrRange a) x # to :: Rep (AddrRange a) x -> AddrRange a #
type Rep (AddrRange a) # |
type Rep (AddrRange a) = D1 (MetaData "AddrRange" "Data.IP.Range" "iproute-1.7.1-9hsGfRvggCmFA0ueZi5Sd9" False) (C1 (MetaCons "AddrRange" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "addr") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) ((:*:) (S1 (MetaSel (Just Symbol "mask") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "mlen") SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int)))))

## Address class

class Eq a => Addr a where #

    >>> toIPv4 [127,0,2,1] `masked` intToMask 7
    126.0.0.0

Minimal complete definition

masked, intToMask

Methods

masked :: a -> a -> a #

The `masked` function takes an `Addr` and a contiguous mask and returned a masked `Addr`.

intToMask :: Int -> a #

The `intToMask` function takes an `Int` representing the number of bits to be set in the returned contiguous mask. When this integer is positive the bits will be starting from the MSB and from the LSB otherwise.

    >>> intToMask 16 :: IPv4
    255.255.0.0

    >>> intToMask (-16) :: IPv4
    0.0.255.255

    >>> intToMask 16 :: IPv6
    ffff::

    >>> intToMask (-16) :: IPv6
    ::ffff

Instances

Addr IPv6 # |
Methods masked :: IPv6 -> IPv6 -> IPv6 # intToMask :: Int -> IPv6 #
Addr IPv4 # |
Methods masked :: IPv4 -> IPv4 -> IPv4 # intToMask :: Int -> IPv4 #

makeAddrRange :: Addr a => a -> Int -> AddrRange a #

The `makeAddrRange` functions takes an `Addr` address and a mask length. It creates a bit mask from the mask length and masks the `Addr` address, then returns `AddrRange` made of them.

    >>> makeAddrRange (toIPv4 [127,0,2,1]) 8
    127.0.0.0/8
    >>> makeAddrRange (toIPv6 [0x2001,0xDB8,0,0,0,0,0,1]) 8
    2000::/8

(>:>) :: Addr a => AddrRange a -> AddrRange a -> Bool #

The >:> operator takes two `AddrRange`. It returns `True` if the first `AddrRange` contains the second `AddrRange`. Otherwise, it returns `False`.

    >>> makeAddrRange ("127.0.2.1" :: IPv4) 8 >:> makeAddrRange "127.0.2.1" 24
    True
    >>> makeAddrRange ("127.0.2.1" :: IPv4) 24 >:> makeAddrRange "127.0.2.1" 8
    False
    >>> makeAddrRange ("2001:DB8::1" :: IPv6) 16 >:> makeAddrRange "2001:DB8::1" 32
    True
    >>> makeAddrRange ("2001:DB8::1" :: IPv6) 32 >:> makeAddrRange "2001:DB8::1" 16
    False

isMatchedTo :: Addr a => a -> AddrRange a -> Bool #

The `toMatchedTo` function take an `Addr` address and an `AddrRange`, and returns `True` if the range contains the address.

    >>> ("127.0.2.0" :: IPv4) `isMatchedTo` makeAddrRange "127.0.2.1" 24
    True
    >>> ("127.0.2.0" :: IPv4) `isMatchedTo` makeAddrRange "127.0.2.1" 32
    False
    >>> ("2001:DB8::1" :: IPv6) `isMatchedTo` makeAddrRange "2001:DB8::1" 32
    True
    >>> ("2001:DB8::" :: IPv6) `isMatchedTo` makeAddrRange "2001:DB8::1" 128
    False

addrRangePair :: Addr a => AddrRange a -> (a, Int) #

The `unmakeAddrRange` functions take a `AddrRange` and returns the network address and a mask length.

    >>> addrRangePair ("127.0.0.0/8" :: AddrRange IPv4)
    (127.0.0.0,8)
    >>> addrRangePair ("2000::/8" :: AddrRange IPv6)
    (2000::,8)

ipv4RangeToIPv6 :: AddrRange IPv4 -> AddrRange IPv6 #

Convert IPv4 range to IPV4-embedded-in-IPV6 range

ipv4ToIPv6 :: IPv4 -> IPv6 #

Convert IPv4 address to IPv4-embedded-in-IPv6