1
package pflag
2

3
import (
4
	"encoding/base64"
5
	"encoding/hex"
6
	"fmt"
7
	"strings"
8
)
9

10
// BytesHex adapts []byte for use as a flag. Value of flag is HEX encoded
11
type bytesHexValue []byte
12

13
// String implements pflag.Value.String.
14
func (bytesHex bytesHexValue) String() string {
15
	return fmt.Sprintf("%X", []byte(bytesHex))
16
}
17

18
// Set implements pflag.Value.Set.
19
func (bytesHex *bytesHexValue) Set(value string) error {
20
	bin, err := hex.DecodeString(strings.TrimSpace(value))
21

22
	if err != nil {
23
		return err
24
	}
25

26
	*bytesHex = bin
27

28
	return nil
29
}
30

31
// Type implements pflag.Value.Type.
32
func (*bytesHexValue) Type() string {
33
	return "bytesHex"
34
}
35

36
func newBytesHexValue(val []byte, p *[]byte) *bytesHexValue {
37
	*p = val
38
	return (*bytesHexValue)(p)
39
}
40

41
func bytesHexConv(sval string) (interface{}, error) {
42

43
	bin, err := hex.DecodeString(sval)
44

45
	if err == nil {
46
		return bin, nil
47
	}
48

49
	return nil, fmt.Errorf("invalid string being converted to Bytes: %s %s", sval, err)
50
}
51

52
// GetBytesHex return the []byte value of a flag with the given name
53
func (f *FlagSet) GetBytesHex(name string) ([]byte, error) {
54
	val, err := f.getFlagType(name, "bytesHex", bytesHexConv)
55

56
	if err != nil {
57
		return []byte{}, err
58
	}
59

60
	return val.([]byte), nil
61
}
62

63
// BytesHexVar defines an []byte flag with specified name, default value, and usage string.
64
// The argument p points to an []byte variable in which to store the value of the flag.
65
func (f *FlagSet) BytesHexVar(p *[]byte, name string, value []byte, usage string) {
66
	f.VarP(newBytesHexValue(value, p), name, "", usage)
67
}
68

69
// BytesHexVarP is like BytesHexVar, but accepts a shorthand letter that can be used after a single dash.
70
func (f *FlagSet) BytesHexVarP(p *[]byte, name, shorthand string, value []byte, usage string) {
71
	f.VarP(newBytesHexValue(value, p), name, shorthand, usage)
72
}
73

74
// BytesHexVar defines an []byte flag with specified name, default value, and usage string.
75
// The argument p points to an []byte variable in which to store the value of the flag.
76
func BytesHexVar(p *[]byte, name string, value []byte, usage string) {
77
	CommandLine.VarP(newBytesHexValue(value, p), name, "", usage)
78
}
79

80
// BytesHexVarP is like BytesHexVar, but accepts a shorthand letter that can be used after a single dash.
81
func BytesHexVarP(p *[]byte, name, shorthand string, value []byte, usage string) {
82
	CommandLine.VarP(newBytesHexValue(value, p), name, shorthand, usage)
83
}
84

85
// BytesHex defines an []byte flag with specified name, default value, and usage string.
86
// The return value is the address of an []byte variable that stores the value of the flag.
87
func (f *FlagSet) BytesHex(name string, value []byte, usage string) *[]byte {
88
	p := new([]byte)
89
	f.BytesHexVarP(p, name, "", value, usage)
90
	return p
91
}
92

93
// BytesHexP is like BytesHex, but accepts a shorthand letter that can be used after a single dash.
94
func (f *FlagSet) BytesHexP(name, shorthand string, value []byte, usage string) *[]byte {
95
	p := new([]byte)
96
	f.BytesHexVarP(p, name, shorthand, value, usage)
97
	return p
98
}
99

100
// BytesHex defines an []byte flag with specified name, default value, and usage string.
101
// The return value is the address of an []byte variable that stores the value of the flag.
102
func BytesHex(name string, value []byte, usage string) *[]byte {
103
	return CommandLine.BytesHexP(name, "", value, usage)
104
}
105

106
// BytesHexP is like BytesHex, but accepts a shorthand letter that can be used after a single dash.
107
func BytesHexP(name, shorthand string, value []byte, usage string) *[]byte {
108
	return CommandLine.BytesHexP(name, shorthand, value, usage)
109
}
110

111
// BytesBase64 adapts []byte for use as a flag. Value of flag is Base64 encoded
112
type bytesBase64Value []byte
113

114
// String implements pflag.Value.String.
115
func (bytesBase64 bytesBase64Value) String() string {
116
	return base64.StdEncoding.EncodeToString([]byte(bytesBase64))
117
}
118

119
// Set implements pflag.Value.Set.
120
func (bytesBase64 *bytesBase64Value) Set(value string) error {
121
	bin, err := base64.StdEncoding.DecodeString(strings.TrimSpace(value))
122

123
	if err != nil {
124
		return err
125
	}
126

127
	*bytesBase64 = bin
128

129
	return nil
130
}
131

132
// Type implements pflag.Value.Type.
133
func (*bytesBase64Value) Type() string {
134
	return "bytesBase64"
135
}
136

137
func newBytesBase64Value(val []byte, p *[]byte) *bytesBase64Value {
138
	*p = val
139
	return (*bytesBase64Value)(p)
140
}
141

142
func bytesBase64ValueConv(sval string) (interface{}, error) {
143

144
	bin, err := base64.StdEncoding.DecodeString(sval)
145
	if err == nil {
146
		return bin, nil
147
	}
148

149
	return nil, fmt.Errorf("invalid string being converted to Bytes: %s %s", sval, err)
150
}
151

152
// GetBytesBase64 return the []byte value of a flag with the given name
153
func (f *FlagSet) GetBytesBase64(name string) ([]byte, error) {
154
	val, err := f.getFlagType(name, "bytesBase64", bytesBase64ValueConv)
155

156
	if err != nil {
157
		return []byte{}, err
158
	}
159

160
	return val.([]byte), nil
161
}
162

163
// BytesBase64Var defines an []byte flag with specified name, default value, and usage string.
164
// The argument p points to an []byte variable in which to store the value of the flag.
165
func (f *FlagSet) BytesBase64Var(p *[]byte, name string, value []byte, usage string) {
166
	f.VarP(newBytesBase64Value(value, p), name, "", usage)
167
}
168

169
// BytesBase64VarP is like BytesBase64Var, but accepts a shorthand letter that can be used after a single dash.
170
func (f *FlagSet) BytesBase64VarP(p *[]byte, name, shorthand string, value []byte, usage string) {
171
	f.VarP(newBytesBase64Value(value, p), name, shorthand, usage)
172
}
173

174
// BytesBase64Var defines an []byte flag with specified name, default value, and usage string.
175
// The argument p points to an []byte variable in which to store the value of the flag.
176
func BytesBase64Var(p *[]byte, name string, value []byte, usage string) {
177
	CommandLine.VarP(newBytesBase64Value(value, p), name, "", usage)
178
}
179

180
// BytesBase64VarP is like BytesBase64Var, but accepts a shorthand letter that can be used after a single dash.
181
func BytesBase64VarP(p *[]byte, name, shorthand string, value []byte, usage string) {
182
	CommandLine.VarP(newBytesBase64Value(value, p), name, shorthand, usage)
183
}
184

185
// BytesBase64 defines an []byte flag with specified name, default value, and usage string.
186
// The return value is the address of an []byte variable that stores the value of the flag.
187
func (f *FlagSet) BytesBase64(name string, value []byte, usage string) *[]byte {
188
	p := new([]byte)
189
	f.BytesBase64VarP(p, name, "", value, usage)
190
	return p
191
}
192

193
// BytesBase64P is like BytesBase64, but accepts a shorthand letter that can be used after a single dash.
194
func (f *FlagSet) BytesBase64P(name, shorthand string, value []byte, usage string) *[]byte {
195
	p := new([]byte)
196
	f.BytesBase64VarP(p, name, shorthand, value, usage)
197
	return p
198
}
199

200
// BytesBase64 defines an []byte flag with specified name, default value, and usage string.
201
// The return value is the address of an []byte variable that stores the value of the flag.
202
func BytesBase64(name string, value []byte, usage string) *[]byte {
203
	return CommandLine.BytesBase64P(name, "", value, usage)
204
}
205

206
// BytesBase64P is like BytesBase64, but accepts a shorthand letter that can be used after a single dash.
207
func BytesBase64P(name, shorthand string, value []byte, usage string) *[]byte {
208
	return CommandLine.BytesBase64P(name, shorthand, value, usage)
209
}
210

211