X-Git-Url: http://www.average.org/gitweb/?p=pdns-pipe-nmc.git;a=blobdiff_plain;f=NmcDom.hs;h=c94e8af8bdd50970f9428ce5fd8a2dc8da4bed95;hp=03eeb98582275db94d2554b48fb4d4a80bb15cf6;hb=2ad29ac97637f25aea0a7ac0ee31afa72221a938;hpb=fbe7735ec10867611bc9d202fce4336c36c8af66 diff --git a/NmcDom.hs b/NmcDom.hs index 03eeb98..c94e8af 100644 --- a/NmcDom.hs +++ b/NmcDom.hs @@ -1,38 +1,68 @@ {-# LANGUAGE OverloadedStrings #-} module NmcDom ( NmcDom(..) + , NmcRRService(..) , emptyNmcDom , seedNmcDom , descendNmcDom ) where +import Prelude hiding (length) import Data.ByteString.Lazy (ByteString) import qualified Data.Text as T (unpack) +import Data.List as L (union) import Data.List.Split import Data.Char -import Data.Map as M (Map, lookup, delete, size) +import Data.Map as M (Map, lookup, delete, size, union) +import Data.Vector (toList,(!),length) import Control.Applicative ((<$>), (<*>), empty) import Data.Aeson -data NmcRRService = NmcRRService -- unused +class Mergeable a where + merge :: a -> a -> a -- bias towads second arg + +instance Ord k => Mergeable (Map k a) where + merge mx my = M.union my mx + +-- instance Mergeable String where +-- merge _ b = b + +instance Mergeable Value where + merge _ b = b + +instance Mergeable a => Mergeable (Maybe a) where + merge (Just x) (Just y) = Just (merge x y) + merge Nothing (Just y) = Just y + merge (Just x) Nothing = Just x + merge Nothing Nothing = Nothing + +instance Eq a => Mergeable [a] where + merge xs ys = L.union xs ys + +data NmcRRService = NmcRRService { srvName :: String , srvProto :: String - , srvW1 :: Int - , srvW2 :: Int + , srvPrio :: Int + , srvWeight :: Int , srvPort :: Int - , srvHost :: [String] + , srvHost :: String } deriving (Show, Eq) instance FromJSON NmcRRService where - parseJSON (Object o) = NmcRRService - <$> o .: "name" - <*> o .: "proto" - <*> o .: "w1" - <*> o .: "w2" - <*> o .: "port" - <*> o .: "host" + parseJSON (Array a) = + if length a == 6 then NmcRRService + <$> parseJSON (a ! 0) + <*> parseJSON (a ! 1) + <*> parseJSON (a ! 2) + <*> parseJSON (a ! 3) + <*> parseJSON (a ! 4) + <*> parseJSON (a ! 5) + else empty parseJSON _ = empty +instance Mergeable NmcRRService where + merge _ b = b + data NmcRRI2p = NmcRRI2p { i2pDestination :: String , i2pName :: String @@ -46,7 +76,10 @@ instance FromJSON NmcRRI2p where <*> o .: "b32" parseJSON _ = empty -data NmcDom = NmcDom { domService :: Maybe [[String]] -- [NmcRRService] +instance Mergeable NmcRRI2p where + merge _ b = b + +data NmcDom = NmcDom { domService :: Maybe [NmcRRService] , domIp :: Maybe [String] , domIp6 :: Maybe [String] , domTor :: Maybe String @@ -65,6 +98,7 @@ data NmcDom = NmcDom { domService :: Maybe [[String]] -- [NmcRRService] , domTls :: Maybe (Map String (Map String [[String]])) , domDs :: Maybe [[String]] + , domMx :: Maybe [String] -- Synthetic } deriving (Show, Eq) instance FromJSON NmcDom where @@ -100,38 +134,44 @@ instance FromJSON NmcDom where <*> o .:? "fingerprint" <*> o .:? "tls" <*> o .:? "ds" + <*> return Nothing -- domMx not parsed parseJSON _ = empty +instance Mergeable NmcDom where + merge sub dom = dom { domService = mergelm domService + , domIp = mergelm domIp + , domIp6 = mergelm domIp6 + , domTor = choose domTor + , domI2p = mergelm domI2p + , domFreenet = choose domFreenet + , domAlias = choose domAlias + , domTranslate = choose domTranslate + , domEmail = choose domEmail + , domLoc = choose domLoc + , domInfo = mergelm domInfo + , domNs = mergelm domNs + , domDelegate = mergelm domDelegate + , domImport = choose domImport + , domMap = mergelm domMap + , domFingerprint = mergelm domFingerprint + , domTls = mergelm domTls + , domDs = mergelm domDs + , domMx = mergelm domMx + } + where + mergelm x = merge (x sub) (x dom) +-- Because it is not possible to define instance of merge for Strings, +-- we have to treat string elements separately, otherwise strings are +-- 'unioned' along with the rest of lists. Ugly, but alternatives are worse. + choose field = case field dom of + Nothing -> field sub + Just x -> Just x + + emptyNmcDom = NmcDom Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing - --- FIXME -- I hope there exists a better way to merge records! -mergeNmcDom :: NmcDom -> NmcDom -> NmcDom -mergeNmcDom sub dom = dom { domService = choose domService - , domIp = choose domIp - , domIp6 = choose domIp6 - , domTor = choose domTor - , domI2p = choose domI2p - , domFreenet = choose domFreenet - , domAlias = choose domAlias - , domTranslate = choose domTranslate - , domEmail = choose domEmail - , domLoc = choose domLoc - , domInfo = choose domInfo - , domNs = choose domNs - , domDelegate = choose domDelegate - , domImport = choose domImport - , domMap = choose domMap - , domFingerprint = choose domFingerprint - , domTls = choose domTls - , domDs = choose domDs - } - where - choose :: (NmcDom -> Maybe a) -> Maybe a - choose field = case field dom of - Nothing -> field sub - Just x -> Just x + Nothing -- | Perform query and return error string or parsed domain object queryNmcDom :: @@ -151,30 +191,31 @@ queryNmcDom queryOp key = do -- imported objects are processed recursively until there are none. mergeImport :: (String -> IO (Either String ByteString)) -- ^ query operation action + -> Int -- ^ recursion counter -> NmcDom -- ^ base domain -> IO (Either String NmcDom) -- ^ result with merged import -mergeImport queryOp base = do +mergeImport queryOp depth base = do let mbase = mergeSelf base base' = mbase {domImport = Nothing} -- print base - case domImport mbase of + if depth <= 0 then return $ Left "Nesting of imports is too deep" + else case domImport mbase of Nothing -> return $ Right base' Just key -> do sub <- queryNmcDom queryOp key case sub of Left e -> return $ Left e - Right sub' -> mergeImport queryOp $ sub' `mergeNmcDom` base' + Right sub' -> mergeImport queryOp (depth - 1) $ sub' `merge` base' -- | If there is an element in the map with key "", merge the contents -- and remove this element. Do this recursively. mergeSelf :: NmcDom -> NmcDom mergeSelf base = let - nbase = normalizeDom base - map = domMap nbase - base' = nbase {domMap = removeSelf map} - removeSelf (Nothing) = Nothing + map = domMap base + base' = base {domMap = removeSelf map} + removeSelf Nothing = Nothing removeSelf (Just map) = if size map' == 0 then Nothing else Just map' where map' = M.delete "" map in @@ -183,17 +224,39 @@ mergeSelf base = Just map' -> case M.lookup "" map' of Nothing -> base' - Just sub -> (mergeSelf sub) `mergeNmcDom` base' + Just sub -> (mergeSelf sub) `merge` base' + -- recursion depth limited by the size of the record + +-- | SRV case - remove everyting and filter SRV records +normalizeSrv :: String -> String -> NmcDom -> NmcDom +normalizeSrv serv proto dom = + emptyNmcDom {domService = fmap (filter needed) (domService dom)} + where + needed r = srvName r == serv && srvProto r == proto -- | Presence of some elements require removal of some others normalizeDom :: NmcDom -> NmcDom -normalizeDom dom - | domNs dom /= Nothing = emptyNmcDom { domNs = domNs dom - , domEmail = domEmail dom - } - | domDelegate dom /= Nothing = emptyNmcDom -- FIXME - | domTranslate dom /= Nothing = dom { domMap = Nothing } - | otherwise = dom +normalizeDom dom = foldr id dom [ srvNormalizer + , translateNormalizer + , nsNormalizer + ] + where + nsNormalizer dom = case domNs dom of + Nothing -> dom + Just ns -> emptyNmcDom { domNs = domNs dom, domEmail = domEmail dom } + translateNormalizer dom = case domTranslate dom of + Nothing -> dom + Just tr -> dom { domMap = Nothing } + srvNormalizer dom = dom { domService = Nothing, domMx = makemx } + where + makemx = case domService dom of + Nothing -> Nothing + Just svl -> Just $ map makerec (filter needed svl) + where + needed sr = srvName sr == "smtp" + && srvProto sr == "tcp" + && srvPort sr == 25 + makerec sr = (show (srvPrio sr)) ++ " " ++ (srvHost sr) -- | Merge imports and Selfs and follow the maps tree to get dom descendNmcDom :: @@ -202,9 +265,11 @@ descendNmcDom :: -> NmcDom -- ^ base domain -> IO (Either String NmcDom) -- ^ fully processed result descendNmcDom queryOp subdom base = do - base' <- mergeImport queryOp base + base' <- mergeImport queryOp 10 base case subdom of - [] -> return base' + [] -> return $ fmap normalizeDom base' + -- A hack to handle SRV records: don't descend if ["_prot","_serv"] + [('_':p),('_':s)] -> return $ fmap (normalizeSrv s p) base' d:ds -> case base' of Left err -> return base'