From 18cf094717444f477dadab700ab3037f8fc383e6 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Tue, 29 Aug 2023 15:07:55 +0500 Subject: [PATCH 01/10] Implements `ipinfo tool isSingleIP` --- ipinfo/cmd_tool.go | 23 ++++++++------ ipinfo/cmd_tool_isSingleIp.go | 50 ++++++++++++++++++++++++++++++ lib/cmd_tool_isSingleIp.go | 58 +++++++++++++++++++++++++++++++++++ lib/cmd_tool_next.go | 3 +- 4 files changed, 123 insertions(+), 11 deletions(-) create mode 100644 ipinfo/cmd_tool_isSingleIp.go create mode 100644 lib/cmd_tool_isSingleIp.go diff --git a/ipinfo/cmd_tool.go b/ipinfo/cmd_tool.go index f561eafb..b4dca5bb 100644 --- a/ipinfo/cmd_tool.go +++ b/ipinfo/cmd_tool.go @@ -11,15 +11,17 @@ import ( var completionsTool = &complete.Command{ Sub: map[string]*complete.Command{ - "aggregate": completionsToolAggregate, - "next": completionsToolNext, - "prev": completionsToolPrev, - "is_v4": completionsToolIsV4, - "lower": completionsToolLower, - "upper": completionsToolUpper, - "ip2n": completionsToolIP2n, - "n2ip": completionsToolN2IP, - "n2ip6": completionsToolN2IP6, + "aggregate": completionsToolAggregate, + "next": completionsToolNext, + "prev": completionsToolPrev, + "is_v4": completionsToolIsV4, + "is_v6": completionsToolIsV6, + "isSingleIp": completionsToolIsSingleIp, + "lower": completionsToolLower, + "upper": completionsToolUpper, + "ip2n": completionsToolIP2n, + "n2ip": completionsToolN2IP, + "n2ip6": completionsToolN2IP6, }, Flags: map[string]complete.Predictor{ "-h": predict.Nothing, @@ -38,6 +40,7 @@ Commands: prev get the previous IP of the input IP is_v4 reports whether input is an IPv4 address. is_v6 reports whether input is an IPv6 address. + isSingleIp checks whether a CIDR contains exactly one IP. lower get start IP of IPs, IP ranges, and CIDRs. upper get end IP of IPs, IP ranges, and CIDRs. ip2n converts an IPv4 or IPv6 address to its decimal representation. @@ -81,6 +84,8 @@ func cmdTool() error { err = cmdToolIsV4() case cmd == "is_v6": err = cmdToolIsV6() + case cmd == "isSingleIp": + err = cmdToolIsSingleIp() case cmd == "lower": err = cmdToolLower() case cmd == "upper": diff --git a/ipinfo/cmd_tool_isSingleIp.go b/ipinfo/cmd_tool_isSingleIp.go new file mode 100644 index 00000000..bacb15e8 --- /dev/null +++ b/ipinfo/cmd_tool_isSingleIp.go @@ -0,0 +1,50 @@ +package main + +import ( + "fmt" + + "github.com/ipinfo/cli/lib" + "github.com/ipinfo/cli/lib/complete" + "github.com/ipinfo/cli/lib/complete/predict" + "github.com/spf13/pflag" +) + +var completionsToolIsSingleIp = &complete.Command{ + Flags: map[string]complete.Predictor{ + "-h": predict.Nothing, + "--help": predict.Nothing, + "-q": predict.Nothing, + "--quiet": predict.Nothing, + }, +} + +func printHelpToolIsSingleIp() { + fmt.Printf( + `Usage: %s tool isSingleIp [] + +Description: + checks whether a CIDR contains exactly one IP. + +Examples: + # Check CIDR. + $ %[1]s tool isSingleIp 1.1.1.0/30 + + # Check for file. + $ %[1]s tool isSingleIp /path/to/file.txt + + # Check entries from stdin. + $ cat /path/to/file1.txt | %[1]s tool isSingleIp + +Options: + --help, -h + show help. +`, progBase) +} + +func cmdToolIsSingleIp() (err error) { + f := lib.CmdToolIsSingleIpFlags{} + f.Init() + pflag.Parse() + + return lib.CmdToolIsSingleIp(f, pflag.Args()[2:], printHelpToolIsSingleIp) +} diff --git a/lib/cmd_tool_isSingleIp.go b/lib/cmd_tool_isSingleIp.go new file mode 100644 index 00000000..d93fcd76 --- /dev/null +++ b/lib/cmd_tool_isSingleIp.go @@ -0,0 +1,58 @@ +package lib + +import ( + "fmt" + "github.com/spf13/pflag" + "net" +) + +// CmdToolIsSingleIpFlags are flags expected by CmdToolIP2n +type CmdToolIsSingleIpFlags struct { + Help bool +} + +// Init initializes the common flags available to CmdToolIsSingleIp with sensible +func (f *CmdToolIsSingleIpFlags) Init() { + pflag.BoolVarP( + &f.Help, + "help", "h", false, + "show help.", + ) +} + +func CmdToolIsSingleIp(f CmdToolIsSingleIpFlags, args []string, printHelp func()) error { + if len(args) == 0 || f.Help { + printHelp() + return nil + } + + op := func(input string, inputType INPUT_TYPE) error { + switch inputType { + case INPUT_TYPE_CIDR: + fmt.Printf("%s %v\n", input, CIDRContainsExactlyOneIP(input)) + default: + return ErrNotCIDR + } + return nil + } + + return GetInputFrom(args, true, true, op) +} + +// CIDRContainsExactlyOneIP checks whether a CIDR contains exactly one IP +func CIDRContainsExactlyOneIP(cidrStr string) bool { + _, ipnet, err := net.ParseCIDR(cidrStr) + if err != nil { + return false + } + + if ipnet.IP.To4() != nil { + ipRange, _ := IPRangeStrFromCIDR(cidrStr) + return ipRange.Start == ipRange.End + } else if ipnet.IP.To16() != nil { + ipRange, _ := IP6RangeStrFromCIDR(cidrStr) + return ipRange.Start == ipRange.End + } + + return false +} diff --git a/lib/cmd_tool_next.go b/lib/cmd_tool_next.go index 3de07415..b4e7c511 100644 --- a/lib/cmd_tool_next.go +++ b/lib/cmd_tool_next.go @@ -2,7 +2,6 @@ package lib import ( "fmt" - "net" "github.com/spf13/pflag" ) @@ -48,6 +47,6 @@ func CmdToolNext( if err != nil { fmt.Println(err) } - + return nil } From 5c9304fe352c16f6703acb6b6002e642653ede08 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Tue, 29 Aug 2023 15:12:15 +0500 Subject: [PATCH 02/10] Implements `ipinfo tool isSingleIP` --- ipinfo/cmd_tool.go | 28 +++++------ ipinfo/cmd_tool_isOneIp.go | 48 ++++++++++++++++++ ipinfo/cmd_tool_isSingleIp.go | 50 ------------------- ...tool_isSingleIp.go => cmd_tool_isOneIp.go} | 10 ++-- 4 files changed, 67 insertions(+), 69 deletions(-) create mode 100644 ipinfo/cmd_tool_isOneIp.go delete mode 100644 ipinfo/cmd_tool_isSingleIp.go rename lib/{cmd_tool_isSingleIp.go => cmd_tool_isOneIp.go} (74%) diff --git a/ipinfo/cmd_tool.go b/ipinfo/cmd_tool.go index b4dca5bb..5399978b 100644 --- a/ipinfo/cmd_tool.go +++ b/ipinfo/cmd_tool.go @@ -11,17 +11,17 @@ import ( var completionsTool = &complete.Command{ Sub: map[string]*complete.Command{ - "aggregate": completionsToolAggregate, - "next": completionsToolNext, - "prev": completionsToolPrev, - "is_v4": completionsToolIsV4, - "is_v6": completionsToolIsV6, - "isSingleIp": completionsToolIsSingleIp, - "lower": completionsToolLower, - "upper": completionsToolUpper, - "ip2n": completionsToolIP2n, - "n2ip": completionsToolN2IP, - "n2ip6": completionsToolN2IP6, + "aggregate": completionsToolAggregate, + "next": completionsToolNext, + "prev": completionsToolPrev, + "is_v4": completionsToolIsV4, + "is_v6": completionsToolIsV6, + "isOneIp": completionsToolIsOneIp, + "lower": completionsToolLower, + "upper": completionsToolUpper, + "ip2n": completionsToolIP2n, + "n2ip": completionsToolN2IP, + "n2ip6": completionsToolN2IP6, }, Flags: map[string]complete.Predictor{ "-h": predict.Nothing, @@ -40,7 +40,7 @@ Commands: prev get the previous IP of the input IP is_v4 reports whether input is an IPv4 address. is_v6 reports whether input is an IPv6 address. - isSingleIp checks whether a CIDR contains exactly one IP. + isOneIp checks whether a CIDR contains exactly one IP. lower get start IP of IPs, IP ranges, and CIDRs. upper get end IP of IPs, IP ranges, and CIDRs. ip2n converts an IPv4 or IPv6 address to its decimal representation. @@ -84,8 +84,8 @@ func cmdTool() error { err = cmdToolIsV4() case cmd == "is_v6": err = cmdToolIsV6() - case cmd == "isSingleIp": - err = cmdToolIsSingleIp() + case cmd == "isOneIp": + err = cmdToolIsOneIp() case cmd == "lower": err = cmdToolLower() case cmd == "upper": diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_isOneIp.go new file mode 100644 index 00000000..8ec8dbe2 --- /dev/null +++ b/ipinfo/cmd_tool_isOneIp.go @@ -0,0 +1,48 @@ +package main + +import ( + "fmt" + + "github.com/ipinfo/cli/lib" + "github.com/ipinfo/cli/lib/complete" + "github.com/ipinfo/cli/lib/complete/predict" + "github.com/spf13/pflag" +) + +var completionsToolIsOneIp = &complete.Command{ + Flags: map[string]complete.Predictor{ + "-h": predict.Nothing, + "--help": predict.Nothing, + }, +} + +func printHelpToolIsOneIp() { + fmt.Printf( + `Usage: %s tool isOneIp [] + +Description: + checks whether a CIDR contains exactly one IP. + +Examples: + # Check CIDR. + $ %[1]s tool isOneIp 1.1.1.0/30 + + # Check for file. + $ %[1]s tool isOneIp /path/to/file.txt + + # Check entries from stdin. + $ cat /path/to/file1.txt | %[1]s tool isOneIp + +Options: + --help, -h + show help. +`, progBase) +} + +func cmdToolIsOneIp() (err error) { + f := lib.CmdToolIsOneIpFlags{} + f.Init() + pflag.Parse() + + return lib.CmdToolIsOneIp(f, pflag.Args()[2:], printHelpToolIsOneIp) +} diff --git a/ipinfo/cmd_tool_isSingleIp.go b/ipinfo/cmd_tool_isSingleIp.go deleted file mode 100644 index bacb15e8..00000000 --- a/ipinfo/cmd_tool_isSingleIp.go +++ /dev/null @@ -1,50 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/ipinfo/cli/lib" - "github.com/ipinfo/cli/lib/complete" - "github.com/ipinfo/cli/lib/complete/predict" - "github.com/spf13/pflag" -) - -var completionsToolIsSingleIp = &complete.Command{ - Flags: map[string]complete.Predictor{ - "-h": predict.Nothing, - "--help": predict.Nothing, - "-q": predict.Nothing, - "--quiet": predict.Nothing, - }, -} - -func printHelpToolIsSingleIp() { - fmt.Printf( - `Usage: %s tool isSingleIp [] - -Description: - checks whether a CIDR contains exactly one IP. - -Examples: - # Check CIDR. - $ %[1]s tool isSingleIp 1.1.1.0/30 - - # Check for file. - $ %[1]s tool isSingleIp /path/to/file.txt - - # Check entries from stdin. - $ cat /path/to/file1.txt | %[1]s tool isSingleIp - -Options: - --help, -h - show help. -`, progBase) -} - -func cmdToolIsSingleIp() (err error) { - f := lib.CmdToolIsSingleIpFlags{} - f.Init() - pflag.Parse() - - return lib.CmdToolIsSingleIp(f, pflag.Args()[2:], printHelpToolIsSingleIp) -} diff --git a/lib/cmd_tool_isSingleIp.go b/lib/cmd_tool_isOneIp.go similarity index 74% rename from lib/cmd_tool_isSingleIp.go rename to lib/cmd_tool_isOneIp.go index d93fcd76..1cfa4913 100644 --- a/lib/cmd_tool_isSingleIp.go +++ b/lib/cmd_tool_isOneIp.go @@ -6,13 +6,13 @@ import ( "net" ) -// CmdToolIsSingleIpFlags are flags expected by CmdToolIP2n -type CmdToolIsSingleIpFlags struct { +// CmdToolIsOneIpFlags are flags expected by CmdToolIP2n +type CmdToolIsOneIpFlags struct { Help bool } -// Init initializes the common flags available to CmdToolIsSingleIp with sensible -func (f *CmdToolIsSingleIpFlags) Init() { +// Init initializes the common flags available to CmdToolIsOneIp with sensible +func (f *CmdToolIsOneIpFlags) Init() { pflag.BoolVarP( &f.Help, "help", "h", false, @@ -20,7 +20,7 @@ func (f *CmdToolIsSingleIpFlags) Init() { ) } -func CmdToolIsSingleIp(f CmdToolIsSingleIpFlags, args []string, printHelp func()) error { +func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) error { if len(args) == 0 || f.Help { printHelp() return nil From 10efb5fb64f3d4af9e55d72ebdee90067cdefd40 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Wed, 30 Aug 2023 15:14:01 +0500 Subject: [PATCH 03/10] Corrections and addition of ip-ranges and single IPs --- ipinfo/cmd_tool.go | 6 +++--- ipinfo/cmd_tool_isOneIp.go | 10 ++++++++-- lib/cmd_tool_isOneIp.go | 19 +++++++++++++++++-- 3 files changed, 28 insertions(+), 7 deletions(-) diff --git a/ipinfo/cmd_tool.go b/ipinfo/cmd_tool.go index 5399978b..db1856a5 100644 --- a/ipinfo/cmd_tool.go +++ b/ipinfo/cmd_tool.go @@ -16,7 +16,7 @@ var completionsTool = &complete.Command{ "prev": completionsToolPrev, "is_v4": completionsToolIsV4, "is_v6": completionsToolIsV6, - "isOneIp": completionsToolIsOneIp, + "is_one_ip": completionsToolIsOneIp, "lower": completionsToolLower, "upper": completionsToolUpper, "ip2n": completionsToolIP2n, @@ -40,7 +40,7 @@ Commands: prev get the previous IP of the input IP is_v4 reports whether input is an IPv4 address. is_v6 reports whether input is an IPv6 address. - isOneIp checks whether a CIDR contains exactly one IP. + is_one_ip checks whether a CIDR or IP-range contains exactly one IP. lower get start IP of IPs, IP ranges, and CIDRs. upper get end IP of IPs, IP ranges, and CIDRs. ip2n converts an IPv4 or IPv6 address to its decimal representation. @@ -84,7 +84,7 @@ func cmdTool() error { err = cmdToolIsV4() case cmd == "is_v6": err = cmdToolIsV6() - case cmd == "isOneIp": + case cmd == "is_one_ip": err = cmdToolIsOneIp() case cmd == "lower": err = cmdToolLower() diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_isOneIp.go index 8ec8dbe2..d67189c6 100644 --- a/ipinfo/cmd_tool_isOneIp.go +++ b/ipinfo/cmd_tool_isOneIp.go @@ -18,15 +18,21 @@ var completionsToolIsOneIp = &complete.Command{ func printHelpToolIsOneIp() { fmt.Printf( - `Usage: %s tool isOneIp [] + `Usage: %s tool isOneIp [] Description: - checks whether a CIDR contains exactly one IP. + checks whether a CIDR or IP-range contains exactly one IP. Examples: # Check CIDR. $ %[1]s tool isOneIp 1.1.1.0/30 + # Check IP. + $ %[1]s tool isOneIp 1.1.1.1 + + # Check IP range. + $ %[1]s tool isOneIp 1.1.1.1-2.2.2.2 + # Check for file. $ %[1]s tool isOneIp /path/to/file.txt diff --git a/lib/cmd_tool_isOneIp.go b/lib/cmd_tool_isOneIp.go index 1cfa4913..83b52e2c 100644 --- a/lib/cmd_tool_isOneIp.go +++ b/lib/cmd_tool_isOneIp.go @@ -27,12 +27,18 @@ func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) erro } op := func(input string, inputType INPUT_TYPE) error { + isOneIp := false switch inputType { case INPUT_TYPE_CIDR: - fmt.Printf("%s %v\n", input, CIDRContainsExactlyOneIP(input)) + isOneIp = CIDRContainsExactlyOneIP(input) + case INPUT_TYPE_IP: + isOneIp = true + case INPUT_TYPE_IP_RANGE: + isOneIp = ipRangeContainsExactlyOneIP(input) default: - return ErrNotCIDR + return ErrInvalidInput } + fmt.Printf("%s %v\n", input, isOneIp) return nil } @@ -56,3 +62,12 @@ func CIDRContainsExactlyOneIP(cidrStr string) bool { return false } + +func ipRangeContainsExactlyOneIP(ipRangeStr string) bool { + ipRange, err := IPRangeStrFromStr(ipRangeStr) + if err != nil { + return false + } + + return ipRange.Start == ipRange.End +} From 58b1ffa16a54103c08902f6c830cf8e049f7eb02 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Wed, 30 Aug 2023 15:16:57 +0500 Subject: [PATCH 04/10] Corrections --- ipinfo/cmd_tool.go | 2 +- ipinfo/cmd_tool_isOneIp.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ipinfo/cmd_tool.go b/ipinfo/cmd_tool.go index db1856a5..0cf99423 100644 --- a/ipinfo/cmd_tool.go +++ b/ipinfo/cmd_tool.go @@ -40,7 +40,7 @@ Commands: prev get the previous IP of the input IP is_v4 reports whether input is an IPv4 address. is_v6 reports whether input is an IPv6 address. - is_one_ip checks whether a CIDR or IP-range contains exactly one IP. + is_one_ip checks whether a CIDR or ip range contains exactly one IP. lower get start IP of IPs, IP ranges, and CIDRs. upper get end IP of IPs, IP ranges, and CIDRs. ip2n converts an IPv4 or IPv6 address to its decimal representation. diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_isOneIp.go index d67189c6..cb71d215 100644 --- a/ipinfo/cmd_tool_isOneIp.go +++ b/ipinfo/cmd_tool_isOneIp.go @@ -21,7 +21,7 @@ func printHelpToolIsOneIp() { `Usage: %s tool isOneIp [] Description: - checks whether a CIDR or IP-range contains exactly one IP. + checks whether a CIDR or ip range contains exactly one IP. Examples: # Check CIDR. From 9d14183c9f557b41fc23772170ec10d83894da77 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Wed, 30 Aug 2023 15:18:00 +0500 Subject: [PATCH 05/10] Corrections --- lib/cmd_tool_isOneIp.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/cmd_tool_isOneIp.go b/lib/cmd_tool_isOneIp.go index 83b52e2c..fcef8303 100644 --- a/lib/cmd_tool_isOneIp.go +++ b/lib/cmd_tool_isOneIp.go @@ -38,7 +38,7 @@ func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) erro default: return ErrInvalidInput } - fmt.Printf("%s %v\n", input, isOneIp) + fmt.Printf("%s,%v\n", input, isOneIp) return nil } From f327eb585ae577f8451f6fb21327a5584febd8b9 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Wed, 30 Aug 2023 15:20:30 +0500 Subject: [PATCH 06/10] Corrections --- ipinfo/cmd_tool_isOneIp.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_isOneIp.go index cb71d215..6d436bc5 100644 --- a/ipinfo/cmd_tool_isOneIp.go +++ b/ipinfo/cmd_tool_isOneIp.go @@ -18,26 +18,26 @@ var completionsToolIsOneIp = &complete.Command{ func printHelpToolIsOneIp() { fmt.Printf( - `Usage: %s tool isOneIp [] + `Usage: %s tool is_one_ip [] Description: checks whether a CIDR or ip range contains exactly one IP. Examples: # Check CIDR. - $ %[1]s tool isOneIp 1.1.1.0/30 + $ %[1]s tool is_one_ip 1.1.1.0/30 # Check IP. - $ %[1]s tool isOneIp 1.1.1.1 + $ %[1]s tool is_one_ip 1.1.1.1 # Check IP range. - $ %[1]s tool isOneIp 1.1.1.1-2.2.2.2 + $ %[1]s tool is_one_ip 1.1.1.1-2.2.2.2 # Check for file. - $ %[1]s tool isOneIp /path/to/file.txt + $ %[1]s tool is_one_ip /path/to/file.txt # Check entries from stdin. - $ cat /path/to/file1.txt | %[1]s tool isOneIp + $ cat /path/to/file1.txt | %[1]s tool is_one_ip Options: --help, -h From 3fdf4a6f6b66a2fc9f89396c295227e2bcbe5004 Mon Sep 17 00:00:00 2001 From: Uman Shahzad Date: Wed, 30 Aug 2023 22:21:30 +0500 Subject: [PATCH 07/10] Apply suggestions from code review --- ipinfo/cmd_tool.go | 2 +- ipinfo/cmd_tool_isOneIp.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ipinfo/cmd_tool.go b/ipinfo/cmd_tool.go index 0cf99423..255764ae 100644 --- a/ipinfo/cmd_tool.go +++ b/ipinfo/cmd_tool.go @@ -40,7 +40,7 @@ Commands: prev get the previous IP of the input IP is_v4 reports whether input is an IPv4 address. is_v6 reports whether input is an IPv6 address. - is_one_ip checks whether a CIDR or ip range contains exactly one IP. + is_one_ip checks whether a CIDR or IP Range contains exactly one IP. lower get start IP of IPs, IP ranges, and CIDRs. upper get end IP of IPs, IP ranges, and CIDRs. ip2n converts an IPv4 or IPv6 address to its decimal representation. diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_isOneIp.go index 6d436bc5..793b8366 100644 --- a/ipinfo/cmd_tool_isOneIp.go +++ b/ipinfo/cmd_tool_isOneIp.go @@ -21,7 +21,7 @@ func printHelpToolIsOneIp() { `Usage: %s tool is_one_ip [] Description: - checks whether a CIDR or ip range contains exactly one IP. + Checks whether a CIDR or IP Range contains exactly one IP. Examples: # Check CIDR. From 9944cc2989280f184bc6b7cef16016e03f8b5cf2 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Thu, 7 Sep 2023 14:13:34 +0500 Subject: [PATCH 08/10] using `net/netip` --- lib/cmd_tool_isOneIp.go | 26 ++++++-------------------- 1 file changed, 6 insertions(+), 20 deletions(-) diff --git a/lib/cmd_tool_isOneIp.go b/lib/cmd_tool_isOneIp.go index fcef8303..641ade65 100644 --- a/lib/cmd_tool_isOneIp.go +++ b/lib/cmd_tool_isOneIp.go @@ -3,7 +3,7 @@ package lib import ( "fmt" "github.com/spf13/pflag" - "net" + "net/netip" ) // CmdToolIsOneIpFlags are flags expected by CmdToolIP2n @@ -30,7 +30,11 @@ func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) erro isOneIp := false switch inputType { case INPUT_TYPE_CIDR: - isOneIp = CIDRContainsExactlyOneIP(input) + prefix, err := netip.ParsePrefix(input) + if err != nil { + return ErrInvalidInput + } + isOneIp = prefix.IsSingleIP() case INPUT_TYPE_IP: isOneIp = true case INPUT_TYPE_IP_RANGE: @@ -45,24 +49,6 @@ func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) erro return GetInputFrom(args, true, true, op) } -// CIDRContainsExactlyOneIP checks whether a CIDR contains exactly one IP -func CIDRContainsExactlyOneIP(cidrStr string) bool { - _, ipnet, err := net.ParseCIDR(cidrStr) - if err != nil { - return false - } - - if ipnet.IP.To4() != nil { - ipRange, _ := IPRangeStrFromCIDR(cidrStr) - return ipRange.Start == ipRange.End - } else if ipnet.IP.To16() != nil { - ipRange, _ := IP6RangeStrFromCIDR(cidrStr) - return ipRange.Start == ipRange.End - } - - return false -} - func ipRangeContainsExactlyOneIP(ipRangeStr string) bool { ipRange, err := IPRangeStrFromStr(ipRangeStr) if err != nil { From 480d510937f0e2bd3785f54002819fd3f0032c6d Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Thu, 7 Sep 2023 14:23:05 +0500 Subject: [PATCH 09/10] Changed filenames --- ipinfo/{cmd_tool_isOneIp.go => cmd_tool_is_one_ip.go} | 0 lib/{cmd_tool_isOneIp.go => cmd_tool_is_one_ip.go} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename ipinfo/{cmd_tool_isOneIp.go => cmd_tool_is_one_ip.go} (100%) rename lib/{cmd_tool_isOneIp.go => cmd_tool_is_one_ip.go} (100%) diff --git a/ipinfo/cmd_tool_isOneIp.go b/ipinfo/cmd_tool_is_one_ip.go similarity index 100% rename from ipinfo/cmd_tool_isOneIp.go rename to ipinfo/cmd_tool_is_one_ip.go diff --git a/lib/cmd_tool_isOneIp.go b/lib/cmd_tool_is_one_ip.go similarity index 100% rename from lib/cmd_tool_isOneIp.go rename to lib/cmd_tool_is_one_ip.go From d9ec579ee16feb3f9a2ea808792fef81bc95ef93 Mon Sep 17 00:00:00 2001 From: harisabdullah Date: Thu, 7 Sep 2023 15:32:10 +0500 Subject: [PATCH 10/10] Allow manual input mode --- lib/cmd_tool_is_one_ip.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/cmd_tool_is_one_ip.go b/lib/cmd_tool_is_one_ip.go index 641ade65..c3031b54 100644 --- a/lib/cmd_tool_is_one_ip.go +++ b/lib/cmd_tool_is_one_ip.go @@ -21,7 +21,7 @@ func (f *CmdToolIsOneIpFlags) Init() { } func CmdToolIsOneIp(f CmdToolIsOneIpFlags, args []string, printHelp func()) error { - if len(args) == 0 || f.Help { + if f.Help { printHelp() return nil }