using Lazy ByteString

5 files changed, 22 insertions, 18 deletions

diff --git a/Network/DNS/Internal.hs b/Network/DNS/Internal.hs
index 4f46d4d..0f53b80 100644
--- a/Network/DNS/Internal.hs
+++ b/Network/DNS/Internal.hs
@@ -1,5 +1,6 @@
 module Network.DNS.Internal where
 
+import qualified Data.ByteString.Lazy.Char8 as L
 import Data.Char
 import Data.IP
 
@@ -124,7 +125,7 @@ data ResourceRecord = ResourceRecord {
 -}
 data RDATA = RD_NS Domain | RD_CNAME Domain | RD_MX Int Domain
            | RD_SOA Domain Domain Int Int Int Int Int
-           | RD_A IPv4 | RD_AAAA IPv6 | RD_TXT String
+           | RD_A IPv4 | RD_AAAA IPv6 | RD_TXT L.ByteString
            | RD_OTH [Int] deriving (Eq)
 
 instance Show RDATA where
@@ -133,7 +134,7 @@ instance Show RDATA where
   show (RD_CNAME dom) = dom
   show (RD_A a) = show a
   show (RD_AAAA aaaa) = show aaaa
-  show (RD_TXT txt) = txt
+  show (RD_TXT txt) = L.unpack txt
   show (RD_SOA mn _ _ _ _ _ mi) = mn ++ " " ++ show mi
   show (RD_OTH is) = show is
 
diff --git a/Network/DNS/Lookup.hs b/Network/DNS/Lookup.hs
index ad0da4d..5f27fa5 100644
--- a/Network/DNS/Lookup.hs
+++ b/Network/DNS/Lookup.hs
@@ -9,10 +9,11 @@ module Network.DNS.Lookup (
   ) where
 
 import Control.Applicative
+import qualified Data.ByteString.Lazy.Char8 as L
 import Data.IP
 import Data.Maybe
-import Network.DNS.Types
 import Network.DNS.Resolver as DNS
+import Network.DNS.Types
 
 ----------------------------------------------------------------
 
@@ -76,7 +77,7 @@ lookupXviaMX rlv dom func = do
 {-|
   Resolving 'String' by 'TXT'.
 -}
-lookupTXT :: Resolver -> Domain -> IO (Maybe [String])
+lookupTXT :: Resolver -> Domain -> IO (Maybe [L.ByteString])
 lookupTXT rlv dom = toTXT <$> DNS.lookup rlv dom TXT
   where
     toTXT = maybe Nothing (Just . map unTag)
diff --git a/Network/DNS/Query.hs b/Network/DNS/Query.hs
index 66bfb31..a431dbd 100644
--- a/Network/DNS/Query.hs
+++ b/Network/DNS/Query.hs
@@ -1,13 +1,13 @@
 module Network.DNS.Query (composeQuery) where
 
-import Data.ByteString.Lazy (ByteString)
+import qualified Data.ByteString.Lazy.Char8 as L
 import Data.Char
 import Network.DNS.StateBinary
 import Network.DNS.Internal
 
 ----------------------------------------------------------------
 
-composeQuery :: Int -> [Question] -> ByteString
+composeQuery :: Int -> [Question] -> L.ByteString
 composeQuery idt qs = runSPut (encodeQuery qry)
   where
     hdr = header defaultQuery
diff --git a/Network/DNS/Response.hs b/Network/DNS/Response.hs
index 1b025fd..898b838 100644
--- a/Network/DNS/Response.hs
+++ b/Network/DNS/Response.hs
@@ -2,7 +2,7 @@ module Network.DNS.Response (parseResponse) where
 
 import Control.Monad
 import Data.Bits
-import Data.ByteString.Lazy (ByteString)
+import qualified Data.ByteString.Lazy.Char8 as L
 import Data.Char
 import Data.IP
 import Network.DNS.StateBinary
@@ -10,7 +10,7 @@ import Network.DNS.Internal
 
 ----------------------------------------------------------------
 
-parseResponse :: ByteString -> DNSFormat
+parseResponse :: L.ByteString -> DNSFormat
 parseResponse bs = runSGet decodeResponse bs
 
 ----------------------------------------------------------------
@@ -97,9 +97,9 @@ decodeRData MX _ = RD_MX <$> decodePreference <*> decodeDomain
   where
     decodePreference = getInt16
 decodeRData CNAME _ = RD_CNAME <$> decodeDomain
-decodeRData TXT len = (RD_TXT . map chr . ignoreLength) <$> getNBytes len
+decodeRData TXT len = (RD_TXT . ignoreLength) <$> getNByteString len
   where
-    ignoreLength = tail
+    ignoreLength = L.tail
 decodeRData A len  = (RD_A . toIPv4) <$> getNBytes len
 decodeRData AAAA len  = (RD_AAAA . toIPv6 . combine) <$> getNBytes len
   where
diff --git a/Network/DNS/StateBinary.hs b/Network/DNS/StateBinary.hs
index 4241364..5e27b30 100644
--- a/Network/DNS/StateBinary.hs
+++ b/Network/DNS/StateBinary.hs
@@ -3,8 +3,8 @@ module Network.DNS.StateBinary where
 import Control.Monad.State
 import Data.Binary.Get
 import Data.Binary.Put
-import Data.ByteString.Lazy (ByteString)
-import qualified Data.ByteString.Lazy as BS hiding (ByteString)
+import qualified Data.ByteString.Lazy.Char8 as L
+import Data.Char
 import Data.IntMap (IntMap)
 import qualified Data.IntMap as IM (insert, lookup, empty)
 import Data.Word
@@ -82,10 +82,12 @@ getPosition :: SGet Int
 getPosition = fromIntegral <$> lift bytesRead
 
 getNBytes :: Int -> SGet [Int]
-getNBytes len = toInts <$> getNbytes len
+getNBytes len = toInts <$> getNByteString len
   where
-    toInts = map fromIntegral . BS.unpack
-    getNbytes = lift . getLazyByteString . fromIntegral
+    toInts = map ord . L.unpack
+
+getNByteString :: Int -> SGet L.ByteString
+getNByteString len = lift . getLazyByteString . fromIntegral $ len
 
 ----------------------------------------------------------------
 
@@ -100,8 +102,8 @@ pop n = IM.lookup n <$> get
 initialState :: IntMap Domain
 initialState = IM.empty
 
-runSGet :: SGet DNSFormat -> ByteString -> DNSFormat
+runSGet :: SGet DNSFormat -> L.ByteString -> DNSFormat
 runSGet res bs = fst $ runGet (runStateT res initialState) bs
 
-runSPut :: Put -> ByteString
-runSPut = runPut
\ No newline at end of file
+runSPut :: Put -> L.ByteString
+runSPut = runPut