-import Data.List (intercalate, intersperse)
-import System.Exit (exitFailure)
-import Text.Regex.Posix
-
-import Cidr (Cidr,
- from_string,
- min_first_octet,
- min_second_octet,
- min_third_octet,
- min_fourth_octet,
- max_first_octet,
- max_second_octet,
- max_third_octet,
- max_fourth_octet)
-
-
--- A regular expression that matches a non-address character.
+import Control.Monad (when)
+import Data.List ((\\), intercalate, intersperse)
+import Data.Maybe (catMaybes, isNothing)
+import Data.String.Utils (splitWs)
+import System.Exit (ExitCode(..), exitWith)
+import System.IO (stderr, hPutStrLn)
+
+import Cidr (Cidr(..),
+ cidr_from_string,
+ combine_all,
+ max_octet1,
+ max_octet2,
+ max_octet3,
+ max_octet4,
+ min_octet1,
+ min_octet2,
+ min_octet3,
+ min_octet4 )
+
+import CommandLine (help_set,
+ help_text,
+ input_function,
+ Mode(..),
+ parse_errors,
+ parse_mode)
+
+import ExitCodes
+import Octet
+
+
+-- | 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'.
+-- | 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:
+-- | 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
+-- 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 :: Cidr.Cidr -> String
cidr_to_regex cidr =
addr_barrier (intercalate "\\." [range1, range2, range3, range4])
range2 = numeric_range min2 max2
range3 = numeric_range min3 max3
range4 = numeric_range min4 max4
- min1 = min_first_octet cidr
- min2 = min_second_octet cidr
- min3 = min_third_octet cidr
- min4 = min_fourth_octet cidr
- max1 = max_first_octet cidr
- max2 = max_second_octet cidr
- max3 = max_third_octet cidr
- max4 = max_fourth_octet cidr
+ min1 = octet_to_int (min_octet1 cidr)
+ min2 = octet_to_int (min_octet2 cidr)
+ min3 = octet_to_int (min_octet3 cidr)
+ min4 = octet_to_int (min_octet4 cidr)
+ max1 = octet_to_int (max_octet1 cidr)
+ max2 = octet_to_int (max_octet2 cidr)
+ max3 = octet_to_int (max_octet3 cidr)
+ max4 = octet_to_int (max_octet4 cidr)
--- 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.
+-- | Take a list of Strings, and return a regular expression matching
+-- any of them.
alternate :: [String] -> String
alternate terms = "(" ++ (concat (intersperse "|" terms)) ++ ")"
--- Take two Ints as parameters, and return a regex matching any
--- integer between them (inclusive).
+-- | 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])
upper = maximum [x,y]
--- Take a CIDR String, and exitFailure if it's invalid.
-validate_or_die :: String -> IO ()
-validate_or_die cidr = do
- if (is_valid_cidr cidr)
- then do
- return ()
- else do
- putStrLn "Error: not valid CIDR notation."
- exitFailure
-
-
main :: IO ()
main = do
- input <- getContents
- let cidr_strings = lines input
- mapM validate_or_die cidr_strings
- let cidrs = map Cidr.from_string cidr_strings
- let regexes = map cidr_to_regex cidrs
- putStrLn $ alternate regexes
-
+ -- First, check for any errors that occurred while parsing
+ -- the command line options.
+ errors <- CommandLine.parse_errors
+ when ((not . null) errors) $ do
+ hPutStrLn stderr (concat errors)
+ putStrLn CommandLine.help_text
+ exitWith (ExitFailure exit_args_parse_failed)
+
+ -- Next, check to see if the 'help' option was passed to the
+ -- program. If it was, display the help, and exit successfully.
+ help_opt_set <- CommandLine.help_set
+ when help_opt_set $ do
+ putStrLn CommandLine.help_text
+ exitWith ExitSuccess
+
+ -- The input function we receive here should know what to read.
+ inputfunc <- (CommandLine.input_function)
+ input <- inputfunc
+
+ let cidr_strings = splitWs input
+ let cidrs = map cidr_from_string cidr_strings
+
+ when (any isNothing cidrs) $ do
+ putStrLn "Error: not valid CIDR notation."
+ exitWith (ExitFailure exit_invalid_cidr)
+
+ -- Filter out only the valid ones.
+ let valid_cidrs = catMaybes cidrs
+
+ -- Get the mode of operation.
+ mode <- CommandLine.parse_mode
+
+ case mode of
+ Regex -> do
+ let regexes = map cidr_to_regex valid_cidrs
+ putStrLn $ alternate regexes
+ Reduce -> do
+ _ <- mapM (putStrLn . show) (combine_all valid_cidrs)
+ return ()
+ Dupe -> do
+ _ <- mapM (putStrLn . show) dupes
+ return ()
+ where
+ dupes = valid_cidrs \\ (combine_all valid_cidrs)
+ Diff -> do
+ _ <- mapM putStrLn deletions
+ _ <- mapM putStrLn additions
+ return ()
+ where
+ dupes = valid_cidrs \\ (combine_all valid_cidrs)
+ deletions = map (\s -> "-" ++ (show s)) dupes
+ newcidrs = (combine_all valid_cidrs) \\ valid_cidrs
+ additions = map (\s -> "+" ++ (show s)) newcidrs