import System.Exit (exitFailure)
import Text.Regex.Posix
+
+-- Stolen from ByteString. Splits a list at each element satisfying
+-- the predicate p.
splitWith :: (a -> Bool) -> [a] -> [[a]]
splitWith p xs =
ys : case zs of
where (ys,zs) = break p xs
+-- Takes an IP address in CIDR notation, and returns a list of its
+-- octets (converted to Int).
octets :: String -> [Int]
octets cidr = map read (take 4 (splitWith (`elem` "./") cidr))
+
+-- Returns the mask portion of a CIDR address. That is, everything
+-- after the trailing slash.
maskbits :: String -> Int
maskbits cidr = read ((splitWith (`elem` "/") cidr) !! 1)
+-- Pads a list (on the left) to length len by prepending pad_elem.
pad_left_to :: Int -> a -> [a] -> [a]
pad_left_to len pad_elem xs =
if (length xs) >= len then
where
padcount = len - (length xs)
+
+-- Pads a list (on the right) to length len by appending pad_elem.
pad_right_to :: Int -> a -> [a] -> [a]
pad_right_to len pad_elem xs =
if (length xs) >= len then
where
padcount = len - (length xs)
-
+
+-- Takes an Int, and returns its base-two representation as a String.
base_two :: Int -> String
base_two n = N.showIntAtBase 2 DC.intToDigit n ""
-ip_base_two :: [Int] -> String
-ip_base_two octet_list =
+
+-- Takes a set of octets, and converts them to base-two
+-- individually. The results are then zero-padded on the left to 8
+-- characters, and concatenated together.
+octets_base_two :: [Int] -> String
+octets_base_two octet_list =
DL.concatMap ((pad_left_to 8 '0') .base_two) octet_list
+
+-- Returns the minimum address (as a base-two string) satisfying the
+-- given CIDR string.
min_base_two_address :: String -> String
min_base_two_address cidr =
pad_right_to 32 '0' netpart
where
- netpart = take (maskbits cidr) (ip_base_two (octets cidr))
+ netpart = take (maskbits cidr) (octets_base_two (octets cidr))
+
+-- Returns the maximum address (as a base-two string) satisfying the
+-- given CIDR string.
max_base_two_address :: String -> String
max_base_two_address cidr =
pad_right_to 32 '1' netpart
where
- netpart = take (maskbits cidr) (ip_base_two (octets cidr))
+ netpart = take (maskbits cidr) (octets_base_two (octets cidr))
+
+-- The octet components of min_base_two_address, as a base-two String.
min_base_two_octets :: String -> [String]
min_base_two_octets cidr =
[octet1, octet2, octet3, octet4]
where
- addr = min_base_two_address cidr
+ addr = min_base_two_address cidr
octet1 = fst (DL.splitAt 8 addr)
octet2 = fst (DL.splitAt 8 (snd (DL.splitAt 8 addr)))
octet3 = fst (DL.splitAt 8 (snd (DL.splitAt 16 addr)))
octet4 = snd (DL.splitAt 24 addr)
+
+-- The octet components of max_base_two_address, as a base-two String.
max_base_two_octets :: String -> [String]
max_base_two_octets cidr =
[octet1, octet2, octet3, octet4]
where
- addr = max_base_two_address cidr
+ addr = max_base_two_address cidr
octet1 = fst (DL.splitAt 8 addr)
octet2 = fst (DL.splitAt 8 (snd (DL.splitAt 8 addr)))
octet3 = fst (DL.splitAt 8 (snd (DL.splitAt 16 addr)))
octet4 = snd (DL.splitAt 24 addr)
+-- The octet components of min_base_two_address, as Ints.
min_octets :: String -> [Int]
min_octets cidr =
map base_two_to_base_ten (min_base_two_octets cidr)
+
+-- The octet components of max_base_two_address, as Ints.
max_octets :: String -> [Int]
max_octets cidr =
map base_two_to_base_ten (max_base_two_octets cidr)
+
+-- The base_two_to_base_ten function requires a way to determine
+-- whether or not the character it's currently parsing is valid. This
+-- should do it.
is_binary_digit :: Char -> Bool
is_binary_digit c =
if c `elem` ['0','1'] then
True
else
False
-
+
+
+-- Convert a base-two String to an Int.
base_two_to_base_ten :: String -> Int
base_two_to_base_ten s =
if (length parsed) == 0 then
parsed = N.readInt 2 is_binary_digit DC.digitToInt s
+-- A regular expression that matches a non-address character.
+non_addr_char :: String
+non_addr_char = "[^\\.0-9]"
+
+
+-- Add non_addr_chars on either side of the given String. This
+-- prevents (for example) the regex '127.0.0.1' from matching
+-- '127.0.0.100'.
+addr_barrier :: String -> String
+addr_barrier x = non_addr_char ++ x ++ non_addr_char
+
+
+-- The magic happens here. We take a CIDR String as an argument, and
+-- return the equivalent regular expression. We do this as follows:
+--
+-- 1. Compute the minimum possible value of each octet.
+-- 2. Compute the maximum possible value of each octet.
+-- 3. Generate a regex matching every value between those min and
+-- max values.
+-- 4. Join the regexes from step 3 with regexes matching periods.
+-- 5. Stick an address boundary on either side of the result.
cidr_to_regex :: String -> String
cidr_to_regex cidr =
- range1 ++ "\\." ++ range2 ++ "\\." ++ range3 ++ "\\." ++ range4
+ addr_barrier (DL.intercalate "\\." [range1, range2, range3, range4])
where
range1 = numeric_range min1 max1
range2 = numeric_range min2 max2
max3 = (max_octets cidr) !! 2
max4 = (max_octets cidr) !! 3
-
+
+-- Will return True if the passed String is in CIDR notation, False
+-- otherwise.
is_valid_cidr :: String -> Bool
is_valid_cidr cidr = cidr =~ "([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}"
+
+-- Take a list of Strings, and return a regular expression matching
+-- any of them.
alternate :: [String] -> String
alternate terms = "(" ++ (concat (DL.intersperse "|" terms)) ++ ")"
-
+
+
+-- Take two Ints as parameters, and return a regex matching any
+-- integer between them (inclusive).
numeric_range :: Int -> Int -> String
numeric_range x y =
alternate (map show [lower..upper])
where
lower = minimum [x,y]
upper = maximum [x,y]
-
+
+
main :: IO ()
main = do
line <- getLine
-
+
if (is_valid_cidr line)
then do
putStrLn (cidr_to_regex line)
projects / hath.git / commitdiff