--- /dev/null
+hath: manipulate network blocks in CIDR notation
+Copyright (C) 2024 Michael Orlitzky
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
cabal-version: 3.0
name: hath
-version: 0.5.7
+version: 0.5.8
author: Michael Orlitzky
-maintainer: Michael Orlitzky <michael@orlitzky.com>
-homepage: http://michael.orlitzky.com/code/hath.xhtml
+maintainer: Michael Orlitzky <michael@orlitzky.com>
+homepage: https://michael.orlitzky.com/code/hath.xhtml
+bug-reports: mailto:michael@orlitzky.com
category: Utils
-license: AGPL-3.0-only
+license: AGPL-3.0-or-later
license-file: doc/LICENSE
build-type: Simple
extra-source-files:
+ doc/COPYING
doc/man1/hath.1
test/shell/*.test
synopsis:
- Hath manipulates network blocks in CIDR notation.
+ Manipulates network blocks in CIDR notation
description:
Hath is a Haskell program for working with network blocks in CIDR
notation. When dealing with blocks of network addresses, there are a
* List them.
- Hath has several modes to perform these functions:
-
- * __Regexed__
- This computes a (Perl-compatible) regular expression matching
- the input CIDR blocks. It's the default mode of operation.
-
- * __Reduced__
- This combines small blocks into larger ones where possible, and
- eliminates redundant blocks. The output should be equivalent to
- the input, though.
-
- * __Duped__
- Shows only the blocks that would be removed by reduce; that is, it
- shows the ones that would get combined into larger blocks or are
- simply redundant.
-
- * __Diffed__
- Shows what would change if you used reduce. Uses diff-like
- notation.
-
- * __Listed__
- List the IP addresses contained within the given CIDRs.
-
- /Examples/:
-
- Compute a (Perl-compatible) regular expression matching
- the input CIDR blocks. It's the default mode of operation.
-
- @
- $ echo \"10.0.0.0\/29 10.0.0.8\/29\" | hath
- ((10)\.(0)\.(0)\.(15|14|13|12|11|10|9|8|7|6|5|4|3|2|1|0))
- @
-
- Combine two \/24s into a \/23:
-
- @
- $ echo \"10.0.0.0\/24 10.0.1.0\/24\" | hath reduced
- 10.0.0.0/23
- @
-
- List the addresses in 192.168.0.240\/29:
-
- @
- $ echo 192.168.0.240\/29 | hath listed
- 192.168.0.240
- 192.168.0.241
- 192.168.0.242
- 192.168.0.243
- 192.168.0.244
- 192.168.0.245
- 192.168.0.246
- 192.168.0.247
- @
-
- The command-line syntax and complete set of options are documented in
- the man page.
+ Hath has several modes to perform these functions. The command-line
+ syntax and complete set of options are documented in the man page.
executable hath
source-repository head
type: git
- location: http://gitweb.michael.orlitzky.com/hath.git
+ location: https://gitweb.michael.orlitzky.com/hath.git
branch: master
-Wno-prepositive-qualified-module \
-Wno-missing-safe-haskell-mode \
-Wno-missing-deriving-strategies \
+ -Wno-missing-kind-signatures \
-rtsopts \
-threaded
-- Chop off the higher octets. x1 = x `mod` 2^32, would be
-- redundant.
- x2 = x `mod` 2^(24 :: Integer)
- x3 = x `mod` 2^(16 :: Integer)
- x4 = (fromIntegral $ x `mod` 2^(8 :: Integer)) :: Int
+ x2 = x `mod` (2 ^ (24 :: Integer))
+ x3 = x `mod` (2 ^ (16 :: Integer))
+ x4 = (fromIntegral $ x `mod` (2 ^ (8 :: Integer))) :: Int
-- Perform right-shifts. x4 doesn't need a shift.
- shifted_x1 = (fromIntegral $ x `quot` 2^(24 :: Integer)) :: Int
- shifted_x2 = (fromIntegral $ x2 `quot` 2^(16 :: Integer)) :: Int
- shifted_x3 = fromIntegral $ x3 `quot` 2^(8 :: Integer) :: Int
+ shifted_x1 = (fromIntegral $ x `quot` (2 ^ (24 :: Integer))) :: Int
+ shifted_x2 = (fromIntegral $ x2 `quot` (2 ^ (16 :: Integer))) :: Int
+ shifted_x3 = (fromIntegral $ x3 `quot` (2 ^ (8 :: Integer))) :: Int
oct1 = toEnum shifted_x1 :: Octet
oct2 = toEnum shifted_x2 :: Octet
oct3 = toEnum shifted_x3 :: Octet
oct2 = fromEnum (octet2 addr)
oct3 = fromEnum (octet3 addr)
oct4 = fromEnum (octet4 addr)
- shifted_oct1 = oct1 * 2^(24 :: Integer)
- shifted_oct2 = oct2 * 2^(16 :: Integer)
- shifted_oct3 = oct3 * 2^(8 :: Integer)
+ shifted_oct1 = oct1 * (2 ^ (24 :: Integer))
+ shifted_oct2 = oct2 * (2 ^ (16 :: Integer))
+ shifted_oct3 = oct3 * (2 ^ (8 :: Integer))
-- | Given two addresses, find the number of the most significant bit
-- where they differ. If the addresses are the same, return
where
prop :: (Small Int64) -> Property
prop x =
- 0 <= x && x <= 2^(32 :: Integer) - 1 ==>
+ 0 <= x && x <= (2 ^ (32 :: Integer)) - 1 ==>
fromIntegral (fromEnum (toEnum (fromIntegral x) :: IPv4Address)) == x
-- According to the QuickCheck documentation, we need the "Large"