{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}

module Data.IP.Addr where

import Control.Monad
import Data.Bits
import Data.Char
import Data.Data (Data)
import Data.List (foldl', intersperse)
import Data.String
import Data.Typeable (Typeable)
import Data.Word
import Network.Socket
import Numeric (showHex, showInt)
import System.ByteOrder
import Text.Appar.String
import GHC.Enum (succError,predError)
import GHC.Generics

----------------------------------------------------------------

{-|
  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
-}

data IP = IPv4 { IP -> IPv4
ipv4 :: IPv4 }
        | IPv6 { IP -> IPv6
ipv6 :: IPv6 }
        deriving (Typeable IP
IP -> Constr
IP -> DataType
(forall b. Data b => b -> b) -> IP -> IP
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IP -> u
forall u. (forall d. Data d => d -> u) -> IP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IP -> m IP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IP -> m IP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IP -> c IP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IP)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IP -> m IP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IP -> m IP
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IP -> m IP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IP -> m IP
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IP -> m IP
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IP -> m IP
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IP -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IP -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> IP -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IP -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IP -> r
gmapT :: (forall b. Data b => b -> b) -> IP -> IP
$cgmapT :: (forall b. Data b => b -> b) -> IP -> IP
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IP)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IP)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IP)
dataTypeOf :: IP -> DataType
$cdataTypeOf :: IP -> DataType
toConstr :: IP -> Constr
$ctoConstr :: IP -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IP
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IP -> c IP
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IP -> c IP
Data,forall x. Rep IP x -> IP
forall x. IP -> Rep IP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IP x -> IP
$cfrom :: forall x. IP -> Rep IP x
Generic,Typeable)

{-|
  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 Eq IP where
  (IPv4 IPv4
ip1) == :: IP -> IP -> Bool
== (IPv4 IPv4
ip2) = IPv4
ip1 forall a. Eq a => a -> a -> Bool
== IPv4
ip2
  (IPv6 IPv6
ip1) == (IPv6 IPv6
ip2) = IPv6
ip1 forall a. Eq a => a -> a -> Bool
== IPv6
ip2
  (IPv4 IPv4
ip1) == (IPv6 IPv6
ip2) = IPv4 -> IPv6
ipv4ToIPv6 IPv4
ip1 forall a. Eq a => a -> a -> Bool
== IPv6
ip2
  (IPv6 IPv6
ip1) == (IPv4 IPv4
ip2) = IPv6
ip1 forall a. Eq a => a -> a -> Bool
== IPv4 -> IPv6
ipv4ToIPv6 IPv4
ip2


instance Ord IP where
  (IPv4 IPv4
ip1) compare :: IP -> IP -> Ordering
`compare` (IPv4 IPv4
ip2) = IPv4
ip1 forall a. Ord a => a -> a -> Ordering
`compare` IPv4
ip2
  (IPv6 IPv6
ip1) `compare` (IPv6 IPv6
ip2) = IPv6
ip1 forall a. Ord a => a -> a -> Ordering
`compare` IPv6
ip2
  (IPv4 IPv4
ip1) `compare` (IPv6 IPv6
ip2) = IPv4 -> IPv6
ipv4ToIPv6 IPv4
ip1 forall a. Ord a => a -> a -> Ordering
`compare` IPv6
ip2
  (IPv6 IPv6
ip1) `compare` (IPv4 IPv4
ip2) = IPv6
ip1 forall a. Ord a => a -> a -> Ordering
`compare` IPv4 -> IPv6
ipv4ToIPv6 IPv4
ip2

instance Show IP where
    show :: IP -> String
show (IPv4 IPv4
ip) = forall a. Show a => a -> String
show IPv4
ip
    show (IPv6 IPv6
ip) = forall a. Show a => a -> String
show IPv6
ip

----------------------------------------------------------------

-- This is host byte order
type IPv4Addr = Word32
type IPv6Addr = (Word32,Word32,Word32,Word32)

{-|
  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
-}
newtype IPv4 = IP4 IPv4Addr
  deriving (IPv4 -> IPv4 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IPv4 -> IPv4 -> Bool
$c/= :: IPv4 -> IPv4 -> Bool
== :: IPv4 -> IPv4 -> Bool
$c== :: IPv4 -> IPv4 -> Bool
Eq, Eq IPv4
IPv4 -> IPv4 -> Bool
IPv4 -> IPv4 -> Ordering
IPv4 -> IPv4 -> IPv4
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
min :: IPv4 -> IPv4 -> IPv4
$cmin :: IPv4 -> IPv4 -> IPv4
max :: IPv4 -> IPv4 -> IPv4
$cmax :: IPv4 -> IPv4 -> IPv4
>= :: IPv4 -> IPv4 -> Bool
$c>= :: IPv4 -> IPv4 -> Bool
> :: IPv4 -> IPv4 -> Bool
$c> :: IPv4 -> IPv4 -> Bool
<= :: IPv4 -> IPv4 -> Bool
$c<= :: IPv4 -> IPv4 -> Bool
< :: IPv4 -> IPv4 -> Bool
$c< :: IPv4 -> IPv4 -> Bool
compare :: IPv4 -> IPv4 -> Ordering
$ccompare :: IPv4 -> IPv4 -> Ordering
Ord, IPv4
forall a. a -> a -> Bounded a
maxBound :: IPv4
$cmaxBound :: IPv4
minBound :: IPv4
$cminBound :: IPv4
Bounded, Typeable IPv4
IPv4 -> Constr
IPv4 -> DataType
(forall b. Data b => b -> b) -> IPv4 -> IPv4
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IPv4 -> u
forall u. (forall d. Data d => d -> u) -> IPv4 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv4
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv4 -> c IPv4
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv4)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv4)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv4 -> m IPv4
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPv4 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPv4 -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> IPv4 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IPv4 -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv4 -> r
gmapT :: (forall b. Data b => b -> b) -> IPv4 -> IPv4
$cgmapT :: (forall b. Data b => b -> b) -> IPv4 -> IPv4
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv4)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv4)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv4)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv4)
dataTypeOf :: IPv4 -> DataType
$cdataTypeOf :: IPv4 -> DataType
toConstr :: IPv4 -> Constr
$ctoConstr :: IPv4 -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv4
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv4
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv4 -> c IPv4
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv4 -> c IPv4
Data, forall x. Rep IPv4 x -> IPv4
forall x. IPv4 -> Rep IPv4 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IPv4 x -> IPv4
$cfrom :: forall x. IPv4 -> Rep IPv4 x
Generic, Typeable)

{-|
  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
-}
newtype IPv6 = IP6 IPv6Addr
  deriving (IPv6 -> IPv6 -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IPv6 -> IPv6 -> Bool
$c/= :: IPv6 -> IPv6 -> Bool
== :: IPv6 -> IPv6 -> Bool
$c== :: IPv6 -> IPv6 -> Bool
Eq, Eq IPv6
IPv6 -> IPv6 -> Bool
IPv6 -> IPv6 -> Ordering
IPv6 -> IPv6 -> IPv6
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
min :: IPv6 -> IPv6 -> IPv6
$cmin :: IPv6 -> IPv6 -> IPv6
max :: IPv6 -> IPv6 -> IPv6
$cmax :: IPv6 -> IPv6 -> IPv6
>= :: IPv6 -> IPv6 -> Bool
$c>= :: IPv6 -> IPv6 -> Bool
> :: IPv6 -> IPv6 -> Bool
$c> :: IPv6 -> IPv6 -> Bool
<= :: IPv6 -> IPv6 -> Bool
$c<= :: IPv6 -> IPv6 -> Bool
< :: IPv6 -> IPv6 -> Bool
$c< :: IPv6 -> IPv6 -> Bool
compare :: IPv6 -> IPv6 -> Ordering
$ccompare :: IPv6 -> IPv6 -> Ordering
Ord, IPv6
forall a. a -> a -> Bounded a
maxBound :: IPv6
$cmaxBound :: IPv6
minBound :: IPv6
$cminBound :: IPv6
Bounded, Typeable IPv6
IPv6 -> Constr
IPv6 -> DataType
(forall b. Data b => b -> b) -> IPv6 -> IPv6
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IPv6 -> u
forall u. (forall d. Data d => d -> u) -> IPv6 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv6
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv6 -> c IPv6
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv6)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv6)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IPv6 -> m IPv6
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPv6 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPv6 -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> IPv6 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IPv6 -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPv6 -> r
gmapT :: (forall b. Data b => b -> b) -> IPv6 -> IPv6
$cgmapT :: (forall b. Data b => b -> b) -> IPv6 -> IPv6
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv6)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IPv6)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv6)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IPv6)
dataTypeOf :: IPv6 -> DataType
$cdataTypeOf :: IPv6 -> DataType
toConstr :: IPv6 -> Constr
$ctoConstr :: IPv6 -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv6
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IPv6
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv6 -> c IPv6
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IPv6 -> c IPv6
Data, forall x. Rep IPv6 x -> IPv6
forall x. IPv6 -> Rep IPv6 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IPv6 x -> IPv6
$cfrom :: forall x. IPv6 -> Rep IPv6 x
Generic, Typeable)


----------------------------------------------------------------
--
-- Enum
--

instance Enum IPv4 where
    fromEnum :: IPv4 -> Int
fromEnum (IP4 Word32
a) = forall a. Enum a => a -> Int
fromEnum Word32
a
    toEnum :: Int -> IPv4
toEnum = Word32 -> IPv4
IP4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => Int -> a
toEnum

instance Enum IPv6 where
    -- fromEnum and toEnum are not really useful, but I defined them anyway
    fromEnum :: IPv6 -> Int
fromEnum (IP6 (Word32
a,Word32
b,Word32
c,Word32
d)) = let a' :: Int
a' = forall a. Enum a => a -> Int
fromEnum Word32
a forall a. Bits a => a -> Int -> a
`shift` Int
96
                                   b' :: Int
b' = forall a. Enum a => a -> Int
fromEnum Word32
b forall a. Bits a => a -> Int -> a
`shift` Int
64
                                   c' :: Int
c' = forall a. Enum a => a -> Int
fromEnum Word32
c forall a. Bits a => a -> Int -> a
`shift` Int
32
                                   d' :: Int
d' = forall a. Enum a => a -> Int
fromEnum Word32
d
                               in Int
a' forall a. Bits a => a -> a -> a
.|. Int
b' forall a. Bits a => a -> a -> a
.|. Int
c' forall a. Bits a => a -> a -> a
.|. Int
d'
    toEnum :: Int -> IPv6
toEnum Int
i = let i' :: Integer
i' = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i :: Integer
                   a :: Word32
a = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i' forall a. Bits a => a -> Int -> a
`shiftR` Int
96 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                   b :: Word32
b = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i' forall a. Bits a => a -> Int -> a
`shiftR` Int
64 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                   c :: Word32
c = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i' forall a. Bits a => a -> Int -> a
`shiftR` Int
32 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                   d :: Word32
d = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i'             forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
               in IPv6Addr -> IPv6
IP6 (Word32
a,Word32
b,Word32
c,Word32
d)

    succ :: IPv6 -> IPv6
succ (IP6 (Word32
0xffffffff,Word32
0xffffffff,Word32
0xffffffff,Word32
0xffffffff)) = forall a. String -> a
succError String
"IPv6"
    succ (IP6 (Word32
a,         Word32
0xffffffff,Word32
0xffffffff,Word32
0xffffffff)) = IPv6Addr -> IPv6
IP6 (forall a. Enum a => a -> a
succ Word32
a,Word32
0,Word32
0,Word32
0)
    succ (IP6 (Word32
a,                  Word32
b,Word32
0xffffffff,Word32
0xffffffff)) = IPv6Addr -> IPv6
IP6 (Word32
a,forall a. Enum a => a -> a
succ Word32
b,Word32
0,Word32
0)
    succ (IP6 (Word32
a,                  Word32
b,         Word32
c,Word32
0xffffffff)) = IPv6Addr -> IPv6
IP6 (Word32
a,Word32
b,forall a. Enum a => a -> a
succ Word32
c,Word32
0)
    succ (IP6 (Word32
a,                  Word32
b,         Word32
c,         Word32
d)) = IPv6Addr -> IPv6
IP6 (Word32
a,Word32
b,Word32
c,forall a. Enum a => a -> a
succ Word32
d)

    pred :: IPv6 -> IPv6
pred (IP6 (Word32
0,Word32
0,Word32
0,Word32
0)) = forall a. String -> a
predError String
"IPv6"
    pred (IP6 (Word32
a,Word32
0,Word32
0,Word32
0)) = IPv6Addr -> IPv6
IP6 (forall a. Enum a => a -> a
pred Word32
a, Word32
0xffffffff, Word32
0xffffffff, Word32
0xffffffff)
    pred (IP6 (Word32
a,Word32
b,Word32
0,Word32
0)) = IPv6Addr -> IPv6
IP6 (     Word32
a,     forall a. Enum a => a -> a
pred Word32
b, Word32
0xffffffff, Word32
0xffffffff)
    pred (IP6 (Word32
a,Word32
b,Word32
c,Word32
0)) = IPv6Addr -> IPv6
IP6 (     Word32
a,          Word32
b,     forall a. Enum a => a -> a
pred Word32
c, Word32
0xffffffff)
    pred (IP6 (Word32
a,Word32
b,Word32
c,Word32
d)) = IPv6Addr -> IPv6
IP6 (     Word32
a,          Word32
b,          Word32
c,     forall a. Enum a => a -> a
pred Word32
d)

    enumFrom :: IPv6 -> [IPv6]
enumFrom IPv6
ip = IPv6
ipforall a. a -> [a] -> [a]
:forall {t}. Enum t => t -> [t]
gen IPv6
ip
        where gen :: t -> [t]
gen t
i = let i' :: t
i' = forall a. Enum a => a -> a
succ t
i in t
i'forall a. a -> [a] -> [a]
:t -> [t]
gen t
i'

    enumFromTo :: IPv6 -> IPv6 -> [IPv6]
enumFromTo IPv6
ip IPv6
ip' = IPv6
ipforall a. a -> [a] -> [a]
:IPv6 -> [IPv6]
gen IPv6
ip
        where gen :: IPv6 -> [IPv6]
gen IPv6
i
                | IPv6
i forall a. Eq a => a -> a -> Bool
== IPv6
ip' = []
                | Bool
otherwise = let i' :: IPv6
i' = forall a. Enum a => a -> a
succ IPv6
i in IPv6
i'forall a. a -> [a] -> [a]
:IPv6 -> [IPv6]
gen IPv6
i'

    -- These two are implemented via the integer enum instance.
    -- A more correct implementation would essentially require
    -- implementing instance Num IPv6, which isn't something
    -- I wanna do. Another approach is to use Word128 to store
    -- an IPv6 address.
    enumFromThen :: IPv6 -> IPv6 -> [IPv6]
enumFromThen IPv6
ip IPv6
ip' = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> IPv6
integerToIP6 [IPv6 -> Integer
ip6ToInteger IPv6
ip, IPv6 -> Integer
ip6ToInteger IPv6
ip' ..]
    enumFromThenTo :: IPv6 -> IPv6 -> IPv6 -> [IPv6]
enumFromThenTo IPv6
ip IPv6
inc IPv6
fin = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> IPv6
integerToIP6 [IPv6 -> Integer
ip6ToInteger IPv6
ip, IPv6 -> Integer
ip6ToInteger IPv6
inc .. IPv6 -> Integer
ip6ToInteger IPv6
fin]

instance Enum IP where
    fromEnum :: IP -> Int
fromEnum (IPv4 IPv4
ip) = forall a. Enum a => a -> Int
fromEnum IPv4
ip
    fromEnum (IPv6 IPv6
ip) = forall a. Enum a => a -> Int
fromEnum IPv6
ip

    -- Because Int cannot hold an IPv6 anyway
    toEnum :: Int -> IP
toEnum = IPv4 -> IP
IPv4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => Int -> a
toEnum

    succ :: IP -> IP
succ (IPv4 IPv4
ip) = IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a
succ IPv4
ip
    succ (IPv6 IPv6
ip) = IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a
succ IPv6
ip

    pred :: IP -> IP
pred (IPv4 IPv4
ip) = IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a
pred IPv4
ip
    pred (IPv6 IPv6
ip) = IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a
pred IPv6
ip

    enumFrom :: IP -> [IP]
enumFrom (IPv4 IPv4
ip) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall {t}. Enum t => t -> [t]
enumFrom IPv4
ip
    enumFrom (IPv6 IPv6
ip) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall {t}. Enum t => t -> [t]
enumFrom IPv6
ip

    enumFromTo :: IP -> IP -> [IP]
enumFromTo (IPv4 IPv4
ip) (IPv4 IPv4
ip') = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> [a]
enumFromTo IPv4
ip IPv4
ip'
    enumFromTo (IPv6 IPv6
ip) (IPv6 IPv6
ip') = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> [a]
enumFromTo IPv6
ip IPv6
ip'
    enumFromTo IP
_ IP
_ = forall a. HasCallStack => String -> a
error String
"enumFromTo: Incompatible IP families"

    enumFromThen :: IP -> IP -> [IP]
enumFromThen (IPv4 IPv4
ip) (IPv4 IPv4
ip') = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> [a]
enumFromThen IPv4
ip IPv4
ip'
    enumFromThen (IPv6 IPv6
ip) (IPv6 IPv6
ip') = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> [a]
enumFromThen IPv6
ip IPv6
ip'
    enumFromThen IP
_ IP
_ = forall a. HasCallStack => String -> a
error String
"enumFromThen: Incompatible IP families"

    enumFromThenTo :: IP -> IP -> IP -> [IP]
enumFromThenTo (IPv4 IPv4
ip) (IPv4 IPv4
inc) (IPv4 IPv4
fin) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv4 -> IP
IPv4 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo IPv4
ip IPv4
inc IPv4
fin
    enumFromThenTo (IPv6 IPv6
ip) (IPv6 IPv6
inc) (IPv6 IPv6
fin) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap IPv6 -> IP
IPv6 forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo IPv6
ip IPv6
inc IPv6
fin
    enumFromThenTo IP
_ IP
_ IP
_ = forall a. HasCallStack => String -> a
error String
"enumFromThenTo: Incompatible IP families"

ip6ToInteger :: IPv6 -> Integer
ip6ToInteger :: IPv6 -> Integer
ip6ToInteger (IP6 (Word32
a,Word32
b,Word32
c,Word32
d)) = let a' :: Integer
a' = Word32 -> Integer
word32ToInteger Word32
a forall a. Bits a => a -> Int -> a
`shift` Int
96
                                   b' :: Integer
b' = Word32 -> Integer
word32ToInteger Word32
b forall a. Bits a => a -> Int -> a
`shift` Int
64
                                   c' :: Integer
c' = Word32 -> Integer
word32ToInteger Word32
c forall a. Bits a => a -> Int -> a
`shift` Int
32
                                   d' :: Integer
d' = Word32 -> Integer
word32ToInteger Word32
d
                               in Integer
a' forall a. Bits a => a -> a -> a
.|. Integer
b' forall a. Bits a => a -> a -> a
.|. Integer
c' forall a. Bits a => a -> a -> a
.|. Integer
d'
    where
        word32ToInteger :: Word32 -> Integer
        word32ToInteger :: Word32 -> Integer
word32ToInteger = forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum

integerToIP6 :: Integer -> IPv6
integerToIP6 :: Integer -> IPv6
integerToIP6 Integer
i = let a :: Word32
a = Integer -> Word32
integerToWord32 (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
96 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                     b :: Word32
b = Integer -> Word32
integerToWord32 (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
64 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                     c :: Word32
c = Integer -> Word32
integerToWord32 (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
32 forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                     d :: Word32
d = Integer -> Word32
integerToWord32 (Integer
i             forall a. Bits a => a -> a -> a
.&. Integer
0xffffffff)
                 in IPv6Addr -> IPv6
IP6 (Word32
a,Word32
b,Word32
c,Word32
d)
    where
        integerToWord32 :: Integer -> Word32
        integerToWord32 :: Integer -> Word32
integerToWord32 = forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum

----------------------------------------------------------------
--
-- Show
--

instance Show IPv4 where
    show :: IPv4 -> String
show IPv4
ip = IPv4 -> ShowS
showIPv4 IPv4
ip String
""

instance Show IPv6 where
    show :: IPv6 -> String
show IPv6
ip = IPv6 -> ShowS
showIPv6 IPv6
ip String
""

-- | Show an IPv4 address in the dot-decimal notation.
showIPv4 :: IPv4 -> ShowS
showIPv4 :: IPv4 -> ShowS
showIPv4 = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
intersperse (Char -> ShowS
showChar Char
'.') forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. Integral a => a -> ShowS
showInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. IPv4 -> [Int]
fromIPv4

-- | Show an IPv6 address in the most appropriate notation, based on recommended
-- representation proposed by <http://tools.ietf.org/html/rfc5952 RFC 5952>.
--
-- /The implementation is completely compatible with the current implementation
-- of the `inet_ntop` function in glibc./
showIPv6 :: IPv6 -> ShowS
showIPv6 :: IPv6 -> ShowS
showIPv6 ip :: IPv6
ip@(IP6 (Word32
a1,Word32
a2,Word32
a3,Word32
a4))
  -- IPv4-Mapped IPv6 Address
  | Word32
a1 forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
a2 forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
a3 forall a. Eq a => a -> a -> Bool
== Word32
0xffff =
      String -> ShowS
showString String
"::ffff:" forall b c a. (b -> c) -> (a -> b) -> a -> c
. IPv4 -> ShowS
showIPv4 (Word32 -> IPv4
IP4 Word32
a4)
  -- IPv4-Compatible IPv6 Address (exclude IPRange ::/112)
  | Word32
a1 forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
a2 forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
a3 forall a. Eq a => a -> a -> Bool
== Word32
0 Bool -> Bool -> Bool
&& Word32
a4 forall a. Ord a => a -> a -> Bool
>= Word32
0x10000 =
      String -> ShowS
showString String
"::" forall b c a. (b -> c) -> (a -> b) -> a -> c
. IPv4 -> ShowS
showIPv4 (Word32 -> IPv4
IP4 Word32
a4)
  -- length of longest run > 1, replace it with "::"
  | Int
end forall a. Num a => a -> a -> a
- Int
begin forall a. Ord a => a -> a -> Bool
> Int
1 =
      [Int] -> ShowS
showFields [Int]
prefix forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
"::" forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> ShowS
showFields [Int]
suffix
  -- length of longest run <= 1, don't use "::"
  | Bool
otherwise =
      [Int] -> ShowS
showFields [Int]
fields
  where
    fields :: [Int]
fields = IPv6 -> [Int]
fromIPv6 IPv6
ip
    showFields :: [Int] -> ShowS
showFields = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
intersperse (Char -> ShowS
showChar Char
':') forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. (Integral a, Show a) => a -> ShowS
showHex
    prefix :: [Int]
prefix = forall a. Int -> [a] -> [a]
take Int
begin [Int]
fields  -- fields before "::"
    suffix :: [Int]
suffix = forall a. Int -> [a] -> [a]
drop Int
end [Int]
fields    -- fields after "::"
    begin :: Int
begin = Int
end forall a. Num a => a -> a -> a
+ Int
diff          -- the longest run of zeros
    (Int
diff, Int
end) = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum forall a b. (a -> b) -> a -> b
$
        forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl (\Int
c Int
i -> if Int
i forall a. Eq a => a -> a -> Bool
== Int
0 then Int
c forall a. Num a => a -> a -> a
- Int
1 else Int
0) Int
0 [Int]
fields forall a b. [a] -> [b] -> [(a, b)]
`zip` [Int
0..]

----------------------------------------------------------------
--
-- IntToIP
--

{-|
  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
-}
toIPv4 :: [Int] -> IPv4
toIPv4 :: [Int] -> IPv4
toIPv4 [Int
a1, Int
a2, Int
a3, Int
a4] = Word32 -> IPv4
IP4 Word32
w
  where
    w :: Word32
w = (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24 forall a. Bits a => a -> a -> a
.|.
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a2 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|.
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a3 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8 forall a. Bits a => a -> a -> a
.|.
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a4 forall a. Bits a => a -> a -> a
.&. Word32
0xff)
toIPv4 [Int]
_ = forall a. HasCallStack => String -> a
error String
"IPv4 field list length != 4"
{-# INLINE toIPv4 #-}

{-|
  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
-}
toIPv4w :: Word32 -> IPv4
toIPv4w :: Word32 -> IPv4
toIPv4w Word32
w = Word32 -> IPv4
IP4 Word32
w
{-# INLINE toIPv4w #-}

{-|
  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
-}
toIPv6 :: [Int] -> IPv6
toIPv6 :: [Int] -> IPv6
toIPv6 [Int
i1,Int
i2,Int
i3,Int
i4,Int
i5,Int
i6,Int
i7,Int
i8] = IPv6Addr -> IPv6
IP6 (Word32
x1,Word32
x2,Word32
x3,Word32
x4)
  where
    !x1 :: Word32
x1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
i1 forall a. Bits a => a -> a -> a
.&. Int
0xffff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|. (Int
i2 forall a. Bits a => a -> a -> a
.&. Int
0xffff)
    !x2 :: Word32
x2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
i3 forall a. Bits a => a -> a -> a
.&. Int
0xffff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|. (Int
i4 forall a. Bits a => a -> a -> a
.&. Int
0xffff)
    !x3 :: Word32
x3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
i5 forall a. Bits a => a -> a -> a
.&. Int
0xffff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|. (Int
i6 forall a. Bits a => a -> a -> a
.&. Int
0xffff)
    !x4 :: Word32
x4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
i7 forall a. Bits a => a -> a -> a
.&. Int
0xffff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|. (Int
i8 forall a. Bits a => a -> a -> a
.&. Int
0xffff)
toIPv6 [Int]
_ = forall a. HasCallStack => String -> a
error String
"toIPv6 field list length != 8"
{-# INLINE toIPv6 #-}

{-|
  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
-}
toIPv6b :: [Int] -> IPv6
toIPv6b :: [Int] -> IPv6
toIPv6b [ Int
h11, Int
h12, Int
l11, Int
l12, Int
h21, Int
h22, Int
l21, Int
l22
        , Int
h31, Int
h32, Int
l31, Int
l32, Int
h41, Int
h42, Int
l41, Int
l42 ] = IPv6Addr -> IPv6
IP6 (Word32
x1,Word32
x2,Word32
x3,Word32
x4)
  where
    !x1 :: Word32
x1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
h11 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24 forall a. Bits a => a -> a -> a
.|.
                         (Int
h12 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|.
                         (Int
l11 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8 forall a. Bits a => a -> a -> a
.|.
                         (Int
l12 forall a. Bits a => a -> a -> a
.&. Int
0xff)
    !x2 :: Word32
x2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
h21 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24 forall a. Bits a => a -> a -> a
.|.
                         (Int
h22 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|.
                         (Int
l21 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8 forall a. Bits a => a -> a -> a
.|.
                         (Int
l22 forall a. Bits a => a -> a -> a
.&. Int
0xff)
    !x3 :: Word32
x3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
h31 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24 forall a. Bits a => a -> a -> a
.|.
                         (Int
h32 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|.
                         (Int
l31 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8 forall a. Bits a => a -> a -> a
.|.
                         (Int
l32 forall a. Bits a => a -> a -> a
.&. Int
0xff)
    !x4 :: Word32
x4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ (Int
h41 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24 forall a. Bits a => a -> a -> a
.|.
                         (Int
h42 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16 forall a. Bits a => a -> a -> a
.|.
                         (Int
l41 forall a. Bits a => a -> a -> a
.&. Int
0xff) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8 forall a. Bits a => a -> a -> a
.|.
                         (Int
l42 forall a. Bits a => a -> a -> a
.&. Int
0xff)
toIPv6b [Int]
_ = forall a. HasCallStack => String -> a
error String
"toIPv6b field list length != 16"

{-|
  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
-}
toIPv6w :: (Word32, Word32, Word32, Word32) -> IPv6
toIPv6w :: IPv6Addr -> IPv6
toIPv6w w :: IPv6Addr
w@(!Word32
_, !Word32
_, !Word32
_, !Word32
_) = IPv6Addr -> IPv6
IP6 IPv6Addr
w
{-# INLINE toIPv6w #-}

----------------------------------------------------------------
--
-- IPToInt
--

{-|
  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]
-}
fromIPv4 :: IPv4 -> [Int]
fromIPv4 :: IPv4 -> [Int]
fromIPv4 (IP4 Word32
w) = Word32 -> Int -> Int
split Word32
w Int
0o30 forall a. a -> [a] -> [a]
: Word32 -> Int -> Int
split Word32
w Int
0o20 forall a. a -> [a] -> [a]
: Word32 -> Int -> Int
split Word32
w Int
0o10 forall a. a -> [a] -> [a]
: Word32 -> Int -> Int
split Word32
w Int
0 forall a. a -> [a] -> [a]
: []
  where
    split :: Word32 -> Int -> Int
    split :: Word32 -> Int -> Int
split Word32
a Int
n = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
n forall a. Bits a => a -> a -> a
.&. Word32
0xff
{-# INLINE fromIPv4 #-}

{-|
  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
-}
fromIPv4w :: IPv4 -> Word32
fromIPv4w :: IPv4 -> Word32
fromIPv4w (IP4 !Word32
ip4rep) = Word32
ip4rep
{-# INLINE fromIPv4w #-}

{-|
  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]
-}
fromIPv6 :: IPv6 -> [Int]
fromIPv6 :: IPv6 -> [Int]
fromIPv6 (IP6 (Word32
w1, Word32
w2, Word32
w3, Word32
w4)) =
    Word32 -> [Int] -> [Int]
split Word32
w1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w3 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w4 forall a b. (a -> b) -> a -> b
$ []
  where
    split :: Word32 -> [Int] -> [Int]
    split :: Word32 -> [Int] -> [Int]
split Word32
n [Int]
acc = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
0x10 forall a. Bits a => a -> a -> a
.&. Word32
0xffff) forall a. a -> [a] -> [a]
:
                  forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> a -> a
.&. Word32
0xffff) forall a. a -> [a] -> [a]
: [Int]
acc
{-# INLINE fromIPv6 #-}

{-|
  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]
-}
fromIPv6b :: IPv6 -> [Int]
fromIPv6b :: IPv6 -> [Int]
fromIPv6b (IP6 (Word32
w1, Word32
w2, Word32
w3, Word32
w4)) =
    Word32 -> [Int] -> [Int]
split Word32
w1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w3 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Int] -> [Int]
split Word32
w4 forall a b. (a -> b) -> a -> b
$ []
  where
    split :: Word32 -> [Int] -> [Int]
    split :: Word32 -> [Int] -> [Int]
split Word32
n [Int]
acc = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
24 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. a -> [a] -> [a]
:
                  forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
16 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. a -> [a] -> [a]
:
                  forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> Int -> a
`unsafeShiftR`  Int
8 forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. a -> [a] -> [a]
:
                  forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
n forall a. Bits a => a -> a -> a
.&. Word32
0xff) forall a. a -> [a] -> [a]
: [Int]
acc

{-|
  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
-}
fromIPv6w :: IPv6 -> (Word32, Word32, Word32, Word32)
fromIPv6w :: IPv6 -> IPv6Addr
fromIPv6w (IP6 IPv6Addr
ip6rep) = IPv6Addr
ip6rep
{-# INLINE fromIPv6w #-}

----------------------------------------------------------------
--
-- Read
--

instance Read IP where
    readsPrec :: Int -> ReadS IP
readsPrec Int
_ = ReadS IP
parseIP

instance Read IPv4 where
    readsPrec :: Int -> ReadS IPv4
readsPrec Int
_ = ReadS IPv4
parseIPv4

instance Read IPv6 where
    readsPrec :: Int -> ReadS IPv6
readsPrec Int
_ = ReadS IPv6
parseIPv6

parseIP :: String -> [(IP,String)]
parseIP :: ReadS IP
parseIP String
cs = case forall inp a. MkParser inp a -> inp -> (Maybe a, inp)
runParser Parser IPv4
ip4 String
cs of
    (Just IPv4
ip,String
rest) -> [(IPv4 -> IP
IPv4 IPv4
ip,String
rest)]
    (Maybe IPv4
Nothing,String
_) -> case forall inp a. MkParser inp a -> inp -> (Maybe a, inp)
runParser Parser IPv6
ip6 String
cs of
        (Just IPv6
ip,String
rest) -> [(IPv6 -> IP
IPv6 IPv6
ip,String
rest)]
        (Maybe IPv6
Nothing,String
_) -> []

parseIPv4 :: String -> [(IPv4,String)]
parseIPv4 :: ReadS IPv4
parseIPv4 String
cs = case forall inp a. MkParser inp a -> inp -> (Maybe a, inp)
runParser Parser IPv4
ip4 String
cs of
    (Maybe IPv4
Nothing,String
_)    -> []
    (Just IPv4
a4,String
rest) -> [(IPv4
a4,String
rest)]

parseIPv6 :: String -> [(IPv6,String)]
parseIPv6 :: ReadS IPv6
parseIPv6 String
cs = case forall inp a. MkParser inp a -> inp -> (Maybe a, inp)
runParser Parser IPv6
ip6 String
cs of
    (Maybe IPv6
Nothing,String
_)    -> []
    (Just IPv6
a6,String
rest) -> [(IPv6
a6,String
rest)]

----------------------------------------------------------------
--
-- IsString
--

instance IsString IP where
    fromString :: String -> IP
fromString = forall a. Read a => String -> a
read

instance IsString IPv4 where
    fromString :: String -> IPv4
fromString = forall a. Read a => String -> a
read

instance IsString IPv6 where
    fromString :: String -> IPv6
fromString = forall a. Read a => String -> a
read

----------------------------------------------------------------
--
-- IPv4 Parser
--

octet :: Parser Int
octet :: Parser Int
octet = Int
0 forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall inp. Input inp => Char -> MkParser inp Char
char Char
'0'
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall {m :: * -> *} {t :: * -> *}.
(MonadFail m, Foldable t) =>
t Char -> m Int
toInt forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall inp. Input inp => String -> MkParser inp Char
oneOf [Char
'1'..Char
'9'] forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall inp. Input inp => MkParser inp Char
digit)
  where
    toInt :: t Char -> m Int
toInt t Char
ds = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv4 address") forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall {a}. Char -> (Int -> Maybe a) -> Int -> Maybe a
go forall a. a -> Maybe a
Just t Char
ds Int
0
    go :: Char -> (Int -> Maybe a) -> Int -> Maybe a
go !Char
d !Int -> Maybe a
f !Int
n =
      let n' :: Int
n' = Int
n forall a. Num a => a -> a -> a
* Int
10 forall a. Num a => a -> a -> a
+ Char -> Int
ord Char
d forall a. Num a => a -> a -> a
- Int
48
      in  if Int
n' forall a. Ord a => a -> a -> Bool
<= Int
255 then Int -> Maybe a
f Int
n' else forall a. Maybe a
Nothing

ip4 :: Parser IPv4
ip4 :: Parser IPv4
ip4 = Parser ()
skipSpaces forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Int] -> IPv4
toIPv4 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Int]
ip4'

ip4' :: Parser [Int]
ip4' :: Parser [Int]
ip4' = do
    [Int]
as <- Parser Int
octet forall inp a b.
MkParser inp a -> MkParser inp b -> MkParser inp [a]
`sepBy1` forall inp. Input inp => Char -> MkParser inp Char
char Char
'.'
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
as forall a. Eq a => a -> a -> Bool
/= Int
4) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv4 address")
    forall (m :: * -> *) a. Monad m => a -> m a
return [Int]
as

skipSpaces :: Parser ()
skipSpaces :: Parser ()
skipSpaces = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall inp. Input inp => Char -> MkParser inp Char
char Char
' ')

----------------------------------------------------------------
--
-- IPv6 Parser (RFC 4291)
--

hex :: Parser Int
hex :: Parser Int
hex = do
    String
ns <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
some forall inp. Input inp => MkParser inp Char
hexDigit
    forall {f :: * -> *} {t :: * -> *} {a}.
(Foldable t, MonadFail f) =>
t a -> f ()
check String
ns
    let ms :: [Int]
ms = forall a b. (a -> b) -> [a] -> [b]
map Char -> Int
digitToInt String
ns
        val :: Int
val = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Int
x Int
y -> Int
x forall a. Num a => a -> a -> a
* Int
16 forall a. Num a => a -> a -> a
+ Int
y) Int
0 [Int]
ms
    forall (m :: * -> *) a. Monad m => a -> m a
return Int
val
  where
    check :: t a -> f ()
check t a
ns = forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
ns forall a. Ord a => a -> a -> Bool
> Int
4) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address -- more than 4 hex")

colon2 :: Parser ()
colon2 :: Parser ()
colon2 = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall inp. Input inp => String -> MkParser inp String
string String
"::"

format :: [Int] -> [Int] -> Parser [Int]
format :: [Int] -> [Int] -> Parser [Int]
format [Int]
bs1 [Int]
bs2 = do
    let len1 :: Int
len1 = forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
bs1
        len2 :: Int
len2 = forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
bs2
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
len1 forall a. Ord a => a -> a -> Bool
> Int
7) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address1")
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
len2 forall a. Ord a => a -> a -> Bool
> Int
7) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address2")
    let len :: Int
len = Int
8 forall a. Num a => a -> a -> a
- Int
len1 forall a. Num a => a -> a -> a
- Int
len2
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
len forall a. Ord a => a -> a -> Bool
<= Int
0) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address3")
    let spring :: [Int]
spring = forall a. Int -> a -> [a]
replicate Int
len Int
0
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Int]
bs1 forall a. [a] -> [a] -> [a]
++ [Int]
spring forall a. [a] -> [a] -> [a]
++ [Int]
bs2

ip6 :: Parser IPv6
ip6 :: Parser IPv6
ip6 = Parser ()
skipSpaces forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Int] -> IPv6
toIPv6 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Int]
ip6'

ip6' :: Parser [Int]
ip6' :: Parser [Int]
ip6' = Parser [Int]
ip4Embedded
   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do Parser ()
colon2
          [Int]
bs <- forall a inp. a -> MkParser inp a -> MkParser inp a
option [] Parser [Int]
hexcolon
          [Int] -> [Int] -> Parser [Int]
format [] [Int]
bs
   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall inp a. MkParser inp a -> MkParser inp a
try (do [Int]
rs <- Parser [Int]
hexcolon
               forall {f :: * -> *} {t :: * -> *} {a}.
(Foldable t, MonadFail f) =>
t a -> f ()
check [Int]
rs
               forall (m :: * -> *) a. Monad m => a -> m a
return [Int]
rs)
   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do [Int]
bs1 <- Parser [Int]
hexcolon2
          [Int]
bs2 <- forall a inp. a -> MkParser inp a -> MkParser inp a
option [] Parser [Int]
hexcolon
          [Int] -> [Int] -> Parser [Int]
format [Int]
bs1 [Int]
bs2
  where
    hexcolon :: Parser [Int]
hexcolon = Parser Int
hex forall inp a b.
MkParser inp a -> MkParser inp b -> MkParser inp [a]
`sepBy1` forall inp. Input inp => Char -> MkParser inp Char
char Char
':'
    hexcolon2 :: Parser [Int]
hexcolon2 = forall inp a b.
MkParser inp a -> MkParser inp b -> MkParser inp [a]
manyTill (Parser Int
hex forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall inp. Input inp => Char -> MkParser inp Char
char Char
':') (forall inp. Input inp => Char -> MkParser inp Char
char Char
':')
    check :: t a -> f ()
check t a
bs = forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
bs forall a. Eq a => a -> a -> Bool
/= Int
8) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address4")

ip4Embedded :: Parser [Int]
ip4Embedded :: Parser [Int]
ip4Embedded = forall inp a. MkParser inp a -> MkParser inp a
try (do Parser ()
colon2
                      [Int]
bs <- Parser [Int]
beforeEmbedded
                      [Int]
embedded <- Parser [Int]
ip4'
                      [Int] -> [Int] -> Parser [Int]
format [] ([Int]
bs forall a. [a] -> [a] -> [a]
++ forall {a}. Bits a => [a] -> [a]
ip4ToIp6 [Int]
embedded))
              -- matches 2001:db8::192.0.2.1
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall inp a. MkParser inp a -> MkParser inp a
try (do [Int]
bs1 <- forall inp a b.
MkParser inp a -> MkParser inp b -> MkParser inp [a]
manyTill (forall inp a. MkParser inp a -> MkParser inp a
try forall a b. (a -> b) -> a -> b
$ Parser Int
hex forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall inp. Input inp => Char -> MkParser inp Char
char Char
':') (forall inp. Input inp => Char -> MkParser inp Char
char Char
':')
                      [Int]
bs2 <- forall a inp. a -> MkParser inp a -> MkParser inp a
option [] Parser [Int]
beforeEmbedded
                      [Int]
embedded <- Parser [Int]
ip4'
                      [Int] -> [Int] -> Parser [Int]
format [Int]
bs1 ([Int]
bs2 forall a. [a] -> [a] -> [a]
++ forall {a}. Bits a => [a] -> [a]
ip4ToIp6 [Int]
embedded))
              -- matches 2001:db8:11e:c00:aa:bb:192.0.2.1
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall inp a. MkParser inp a -> MkParser inp a
try (do [Int]
bs <- Parser [Int]
beforeEmbedded
                      [Int]
embedded <- Parser [Int]
ip4'
                      let rs :: [Int]
rs = [Int]
bs forall a. [a] -> [a] -> [a]
++ forall {a}. Bits a => [a] -> [a]
ip4ToIp6 [Int]
embedded
                      forall {f :: * -> *} {t :: * -> *} {a}.
(Foldable t, MonadFail f) =>
t a -> f ()
check [Int]
rs
                      forall (m :: * -> *) a. Monad m => a -> m a
return [Int]
rs)
  where
    beforeEmbedded :: Parser [Int]
beforeEmbedded = forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a b. (a -> b) -> a -> b
$ forall inp a. MkParser inp a -> MkParser inp a
try forall a b. (a -> b) -> a -> b
$ Parser Int
hex forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall inp. Input inp => Char -> MkParser inp Char
char Char
':'
    ip4ToIp6 :: [a] -> [a]
ip4ToIp6 [a
a,a
b,a
c,a
d] = [ a
a forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. a
b
                         , a
c forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. a
d ]
    ip4ToIp6 [a]
_ = forall a. HasCallStack => String -> a
error String
"ip4ToIp6"
    check :: t a -> f ()
check t a
bs = forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
bs forall a. Eq a => a -> a -> Bool
/= Int
8) (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"IPv6 address4")

----------------------------------------------------------------
--
-- HostAddress and HostAddress6
--

-- | The 'fromHostAddress' function converts 'HostAddress' to 'IPv4'.
fromHostAddress :: HostAddress -> IPv4
fromHostAddress :: Word32 -> IPv4
fromHostAddress Word32
addr4
  | ByteOrder
byteOrder forall a. Eq a => a -> a -> Bool
== ByteOrder
LittleEndian = Word32 -> IPv4
IP4 forall a b. (a -> b) -> a -> b
$ Word32 -> Word32
fixByteOrder Word32
addr4
  | Bool
otherwise                 = Word32 -> IPv4
IP4 Word32
addr4

-- | The 'toHostAddress' function converts 'IPv4' to 'HostAddress'.
toHostAddress :: IPv4 -> HostAddress
toHostAddress :: IPv4 -> Word32
toHostAddress (IP4 Word32
addr4)
  | ByteOrder
byteOrder forall a. Eq a => a -> a -> Bool
== ByteOrder
LittleEndian = Word32 -> Word32
fixByteOrder Word32
addr4
  | Bool
otherwise                 = Word32
addr4

-- | The 'fromHostAddress6' function converts 'HostAddress6' to 'IPv6'.
fromHostAddress6 :: HostAddress6 -> IPv6
fromHostAddress6 :: IPv6Addr -> IPv6
fromHostAddress6 = IPv6Addr -> IPv6
IP6

-- | The 'toHostAddress6' function converts 'IPv6' to 'HostAddress6'.
toHostAddress6 :: IPv6 -> HostAddress6
toHostAddress6 :: IPv6 -> IPv6Addr
toHostAddress6 (IP6 IPv6Addr
addr6) = IPv6Addr
addr6

fixByteOrder :: Word32 -> Word32
fixByteOrder :: Word32 -> Word32
fixByteOrder Word32
s = Word32
d1 forall a. Bits a => a -> a -> a
.|. Word32
d2 forall a. Bits a => a -> a -> a
.|. Word32
d3 forall a. Bits a => a -> a -> a
.|. Word32
d4
  where
    d1 :: Word32
d1 = forall a. Bits a => a -> Int -> a
shiftL Word32
s Int
24
    d2 :: Word32
d2 = forall a. Bits a => a -> Int -> a
shiftL Word32
s  Int
8 forall a. Bits a => a -> a -> a
.&. Word32
0x00ff0000
    d3 :: Word32
d3 = forall a. Bits a => a -> Int -> a
shiftR Word32
s  Int
8 forall a. Bits a => a -> a -> a
.&. Word32
0x0000ff00
    d4 :: Word32
d4 = forall a. Bits a => a -> Int -> a
shiftR Word32
s Int
24 forall a. Bits a => a -> a -> a
.&. Word32
0x000000ff

-- | Convert IPv4 address to IPv4-embedded-in-IPv6
ipv4ToIPv6 :: IPv4 -> IPv6
ipv4ToIPv6 :: IPv4 -> IPv6
ipv4ToIPv6 IPv4
ip = [Int] -> IPv6
toIPv6b [Int
0,Int
0,Int
0,Int
0,Int
0,Int
0,Int
0,Int
0,Int
0,Int
0,Int
0xff,Int
0xff,Int
i1,Int
i2,Int
i3,Int
i4]
  where
    [Int
i1,Int
i2,Int
i3,Int
i4] = IPv4 -> [Int]
fromIPv4 IPv4
ip

-- | Convert 'SockAddr' to 'IP'.
--
--   Since: 1.7.4.
fromSockAddr :: SockAddr -> Maybe (IP, PortNumber)
fromSockAddr :: SockAddr -> Maybe (IP, PortNumber)
fromSockAddr (SockAddrInet  PortNumber
pn   Word32
ha)    = forall a. a -> Maybe a
Just (IPv4 -> IP
IPv4 (Word32 -> IPv4
fromHostAddress  Word32
ha),  PortNumber
pn)
fromSockAddr (SockAddrInet6 PortNumber
pn Word32
_ IPv6Addr
ha6 Word32
_) = forall a. a -> Maybe a
Just (IPv6 -> IP
IPv6 (IPv6Addr -> IPv6
fromHostAddress6 IPv6Addr
ha6), PortNumber
pn)
fromSockAddr SockAddr
_                          = forall a. Maybe a
Nothing

-- | Convert 'IP' to 'SockAddr'.
--
--   Since: 1.7.8.
toSockAddr :: (IP, PortNumber) -> SockAddr
toSockAddr :: (IP, PortNumber) -> SockAddr
toSockAddr (IPv4 IPv4
addr4, PortNumber
pn) = PortNumber -> Word32 -> SockAddr
SockAddrInet  PortNumber
pn   (IPv4 -> Word32
toHostAddress  IPv4
addr4)
toSockAddr (IPv6 IPv6
addr6, PortNumber
pn) = PortNumber -> Word32 -> IPv6Addr -> Word32 -> SockAddr
SockAddrInet6 PortNumber
pn Word32
0 (IPv6 -> IPv6Addr
toHostAddress6 IPv6
addr6) Word32
0