1package pflag 2 3import ( 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 11type bytesHexValue []byte 12 13// String implements pflag.Value.String. 14func (bytesHex bytesHexValue) String() string { 15 return fmt.Sprintf("%X", []byte(bytesHex)) 16} 17 18// Set implements pflag.Value.Set. 19func (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. 32func (*bytesHexValue) Type() string { 33 return "bytesHex" 34} 35 36func newBytesHexValue(val []byte, p *[]byte) *bytesHexValue { 37 *p = val 38 return (*bytesHexValue)(p) 39} 40 41func 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 53func (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. 65func (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. 70func (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. 76func 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. 81func 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. 87func (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. 94func (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. 102func 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. 107func 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 112type bytesBase64Value []byte 113 114// String implements pflag.Value.String. 115func (bytesBase64 bytesBase64Value) String() string { 116 return base64.StdEncoding.EncodeToString([]byte(bytesBase64)) 117} 118 119// Set implements pflag.Value.Set. 120func (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. 133func (*bytesBase64Value) Type() string { 134 return "bytesBase64" 135} 136 137func newBytesBase64Value(val []byte, p *[]byte) *bytesBase64Value { 138 *p = val 139 return (*bytesBase64Value)(p) 140} 141 142func 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 153func (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. 165func (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. 170func (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. 176func 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. 181func 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. 187func (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. 194func (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. 202func 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. 207func BytesBase64P(name, shorthand string, value []byte, usage string) *[]byte { 208 return CommandLine.BytesBase64P(name, shorthand, value, usage) 209} 210