-import qualified Data.Char as DC
-import qualified Data.List as DL
-import qualified Numeric as N
-import System.Exit (exitFailure)
-import Text.Regex.Posix
-
-import ListUtils
-
--- 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)
-
-
--- 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 ""
-
-
--- 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) (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) (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
- 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
- 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
- 0
- else
- fst (parsed !! 0)
- where
- parsed = N.readInt 2 is_binary_digit DC.digitToInt s
+import Data.List ((\\), intercalate, intersperse)
+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 Octet
+
+-- Some exit codes, used in the ExitFailure constructor.
+exit_invalid_cidr :: Int
+exit_invalid_cidr = 1
+
+exit_args_parse_failed :: Int
+exit_args_parse_failed = 2
-- A regular expression that matches a non-address character.
-- 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 :: String -> String
+cidr_to_regex :: Cidr.Cidr -> String
cidr_to_regex cidr =
- addr_barrier (DL.intercalate "\\." [range1, range2, range3, range4])
+ addr_barrier (intercalate "\\." [range1, range2, range3, range4])
where
range1 = numeric_range min1 max1
range2 = numeric_range min2 max2
range3 = numeric_range min3 max3
range4 = numeric_range min4 max4
- min1 = (min_octets cidr) !! 0
- min2 = (min_octets cidr) !! 1
- min3 = (min_octets cidr) !! 2
- min4 = (min_octets cidr) !! 3
- max1 = (max_octets cidr) !! 0
- max2 = (max_octets cidr) !! 1
- max3 = (max_octets cidr) !! 2
- max4 = (max_octets cidr) !! 3
+ 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.
alternate :: [String] -> String
-alternate terms = "(" ++ (concat (DL.intersperse "|" terms)) ++ ")"
+alternate terms = "(" ++ (concat (intersperse "|" terms)) ++ ")"
-- Take two Ints as parameters, and return a regex matching any
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)
+main :: IO ()
+main = do
+ -- First, check for any errors that occurred while parsing
+ -- the command line options.
+ errors <- CommandLine.parse_errors
+ if not (null errors)
+ then do
+ hPutStrLn stderr (concat errors)
+ putStrLn CommandLine.help_text
+ exitWith (ExitFailure exit_args_parse_failed)
+ else do -- Nothing
+
+ -- 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
+ if help_opt_set
then do
- return ()
- else do
- putStrLn "Error: not valid CIDR notation."
- exitFailure
+ putStrLn CommandLine.help_text
+ exitWith ExitSuccess
+ else do -- Nothing
+ -- The input function we receive here should know what to read.
+ inputfunc <- (CommandLine.input_function)
+ input <- inputfunc
-main :: IO ()
-main = do
- input <- getContents
- let cidrs = lines input
- mapM validate_or_die cidrs
- let regexes = map cidr_to_regex cidrs
- putStrLn $ alternate regexes
+ let cidr_strings = lines input
+ let cidrs = map Cidr.cidr_from_string cidr_strings
+ if (any (== Cidr.None) cidrs)
+ then do
+ putStrLn "Error: not valid CIDR notation."
+ exitWith (ExitFailure exit_invalid_cidr)
+ else do -- Nothing
+
+ -- Get the mode of operation.
+ mode <- CommandLine.parse_mode
+
+ case mode of
+ Regex -> do
+ let regexes = map cidr_to_regex cidrs
+ putStrLn $ alternate regexes
+ Reduce -> do
+ _ <- mapM (putStrLn . show) (combine_all cidrs)
+ return ()
+ Dupe -> do
+ _ <- mapM (putStrLn . show) dupes
+ return ()
+ where
+ dupes = cidrs \\ (combine_all cidrs)
+ Diff -> do
+ _ <- mapM putStrLn deletions
+ _ <- mapM putStrLn additions
+ return ()
+ where
+ dupes = cidrs \\ (combine_all cidrs)
+ deletions = map (\s -> "-" ++ (show s)) dupes
+ newcidrs = (combine_all cidrs) \\ cidrs
+ additions = map (\s -> "+" ++ (show s)) newcidrs
projects / hath.git / blobdiff