1 package pflag
2 3 import (
4 "fmt"
5 "io"
6 "net"
7 "strings"
8 )
9 10 // -- ipSlice Value
11 type ipSliceValue struct {
12 value *[]net.IP
13 changed bool
14 }
15 16 func newIPSliceValue(val []net.IP, p *[]net.IP) *ipSliceValue {
17 ipsv := new(ipSliceValue)
18 ipsv.value = p
19 *ipsv.value = val
20 return ipsv
21 }
22 23 // Set converts, and assigns, the comma-separated IP argument string representation as the []net.IP value of this flag.
24 // If Set is called on a flag that already has a []net.IP assigned, the newly converted values will be appended.
25 func (s *ipSliceValue) Set(val string) error {
26 27 // remove all quote characters
28 rmQuote := strings.NewReplacer(`"`, "", `'`, "", "`", "")
29 30 // read flag arguments with CSV parser
31 ipStrSlice, err := readAsCSV(rmQuote.Replace(val))
32 if err != nil && err != io.EOF {
33 return err
34 }
35 36 // parse ip values into slice
37 out := make([]net.IP, 0, len(ipStrSlice))
38 for _, ipStr := range ipStrSlice {
39 ip := net.ParseIP(strings.TrimSpace(ipStr))
40 if ip == nil {
41 return fmt.Errorf("invalid string being converted to IP address: %s", ipStr)
42 }
43 out = append(out, ip)
44 }
45 46 if !s.changed {
47 *s.value = out
48 } else {
49 *s.value = append(*s.value, out...)
50 }
51 52 s.changed = true
53 54 return nil
55 }
56 57 // Type returns a string that uniquely represents this flag's type.
58 func (s *ipSliceValue) Type() string {
59 return "ipSlice"
60 }
61 62 // String defines a "native" format for this net.IP slice flag value.
63 func (s *ipSliceValue) String() string {
64 65 ipStrSlice := make([]string, len(*s.value))
66 for i, ip := range *s.value {
67 ipStrSlice[i] = ip.String()
68 }
69 70 out, _ := writeAsCSV(ipStrSlice)
71 72 return "[" + out + "]"
73 }
74 75 func (s *ipSliceValue) fromString(val string) (net.IP, error) {
76 return net.ParseIP(strings.TrimSpace(val)), nil
77 }
78 79 func (s *ipSliceValue) toString(val net.IP) string {
80 return val.String()
81 }
82 83 func (s *ipSliceValue) Append(val string) error {
84 i, err := s.fromString(val)
85 if err != nil {
86 return err
87 }
88 *s.value = append(*s.value, i)
89 return nil
90 }
91 92 func (s *ipSliceValue) Replace(val []string) error {
93 out := make([]net.IP, len(val))
94 for i, d := range val {
95 var err error
96 out[i], err = s.fromString(d)
97 if err != nil {
98 return err
99 }
100 }
101 *s.value = out
102 return nil
103 }
104 105 func (s *ipSliceValue) GetSlice() []string {
106 out := make([]string, len(*s.value))
107 for i, d := range *s.value {
108 out[i] = s.toString(d)
109 }
110 return out
111 }
112 113 func ipSliceConv(val string) (interface{}, error) {
114 val = strings.Trim(val, "[]")
115 // Empty string would cause a slice with one (empty) entry
116 if len(val) == 0 {
117 return []net.IP{}, nil
118 }
119 ss := strings.Split(val, ",")
120 out := make([]net.IP, len(ss))
121 for i, sval := range ss {
122 ip := net.ParseIP(strings.TrimSpace(sval))
123 if ip == nil {
124 return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval)
125 }
126 out[i] = ip
127 }
128 return out, nil
129 }
130 131 // GetIPSlice returns the []net.IP value of a flag with the given name
132 func (f *FlagSet) GetIPSlice(name string) ([]net.IP, error) {
133 val, err := f.getFlagType(name, "ipSlice", ipSliceConv)
134 if err != nil {
135 return []net.IP{}, err
136 }
137 return val.([]net.IP), nil
138 }
139 140 // IPSliceVar defines a ipSlice flag with specified name, default value, and usage string.
141 // The argument p points to a []net.IP variable in which to store the value of the flag.
142 func (f *FlagSet) IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
143 f.VarP(newIPSliceValue(value, p), name, "", usage)
144 }
145 146 // IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
147 func (f *FlagSet) IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
148 f.VarP(newIPSliceValue(value, p), name, shorthand, usage)
149 }
150 151 // IPSliceVar defines a []net.IP flag with specified name, default value, and usage string.
152 // The argument p points to a []net.IP variable in which to store the value of the flag.
153 func IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
154 CommandLine.VarP(newIPSliceValue(value, p), name, "", usage)
155 }
156 157 // IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
158 func IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
159 CommandLine.VarP(newIPSliceValue(value, p), name, shorthand, usage)
160 }
161 162 // IPSlice defines a []net.IP flag with specified name, default value, and usage string.
163 // The return value is the address of a []net.IP variable that stores the value of that flag.
164 func (f *FlagSet) IPSlice(name string, value []net.IP, usage string) *[]net.IP {
165 p := []net.IP{}
166 f.IPSliceVarP(&p, name, "", value, usage)
167 return &p
168 }
169 170 // IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
171 func (f *FlagSet) IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
172 p := []net.IP{}
173 f.IPSliceVarP(&p, name, shorthand, value, usage)
174 return &p
175 }
176 177 // IPSlice defines a []net.IP flag with specified name, default value, and usage string.
178 // The return value is the address of a []net.IP variable that stores the value of the flag.
179 func IPSlice(name string, value []net.IP, usage string) *[]net.IP {
180 return CommandLine.IPSliceP(name, "", value, usage)
181 }
182 183 // IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
184 func IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
185 return CommandLine.IPSliceP(name, shorthand, value, usage)
186 }
187