Support hostnames as --server arguments.

[haeredes.git] / src / DNS.hs

diff --git a/src/DNS.hs b/src/DNS.hs
index 08d4f210434e6588edd0bcb1147b7813ecf570f3..a1ed2bdf718790d5fce2aaa77cda275da77eb3f1 100644 (file)
--- a/src/DNS.hs
+++ b/src/DNS.hs
@@ -1,15 +1,99 @@
 module DNS (
-  normalize
-  )
+  LookupResult,
+  lookupMX',
+  lookupNS',
+  normalize,
+  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 Network.DNS.Types (Domain)
+import Data.IP (IPv4)
+import Network.DNS (
+  Domain,
+  DNSFormat(..),
+  Resolver,
+  RDATA(..),
+  TYPE(..),
+  defaultResolvConf,
+  lookupA,
+  lookupMX,
+  lookupNS,
+  lookupRaw,
+  makeResolvSeed,
+  rdata,
+  rrtype,
+  withResolver )
+import Text.Read (readMaybe)
+
+type LookupResult = (Domain, Maybe [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)
+resolve_address s =
+  case read_result of
+    Just _  -> return read_result
+    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
+  where
+    read_result :: Maybe IPv4
+    read_result = readMaybe s
+
+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 = fmap (map fst)
+
+    pair_em :: a -> (Domain, a)
+    pair_em = (,) domain
+
+-- This function keeps the domain matches with its NS records.
+lookupNS' :: Resolver -> Domain -> IO LookupResult
+lookupNS' resolver domain = do
+  answer_result <- lookupNS resolver domain
+  auth_result <- lookupNS_authority 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.