X-Git-Url: http://gitweb.michael.orlitzky.com/?p=haeredes.git;a=blobdiff_plain;f=src%2FDNS.hs;h=b8e9cd0521e6baec631c56da2d4753e531e2ffc1;hp=02e5a5524b866eb646102a544bcc0719a154080c;hb=c66c2d4fdf14e5b0fa54f39e6061eb4774c7b98a;hpb=7cc26ab4bfa90c4abe0c741d5a3eaf575544466a

diff --git a/src/DNS.hs b/src/DNS.hs
index 02e5a55..b8e9cd0 100644
--- a/src/DNS.hs
+++ b/src/DNS.hs
@@ -2,113 +2,109 @@ module DNS (
   LookupResult,
   lookupMX',
   lookupNS',
-  normalize,
-  normalize_case,
   resolve_address )
 where
 
-import Control.Applicative ((<$>))
-import Control.Monad (liftM)
-import qualified Data.ByteString.Char8 as BS (
-  append,
-  last,
-  map,
-  pack )
-import Data.Char (toLower)
+import Control.Monad ( liftM )
+import qualified Data.ByteString.Char8 as BS ( pack )
 import Data.IP (IPv4)
 import Network.DNS (
   Domain,
-  DNSFormat(..),
+  DNSError,
   Resolver,
-  RDATA(..),
-  TYPE(..),
   defaultResolvConf,
   lookupA,
   lookupMX,
   lookupNS,
-  lookupRaw,
+  lookupNSAuth,
   makeResolvSeed,
-  rdata,
-  rrtype,
   withResolver )
-import Text.Read (readMaybe)
+import Text.Read ( readMaybe )
 
-type LookupResult = (Domain, Maybe [Domain])
+type LookupResult = (Domain, Either DNSError [Domain])
 
--- | Perform a query, but take the result from the authority section
---   of the response rather than the answer section. Code shamelessly
---   stolen from Network.DNS.lookup.
-lookup_authority :: Resolver -> Domain -> TYPE -> IO (Maybe [RDATA])
-lookup_authority rlv dom typ = (>>= toRDATA) <$> lookupRaw rlv dom typ
-  where
-    correct r = rrtype r == typ
-    listToMaybe [] = Nothing
-    listToMaybe xs = Just xs
-    toRDATA = listToMaybe . map rdata . filter correct . authority
-
--- | Like lookupNS, except we take the result from the authority
---   section of the response (as opposed to the answer section).
-lookupNS_authority :: Resolver -> Domain -> IO (Maybe [Domain])
-lookupNS_authority rlv dom = toNS <$> DNS.lookup_authority rlv dom NS
-  where
-    toNS = fmap (map unTag)
-    unTag (RD_NS dm) = dm
-    unTag _ = error "lookupNS_authority"
-
-resolve_address :: String -> IO (Maybe IPv4)
+-- | Takes a String representing either a hostname or an IP
+--   address. If a hostname was supplied, it is resolved to either an
+--   [IPv4] or an error. If an IP address is supplied, it is returned
+--   as a singleton [IPv4].
+--
+--   Examples:
+--
+--   >>> resolve_address "example.com"
+--   Right [93.184.216.34]
+--   >>> resolve_address "93.184.216.34"
+--   Right [93.184.216.34]
+--
+resolve_address :: String -> IO (Either DNSError [IPv4])
 resolve_address s =
   case read_result of
-    Just _  -> return read_result
+    Just addr  -> return $ Right [addr]
     Nothing -> do
       default_rs <- makeResolvSeed defaultResolvConf
-      withResolver default_rs $ \resolver -> do
-        result <- lookupA resolver (BS.pack s)
-        return $ case result of
-                   Just (x:_) -> Just x
-                   _           -> Nothing
+      withResolver default_rs $ \resolver ->
+        lookupA resolver (BS.pack s)
   where
     read_result :: Maybe IPv4
     read_result = readMaybe s
 
+
+-- | This calls lookupMX, and returns the result as the second
+--   component of a tuple whose first component is the domain name
+--   itself.
+--
+--   Examples:
+--
+--   The example domain, example.com, has no MX record.
+--
+--   >>> rs <- makeResolvSeed defaultResolvConf
+--   >>> let domain = BS.pack "example.com."
+--   >>> withResolver rs $ \resolver -> lookupMX' resolver domain
+--   ("example.com.",Right [])
+--
 lookupMX' :: Resolver -> Domain -> IO LookupResult
 lookupMX' resolver domain =
   liftM (pair_em . drop_priority) $ lookupMX resolver domain
   where
-    drop_priority :: Maybe [(Domain, Int)] -> Maybe [Domain]
+    drop_priority :: Either DNSError [(Domain, Int)]
+                  -> Either DNSError [Domain]
     drop_priority = fmap (map fst)
 
     pair_em :: a -> (Domain, a)
     pair_em = (,) domain
 
--- This function keeps the domain matches with its NS records.
+
+-- | This calls lookupNS, and returns the result as the second
+--   component of a tuple whose first component is the domain name
+--   itself.
+--
+--   Examples:
+--
+--   The example domain, example.com, does have NS records, but the
+--   order in which they are returned is variable, so we have to sort
+--   them to get a reliable result.
+--
+--   >>> import Data.List (sort)
+--   >>> import Control.Applicative ((<$>))
+--   >>>
+--   >>> let sort_snd (x,y) = (x, sort <$> y)
+--   >>> rs <- makeResolvSeed defaultResolvConf
+--   >>> let domain = BS.pack "example.com."
+--   >>> withResolver rs $ \resolver -> sort_snd <$> lookupNS' resolver domain
+--   ("example.com.",Right ["a.iana-servers.net.","b.iana-servers.net."])
+--
 lookupNS' :: Resolver -> Domain -> IO LookupResult
 lookupNS' resolver domain = do
   answer_result <- lookupNS resolver domain
-  auth_result <- lookupNS_authority resolver domain
+  auth_result <- lookupNSAuth resolver domain
   liftM pair_em $ return $ combine answer_result auth_result
   where
     pair_em :: a -> (Domain, a)
     pair_em = (,) domain
 
-    combine :: (Maybe [Domain]) ->  (Maybe [Domain]) -> (Maybe [Domain])
-    combine Nothing Nothing = Nothing
-    combine m1 Nothing = m1
-    combine Nothing m2 = m2
-    combine (Just ds1) (Just ds2) = Just (ds1 ++ ds2)
-
--- | Normalize the given name by lowercasing and appending a trailing
---   dot (the root) if necessary.
-normalize :: Domain -> Domain
-normalize = normalize_case . normalize_root
-
-
-normalize_root :: Domain -> Domain
-normalize_root d
-  | BS.last d == '.' = d
-  | otherwise = d `BS.append` trailing_dot
-    where
-      trailing_dot = BS.pack "."
-
-
-normalize_case :: Domain -> Domain
-normalize_case = BS.map toLower
+    combine :: (Either DNSError [Domain])
+            -> (Either DNSError [Domain])
+            -> (Either DNSError [Domain])
+    combine e1 e2 = do
+      l1 <- e1
+      l2 <- e2
+      return (l1 ++ l2)