diff --git a/Network/DNS/Decode.hs b/Network/DNS/Decode.hs --- a/Network/DNS/Decode.hs +++ b/Network/DNS/Decode.hs @@ -5,17 +5,18 @@ , receive ) where -import Control.Applicative -import Control.Monad -import Data.Bits +import Control.Applicative ((<$), (<$>), (<*), (<*>)) +import Control.Monad (replicateM) +import Control.Monad.Trans.Resource (ResourceT, runResourceT) +import Data.Bits ((.&.), shiftR, testBit) import Data.ByteString (ByteString) import qualified Data.ByteString.Char8 as BS import qualified Data.ByteString.Lazy as BL -import Data.Conduit -import Data.Conduit.Network -import Data.IP -import Data.Maybe -import Network +import Data.Conduit (($$), Source) +import Data.Conduit.Network (sourceSocket) +import Data.IP (toIPv4, toIPv6) +import Data.Maybe (fromMaybe) +import Network (Socket) import Network.DNS.Internal import Network.DNS.StateBinary diff --git a/Network/DNS/Encode.hs b/Network/DNS/Encode.hs --- a/Network/DNS/Encode.hs +++ b/Network/DNS/Encode.hs @@ -5,16 +5,17 @@ , composeQuery ) where -import qualified Blaze.ByteString.Builder as BB (toByteString, fromWrite, writeInt16be) -import qualified Data.ByteString.Lazy.Char8 as BL (ByteString) -import qualified Data.ByteString.Char8 as BS (length, null, break, drop) -import Network.DNS.StateBinary +import qualified Blaze.ByteString.Builder as BB +import Control.Monad (when) +import Control.Monad.State (State, modify, execState, gets) +import Data.Binary (Word16) +import Data.Bits ((.|.), bit, shiftL) +import qualified Data.ByteString.Char8 as BS +import Data.ByteString.Lazy.Char8 (ByteString) +import Data.IP (fromIPv4, fromIPv6) +import Data.Monoid (Monoid, mappend, mconcat) import Network.DNS.Internal -import Data.Monoid -import Control.Monad.State -import Data.Bits -import Data.Word -import Data.IP +import Network.DNS.StateBinary (+++) :: Monoid a => a -> a -> a (+++) = mappend @@ -23,7 +24,7 @@ -- | Composing query. First argument is a number to identify response. -composeQuery :: Int -> [Question] -> BL.ByteString +composeQuery :: Int -> [Question] -> ByteString composeQuery idt qs = encode qry where hdr = header defaultQuery @@ -39,7 +40,7 @@ -- | Composing DNS data. -encode :: DNSFormat -> BL.ByteString +encode :: DNSFormat -> ByteString encode fmt = runSPut (encodeDNSFormat fmt) ---------------------------------------------------------------- diff --git a/Network/DNS/Internal.hs b/Network/DNS/Internal.hs --- a/Network/DNS/Internal.hs +++ b/Network/DNS/Internal.hs @@ -5,9 +5,9 @@ import Control.Exception (Exception) import Data.ByteString (ByteString) import qualified Data.ByteString.Char8 as BS -import Data.Char -import Data.IP -import Data.Maybe +import Data.Char (toUpper) +import Data.IP (IPv4, IPv6) +import Data.Maybe (fromMaybe) import Data.Typeable (Typeable) ---------------------------------------------------------------- diff --git a/Network/DNS/Lookup.hs b/Network/DNS/Lookup.hs --- a/Network/DNS/Lookup.hs +++ b/Network/DNS/Lookup.hs @@ -69,8 +69,8 @@ ) where import Data.ByteString (ByteString) -import qualified Data.ByteString.Char8 as BS (append, intercalate, pack, split) -import Data.IP +import qualified Data.ByteString.Char8 as BS +import Data.IP (IPv4, IPv6) import Network.DNS.Resolver as DNS import Network.DNS.Types diff --git a/Network/DNS/Resolver.hs b/Network/DNS/Resolver.hs --- a/Network/DNS/Resolver.hs +++ b/Network/DNS/Resolver.hs @@ -17,21 +17,21 @@ , fromDNSFormat ) where -import Control.Applicative -import Control.Exception +import Control.Applicative ((<$>), (<*>), pure) +import Control.Exception (bracket) import qualified Data.ByteString.Char8 as BS -import Data.Char -import Data.Int -import Data.List hiding (find, lookup) -import Network.BSD +import Data.Char (isSpace) +import Data.List (isPrefixOf) +import Network.BSD (getProtocolNumber) import Network.DNS.Decode import Network.DNS.Encode import Network.DNS.Internal -import Network.Socket hiding (send, sendTo, recv, recvFrom) -import Network.Socket.ByteString.Lazy +import Network.Socket (HostName, Socket, SocketType(Datagram), sClose, socket, connect) +import Network.Socket (AddrInfoFlag(..), AddrInfo(..), defaultHints, getAddrInfo) +import Network.Socket.ByteString.Lazy (sendAll) import Prelude hiding (lookup) -import System.Random -import System.Timeout +import System.Random (getStdRandom, randomR) +import System.Timeout (timeout) #if mingw32_HOST_OS == 1 import Network.Socket (send) @@ -159,7 +159,7 @@ withResolvers :: [ResolvSeed] -> ([Resolver] -> IO a) -> IO a withResolvers seeds func = bracket openSockets closeSockets $ \socks -> do mapM_ (uncurry connectSocket) $ zip socks seeds - let resolvs = map (uncurry makeResolver) $ zip seeds socks + let resolvs = zipWith makeResolver seeds socks func resolvs where openSockets = mapM openSocket seeds diff --git a/Network/DNS/StateBinary.hs b/Network/DNS/StateBinary.hs --- a/Network/DNS/StateBinary.hs +++ b/Network/DNS/StateBinary.hs @@ -1,28 +1,28 @@ {-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-} module Network.DNS.StateBinary where -import Blaze.ByteString.Builder -import Control.Applicative -import Control.Monad.State -import Data.Attoparsec.ByteString +import Blaze.ByteString.Builder (Write) +import qualified Blaze.ByteString.Builder as BB +import Control.Applicative ((<$>), (<*)) +import Control.Monad.State (State, StateT) +import qualified Control.Monad.State as ST +import Control.Monad.Trans.Resource (ResourceT) +import qualified Data.Attoparsec as A import qualified Data.Attoparsec.ByteString.Lazy as AL +import qualified Data.Attoparsec.Types as T import Data.ByteString (ByteString) -import qualified Data.ByteString as BS (unpack, length) -import qualified Data.ByteString.Lazy as BL (ByteString) -import Data.Conduit -import Data.Conduit.Attoparsec -import Data.Int +import qualified Data.ByteString as BS +import qualified Data.ByteString.Lazy as BL +import Data.Conduit (Sink) +import Data.Conduit.Attoparsec (sinkParser) import Data.IntMap (IntMap) -import qualified Data.IntMap as IM (insert, lookup, empty) +import qualified Data.IntMap as IM import Data.Map (Map) -import qualified Data.Map as M (insert, lookup, empty) -import Data.Monoid -import Data.Word +import qualified Data.Map as M +import Data.Monoid (Monoid, mconcat, mappend, mempty) +import Data.Word (Word8, Word16, Word32) import Network.DNS.Types -import Prelude hiding (lookup, take) -import qualified Data.Attoparsec.Types as T (Parser) - ---------------------------------------------------------------- type SPut = State WState Write @@ -40,30 +40,30 @@ mappend a b = mconcat <$> sequence [a, b] put8 :: Word8 -> SPut -put8 = fixedSized 1 writeWord8 +put8 = fixedSized 1 BB.writeWord8 put16 :: Word16 -> SPut -put16 = fixedSized 2 writeWord16be +put16 = fixedSized 2 BB.writeWord16be put32 :: Word32 -> SPut -put32 = fixedSized 4 writeWord32be +put32 = fixedSized 4 BB.writeWord32be putInt8 :: Int -> SPut -putInt8 = fixedSized 1 (writeInt8 . fromIntegral) +putInt8 = fixedSized 1 (BB.writeInt8 . fromIntegral) putInt16 :: Int -> SPut -putInt16 = fixedSized 2 (writeInt16be . fromIntegral) +putInt16 = fixedSized 2 (BB.writeInt16be . fromIntegral) putInt32 :: Int -> SPut -putInt32 = fixedSized 4 (writeInt32be . fromIntegral) +putInt32 = fixedSized 4 (BB.writeInt32be . fromIntegral) putByteString :: ByteString -> SPut -putByteString = writeSized BS.length writeByteString +putByteString = writeSized BS.length BB.writeByteString addPositionW :: Int -> State WState () addPositionW n = do - (WState m cur) <- get - put $ WState m (cur+n) + (WState m cur) <- ST.get + ST.put $ WState m (cur+n) fixedSized :: Int -> (a -> Write) -> a -> SPut fixedSized n f a = do addPositionW n @@ -75,13 +75,13 @@ wsPop :: Domain -> State WState (Maybe Int) wsPop dom = do - doms <- gets wsDomain + doms <- ST.gets wsDomain return $ M.lookup dom doms wsPush :: Domain -> Int -> State WState () wsPush dom pos = do - (WState m cur) <- get - put $ WState (M.insert dom pos m) cur + (WState m cur) <- ST.get + ST.put $ WState (M.insert dom pos m) cur ---------------------------------------------------------------- @@ -95,39 +95,39 @@ ---------------------------------------------------------------- getPosition :: SGet Int -getPosition = psPosition <$> get +getPosition = psPosition <$> ST.get addPosition :: Int -> SGet () addPosition n = do - PState dom pos <- get - put $ PState dom (pos + n) + PState dom pos <- ST.get + ST.put $ PState dom (pos + n) push :: Int -> Domain -> SGet () push n d = do - PState dom pos <- get - put $ PState (IM.insert n d dom) pos + PState dom pos <- ST.get + ST.put $ PState (IM.insert n d dom) pos pop :: Int -> SGet (Maybe Domain) -pop n = IM.lookup n . psDomain <$> get +pop n = IM.lookup n . psDomain <$> ST.get ---------------------------------------------------------------- get8 :: SGet Word8 -get8 = lift anyWord8 <* addPosition 1 +get8 = ST.lift A.anyWord8 <* addPosition 1 get16 :: SGet Word16 -get16 = lift getWord16be <* addPosition 2 +get16 = ST.lift getWord16be <* addPosition 2 where - word8' = fromIntegral <$> anyWord8 + word8' = fromIntegral <$> A.anyWord8 getWord16be = do a <- word8' b <- word8' return $ a * 256 + b get32 :: SGet Word32 -get32 = lift getWord32be <* addPosition 4 +get32 = ST.lift getWord32be <* addPosition 4 where - word8' = fromIntegral <$> anyWord8 + word8' = fromIntegral <$> A.anyWord8 getWord32be = do a <- word8' b <- word8' @@ -152,7 +152,7 @@ toInts = map fromIntegral . BS.unpack getNByteString :: Int -> SGet ByteString -getNByteString n = lift (take n) <* addPosition n +getNByteString n = ST.lift (A.take n) <* addPosition n ---------------------------------------------------------------- @@ -160,10 +160,10 @@ initialState = PState IM.empty 0 sinkSGet :: SGet a -> Sink ByteString (ResourceT IO) (a, PState) -sinkSGet parser = sinkParser (runStateT parser initialState) +sinkSGet parser = sinkParser (ST.runStateT parser initialState) runSGet :: SGet a -> BL.ByteString -> Either String (a, PState) -runSGet parser bs = AL.eitherResult $ AL.parse (runStateT parser initialState) bs +runSGet parser bs = AL.eitherResult $ AL.parse (ST.runStateT parser initialState) bs runSPut :: SPut -> BL.ByteString -runSPut = toLazyByteString . fromWrite . flip evalState initialWState +runSPut = BB.toLazyByteString . BB.fromWrite . flip ST.evalState initialWState diff --git a/dns.cabal b/dns.cabal --- a/dns.cabal +++ b/dns.cabal @@ -1,5 +1,5 @@ Name: dns -Version: 1.2.0 +Version: 1.2.1 Author: Kazu Yamamoto Maintainer: Kazu Yamamoto License: BSD3 @@ -30,13 +30,14 @@ , binary , blaze-builder , bytestring - , conduit >= 0.5 + , conduit >= 1.1 + , conduit-extra , containers , iproute >= 1.2.4 , mtl , network >= 2.3 - , network-conduit , random + , resourcet else Build-Depends: base >= 4 && < 5 , attoparsec @@ -44,14 +45,15 @@ , binary , blaze-builder , bytestring - , conduit + , conduit >= 1.1 + , conduit-extra , containers , iproute >= 1.2.4 , mtl , network , network-bytestring - , network-conduit , random + , resourcet Test-Suite network Type: exitcode-stdio-1.0 @@ -78,15 +80,16 @@ , binary , blaze-builder , bytestring - , conduit >= 0.5 + , conduit >= 1.1 + , conduit-extra , containers , dns , hspec , iproute >= 1.2.4 , mtl , network >= 2.3 - , network-conduit , random + , resourcet Test-Suite doctest Type: exitcode-stdio-1.0