iproute-1.7.12: IP Routing Table
Safe Haskell None
Language Haskell2010

Data.IP

Description

Data structures to express IPv4, IPv6 and IP range.

Synopsis

IP data

data IP Source #

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

IPv6

Fields

Instances

Instances details
Enum IP Source #
Instance details

Defined in Data.IP.Addr

Eq IP Source #

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
Instance details

Defined in Data.IP.Addr

Data IP Source #
Instance details

Defined in Data.IP.Addr

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IP -> c IP Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c IP Source #

toConstr :: IP -> Constr Source #

dataTypeOf :: IP -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c IP ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c IP ) Source #

gmapT :: ( forall b. Data b => b -> b) -> IP -> IP Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IP -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IP -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> IP -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> IP -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IP -> m IP Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IP -> m IP Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IP -> m IP Source #

Ord IP Source #
Instance details

Defined in Data.IP.Addr

Read IP Source #
Instance details

Defined in Data.IP.Addr

Show IP Source #
Instance details

Defined in Data.IP.Addr

IsString IP Source #
Instance details

Defined in Data.IP.Addr

Generic IP Source #
Instance details

Defined in Data.IP.Addr

Associated Types

type Rep IP :: Type -> Type Source #

type Rep IP Source #
Instance details

Defined in Data.IP.Addr

IPv4

data IPv4 Source #

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

Instances details
Bounded IPv4 Source #
Instance details

Defined in Data.IP.Addr

Enum IPv4 Source #
Instance details

Defined in Data.IP.Addr

Eq IPv4 Source #
Instance details

Defined in Data.IP.Addr

Data IPv4 Source #
Instance details

Defined in Data.IP.Addr

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IPv4 -> c IPv4 Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c IPv4 Source #

toConstr :: IPv4 -> Constr Source #

dataTypeOf :: IPv4 -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c IPv4 ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c IPv4 ) Source #

gmapT :: ( forall b. Data b => b -> b) -> IPv4 -> IPv4 Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IPv4 -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IPv4 -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> IPv4 -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> IPv4 -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IPv4 -> m IPv4 Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPv4 -> m IPv4 Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPv4 -> m IPv4 Source #

Ord IPv4 Source #
Instance details

Defined in Data.IP.Addr

Read IPv4 Source #
Instance details

Defined in Data.IP.Addr

Show IPv4 Source #
Instance details

Defined in Data.IP.Addr

IsString IPv4 Source #
Instance details

Defined in Data.IP.Addr

Generic IPv4 Source #
Instance details

Defined in Data.IP.Addr

Associated Types

type Rep IPv4 :: Type -> Type Source #

Addr IPv4 Source #
Instance details

Defined in Data.IP.Op

Routable IPv4 Source #
Instance details

Defined in Data.IP.RouteTable.Internal

Read ( AddrRange IPv4 ) Source #
Instance details

Defined in Data.IP.Range

IsString ( AddrRange IPv4 ) Source #
Instance details

Defined in Data.IP.Range

type Rep IPv4 Source #
Instance details

Defined in Data.IP.Addr

toIPv4 :: [ Int ] -> IPv4 Source #

The toIPv4 function returns the IPv4 address corresponding to the given list of Int octets. The function is strict in the four elements of the list. An error is returned if the list has a differnet length. The input elements are silently truncated to their 8 least-significant bits before they are combined to form the IPv4 address.

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

toIPv4w :: Word32 -> IPv4 Source #

The toIPv4w function constructs the IPv4 address corresponding to the given Word32 value. Unlike the fromHostAddress function, it is strict in the input value, which here is in host byte order.

>>> toIPv4w 0xc0000201
192.0.2.1

Since: 1.7.9

fromIPv4 :: IPv4 -> [ Int ] Source #

The fromIPv4 function returns the list of four Int octets corresponding to the given IPv4 address.

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

fromIPv4w :: IPv4 -> Word32 Source #

The fromIPv4w function returns a single Word32 value corresponding to the given the IPv4 address. Unlike the toHostAddress function, the returned value is strictly evaluated, and is not converted to network byte order.

>>> fromIPv4w (toIPv4 [0xc0,0,2,1]) == 0xc0000201
True

Since: 1.7.9

IPv6

data IPv6 Source #

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

Instances details
Bounded IPv6 Source #
Instance details

Defined in Data.IP.Addr

Enum IPv6 Source #
Instance details

Defined in Data.IP.Addr

Eq IPv6 Source #
Instance details

Defined in Data.IP.Addr

Data IPv6 Source #
Instance details

Defined in Data.IP.Addr

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IPv6 -> c IPv6 Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c IPv6 Source #

toConstr :: IPv6 -> Constr Source #

dataTypeOf :: IPv6 -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c IPv6 ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c IPv6 ) Source #

gmapT :: ( forall b. Data b => b -> b) -> IPv6 -> IPv6 Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IPv6 -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IPv6 -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> IPv6 -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> IPv6 -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IPv6 -> m IPv6 Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPv6 -> m IPv6 Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPv6 -> m IPv6 Source #

Ord IPv6 Source #
Instance details

Defined in Data.IP.Addr

Read IPv6 Source #
Instance details

Defined in Data.IP.Addr

Show IPv6 Source #
Instance details

Defined in Data.IP.Addr

IsString IPv6 Source #
Instance details

Defined in Data.IP.Addr

Generic IPv6 Source #
Instance details

Defined in Data.IP.Addr

Associated Types

type Rep IPv6 :: Type -> Type Source #

Addr IPv6 Source #
Instance details

Defined in Data.IP.Op

Routable IPv6 Source #
Instance details

Defined in Data.IP.RouteTable.Internal

Read ( AddrRange IPv6 ) Source #
Instance details

Defined in Data.IP.Range

IsString ( AddrRange IPv6 ) Source #
Instance details

Defined in Data.IP.Range

type Rep IPv6 Source #
Instance details

Defined in Data.IP.Addr

toIPv6 :: [ Int ] -> IPv6 Source #

The toIPv6 function returns the IPv6 address corresponding to the given list of eight 16-bit Int s. The function is strict in the eight elements of the list. An error is returned if the list has a differnet length. The input elements are in host byte order and are silently truncated to their 16 least-signicant bits before they are combined to form the IPv6 address.

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

toIPv6b :: [ Int ] -> IPv6 Source #

The toIPv6b function returns the IPv6 address corresponding to the given list of sixteen Int octets. The function is strict in the sixteen elements of the list. An error is returned if the list has a differnet length. The input elements are silently truncated to their 8 least-signicant bits before they are combined to form the IPv6 address.

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

toIPv6w :: ( Word32 , Word32 , Word32 , Word32 ) -> IPv6 Source #

The toIPv6w function constructs the IPv6 address corresponding to the given four-tuple of host byte order Word32 values. This function differs from the fromHostAddress6 function only in the fact that it is strict in the elements of the tuple.

>>> toIPv6w (0x20010DB8,0x0,0x0,0x1)
2001:db8::1

Since: 1.7.9

fromIPv6 :: IPv6 -> [ Int ] Source #

The fromIPv6 function returns a list eight Int s in host byte order corresponding to the eight 16-bit fragments of the given IPv6 address.

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

fromIPv6b :: IPv6 -> [ Int ] Source #

The fromIPv6b function returns the 16 Int octets corresponding to the 16 bytes of the given IPv6 address.

>>> 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]

fromIPv6w :: IPv6 -> ( Word32 , Word32 , Word32 , Word32 ) Source #

The fromIPv6w function returns a four-tuple of Word32 values in host byte order corresponding to the given IPv6 address. This is identical to the toHostAddress6 function, except that the elements of four-tuple are first strictly evaluated.

>>> fromIPv6w (toIPv6 [0x2001,0xDB8,0,0,0,0,0,1]) == (0x20010DB8, 0, 0, 1)
True

Since: 1.7.9

Converters

ipv4ToIPv6 :: IPv4 -> IPv6 Source #

Convert IPv4 address to IPv4-embedded-in-IPv6

IP range data

data IPRange Source #

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

Instances

Instances details
Eq IPRange Source #
Instance details

Defined in Data.IP.Range

Data IPRange Source #
Instance details

Defined in Data.IP.Range

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> IPRange -> c IPRange Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c IPRange Source #

toConstr :: IPRange -> Constr Source #

dataTypeOf :: IPRange -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c IPRange ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c IPRange ) Source #

gmapT :: ( forall b. Data b => b -> b) -> IPRange -> IPRange Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IPRange -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IPRange -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> IPRange -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> IPRange -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IPRange -> m IPRange Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPRange -> m IPRange Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPRange -> m IPRange Source #

Ord IPRange Source #
Instance details

Defined in Data.IP.Range

Read IPRange Source #
Instance details

Defined in Data.IP.Range

Show IPRange Source #
Instance details

Defined in Data.IP.Range

IsString IPRange Source #
Instance details

Defined in Data.IP.Range

Generic IPRange Source #
Instance details

Defined in Data.IP.Range

type Rep IPRange Source #
Instance details

Defined in Data.IP.Range

data AddrRange a Source #

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

Instances details
Eq a => Eq ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

Data a => Data ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> AddrRange a -> c ( AddrRange a) Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( AddrRange a) Source #

toConstr :: AddrRange a -> Constr Source #

dataTypeOf :: AddrRange a -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( AddrRange a)) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( AddrRange a)) Source #

gmapT :: ( forall b. Data b => b -> b) -> AddrRange a -> AddrRange a Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> AddrRange a -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> AddrRange a -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> AddrRange a -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> AddrRange a -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> AddrRange a -> m ( AddrRange a) Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> AddrRange a -> m ( AddrRange a) Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> AddrRange a -> m ( AddrRange a) Source #

Ord a => Ord ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

Read ( AddrRange IPv6 ) Source #
Instance details

Defined in Data.IP.Range

Read ( AddrRange IPv4 ) Source #
Instance details

Defined in Data.IP.Range

Show a => Show ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

IsString ( AddrRange IPv6 ) Source #
Instance details

Defined in Data.IP.Range

IsString ( AddrRange IPv4 ) Source #
Instance details

Defined in Data.IP.Range

Generic ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

Associated Types

type Rep ( AddrRange a) :: Type -> Type Source #

type Rep ( AddrRange a) Source #
Instance details

Defined in Data.IP.Range

Address class

class Eq a => Addr a where Source #

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

Methods

masked :: a -> a -> a Source #

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

intToMask :: Int -> a Source #

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

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

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 Source #

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 Source #

The isMatchedTo 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 ) Source #

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 Source #

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