From 5304f43067c24e24eb8b8550c0db67fdbcc94718 Mon Sep 17 00:00:00 2001
From: Bas van Kervel <basvankervel@ziggo.nl>
Date: Wed, 8 Apr 2015 15:43:55 +0200
Subject: Add path expansion support for command line arguments, closes 567
---
cmd/utils/customflags.go | 133 ++++++++++++++++++++++++++++++++++++++++++
cmd/utils/customflags_test.go | 28 +++++++++
cmd/utils/flags.go | 6 +-
3 files changed, 164 insertions(+), 3 deletions(-)
create mode 100644 cmd/utils/customflags.go
create mode 100644 cmd/utils/customflags_test.go
diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go
new file mode 100644
index 000000000..6d4a87bfb
--- /dev/null
+++ b/cmd/utils/customflags.go
@@ -0,0 +1,133 @@
+package utils
+import (
+ "path/filepath"
+ "os"
+ "strings"
+ "os/user"
+ "github.com/codegangsta/cli"
+ "flag"
+ "fmt"
+)
+
+// Custom type which is registered in the flags library which cli uses for
+// argument parsing. This allows us to expand Value to an absolute path when
+// the argument is parsed
+type DirectoryString struct {
+ Value string
+}
+
+func (self DirectoryString) String() string {
+ return self.Value
+}
+
+func (self DirectoryString) Set(value string) error {
+ self.Value = expandPath(value)
+ return nil
+}
+
+// Custom cli.Flag type which expand the received string to an absolute path.
+// e.g. ~/.ethereum -> /home/username/.ethereum
+type DirectoryFlag struct {
+ cli.GenericFlag
+ Name string
+ Value DirectoryString
+ Usage string
+ EnvVar string
+}
+
+func (self DirectoryFlag) String() string {
+ var fmtString string
+ fmtString = "%s %v\t%v"
+
+ if len(self.Value.Value) > 0 {
+ fmtString = "%s \"%v\"\t%v"
+ } else {
+ fmtString = "%s %v\t%v"
+ }
+
+ return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage))
+}
+
+func eachName(longName string, fn func(string)) {
+ parts := strings.Split(longName, ",")
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ fn(name)
+ }
+}
+// called by cli library, grabs variable from environment (if in env)
+// and adds variable to flag set for parsing.
+func (self DirectoryFlag) Apply(set *flag.FlagSet) {
+ if self.EnvVar != "" {
+ for _, envVar := range strings.Split(self.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ self.Value.Value = envVal
+ break
+ }
+ }
+ }
+
+ eachName(self.Name, func(name string) {
+ set.Var(self.Value, self.Name, "a: " + self.Usage)
+ })
+
+}
+
+func prefixFor(name string) (prefix string) {
+ if len(name) == 1 {
+ prefix = "-"
+ } else {
+ prefix = "--"
+ }
+
+ return
+}
+
+func prefixedNames(fullName string) (prefixed string) {
+ parts := strings.Split(fullName, ",")
+ for i, name := range parts {
+ name = strings.Trim(name, " ")
+ prefixed += prefixFor(name) + name
+ if i < len(parts)-1 {
+ prefixed += ", "
+ }
+ }
+ return
+}
+
+func withEnvHint(envVar, str string) string {
+ envText := ""
+ if envVar != "" {
+ envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
+ }
+ return str + envText
+}
+
+func (self DirectoryFlag) getName() string {
+ return self.Name
+}
+
+func (self *DirectoryFlag) Set(value string) {
+ self.Value.Value = value
+}
+
+// Expands a file path
+// 1. replace tilde with users home dir
+// 2. expands embedded environment variables
+// 3. cleans the path, e.g. /a/b/../c -> /a/c
+// Note, it has limitations, e.g. ~someuser/tmp will not be expanded
+func expandPath(p string) string {
+ if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
+ if user, err := user.Current(); err == nil {
+ if err == nil {
+ p = strings.Replace(p, "~", user.HomeDir, 1)
+ }
+ }
+ }
+
+ return filepath.Clean(os.ExpandEnv(p))
+}
+
+
+
diff --git a/cmd/utils/customflags_test.go b/cmd/utils/customflags_test.go
new file mode 100644
index 000000000..5674b939e
--- /dev/null
+++ b/cmd/utils/customflags_test.go
@@ -0,0 +1,28 @@
+package utils
+
+import (
+ "testing"
+ "os"
+ "os/user"
+)
+
+func TestPathExpansion(t *testing.T) {
+
+ user, _ := user.Current()
+
+ tests := map[string]string {
+ "/home/someuser/tmp": "/home/someuser/tmp",
+ "~/tmp": user.HomeDir + "/tmp",
+ "$DDDXXX/a/b": "/tmp/a/b",
+ "/a/b/": "/a/b",
+ }
+
+ os.Setenv("DDDXXX", "/tmp")
+
+ for test, expected := range tests {
+ got := expandPath(test)
+ if got != expected {
+ t.Errorf("test %s, got %s, expected %s\n", test, got, expected)
+ }
+ }
+}
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 51844a68e..461d34ebc 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -68,10 +68,10 @@ func NewApp(version, usage string) *cli.App {
var (
// General settings
- DataDirFlag = cli.StringFlag{
- Name: "datadir",
+ DataDirFlag = DirectoryFlag{
+ Name: "datadir",
Usage: "Data directory to be used",
- Value: common.DefaultDataDir(),
+ Value: DirectoryString{common.DefaultDataDir()},
}
ProtocolVersionFlag = cli.IntFlag{
Name: "protocolversion",
--
cgit v1.2.3
From b3a3fdf9a447bd2b3f862380d87c675138da78e7 Mon Sep 17 00:00:00 2001
From: Bas van Kervel <basvankervel@ziggo.nl>
Date: Wed, 8 Apr 2015 23:03:47 +0200
Subject: Support for import/export hex encoded keys, closes #635
---
cmd/geth/main.go | 3 +--
common/bytes.go | 12 ++++++++++++
crypto/crypto.go | 6 +++---
3 files changed, 16 insertions(+), 5 deletions(-)
diff --git a/cmd/geth/main.go b/cmd/geth/main.go
index 9437f8eb4..02964dadf 100644
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@@ -149,8 +149,7 @@ password to file or expose in any other way.
Imports an unencrypted private key from <keyfile> and creates a new account.
Prints the address.
-The keyfile is assumed to contain an unencrypted private key in canonical EC
-raw bytes format.
+The keyfile is assumed to contain an unencrypted private key in hexadecimal format.
The account is saved in encrypted format, you are prompted for a passphrase.
diff --git a/common/bytes.go b/common/bytes.go
index 5bdacd810..ba180ac94 100644
--- a/common/bytes.go
+++ b/common/bytes.go
@@ -147,6 +147,18 @@ func Hex2Bytes(str string) []byte {
return h
}
+func HexBytes2Bytes(d []byte) []byte {
+ r := make([]byte, hex.DecodedLen(len(d)))
+ hex.Decode(r, d)
+ return r
+}
+
+func Bytes2HexBytes(d []byte) []byte {
+ r := make([]byte, hex.EncodedLen(len(d)))
+ hex.Encode(r, d)
+ return r
+}
+
func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) {
if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") {
ret = Hex2Bytes(str[2:])
diff --git a/crypto/crypto.go b/crypto/crypto.go
index 7d1d51fa6..6e3ffbd4a 100644
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -121,7 +121,7 @@ func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error) {
// LoadECDSA loads a secp256k1 private key from the given file.
func LoadECDSA(file string) (*ecdsa.PrivateKey, error) {
- buf := make([]byte, 32)
+ buf := make([]byte, 64)
fd, err := os.Open(file)
if err != nil {
return nil, err
@@ -130,13 +130,13 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) {
if _, err := io.ReadFull(fd, buf); err != nil {
return nil, err
}
- return ToECDSA(buf), nil
+ return ToECDSA(common.HexBytes2Bytes(buf)), nil
}
// SaveECDSA saves a secp256k1 private key to the given file with restrictive
// permissions
func SaveECDSA(file string, key *ecdsa.PrivateKey) error {
- return ioutil.WriteFile(file, FromECDSA(key), 0600)
+ return ioutil.WriteFile(file, common.Bytes2HexBytes(FromECDSA(key)), 0600)
}
func GenerateKey() (*ecdsa.PrivateKey, error) {
--
cgit v1.2.3
From 6da5b2fc5fc0fe703158411afcd4f05add0336f2 Mon Sep 17 00:00:00 2001
From: Bas van Kervel <basvankervel@ziggo.nl>
Date: Thu, 9 Apr 2015 10:26:26 +0200
Subject: reformat code with goimports
---
cmd/utils/customflags.go | 152 +++++++++++++++++++++---------------------
cmd/utils/customflags_test.go | 34 +++++-----
cmd/utils/flags.go | 2 +-
3 files changed, 94 insertions(+), 94 deletions(-)
diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go
index 6d4a87bfb..a623ae19c 100644
--- a/cmd/utils/customflags.go
+++ b/cmd/utils/customflags.go
@@ -1,115 +1,118 @@
package utils
+
import (
- "path/filepath"
- "os"
- "strings"
- "os/user"
- "github.com/codegangsta/cli"
- "flag"
- "fmt"
+ "flag"
+ "fmt"
+ "os"
+ "os/user"
+ "path/filepath"
+ "strings"
+
+ "github.com/codegangsta/cli"
)
// Custom type which is registered in the flags library which cli uses for
// argument parsing. This allows us to expand Value to an absolute path when
// the argument is parsed
type DirectoryString struct {
- Value string
+ Value string
}
func (self DirectoryString) String() string {
- return self.Value
+ return self.Value
}
func (self DirectoryString) Set(value string) error {
- self.Value = expandPath(value)
- return nil
+ self.Value = expandPath(value)
+ return nil
}
// Custom cli.Flag type which expand the received string to an absolute path.
// e.g. ~/.ethereum -> /home/username/.ethereum
type DirectoryFlag struct {
- cli.GenericFlag
- Name string
- Value DirectoryString
- Usage string
- EnvVar string
+ cli.GenericFlag
+ Name string
+ Value DirectoryString
+ Usage string
+ EnvVar string
}
func (self DirectoryFlag) String() string {
- var fmtString string
- fmtString = "%s %v\t%v"
+ var fmtString string
+ fmtString = "%s %v\t%v"
- if len(self.Value.Value) > 0 {
- fmtString = "%s \"%v\"\t%v"
- } else {
- fmtString = "%s %v\t%v"
- }
+ if len(self.Value.Value) > 0 {
+ fmtString = "%s \"%v\"\t%v"
+ } else {
+ fmtString = "%s %v\t%v"
+ }
- return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage))
+ return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage))
}
func eachName(longName string, fn func(string)) {
- parts := strings.Split(longName, ",")
- for _, name := range parts {
- name = strings.Trim(name, " ")
- fn(name)
- }
+ parts := strings.Split(longName, ",")
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ fn(name)
+ }
}
+
// called by cli library, grabs variable from environment (if in env)
// and adds variable to flag set for parsing.
func (self DirectoryFlag) Apply(set *flag.FlagSet) {
- if self.EnvVar != "" {
- for _, envVar := range strings.Split(self.EnvVar, ",") {
- envVar = strings.TrimSpace(envVar)
- if envVal := os.Getenv(envVar); envVal != "" {
- self.Value.Value = envVal
- break
- }
- }
- }
-
- eachName(self.Name, func(name string) {
- set.Var(self.Value, self.Name, "a: " + self.Usage)
- })
+ if self.EnvVar != "" {
+ for _, envVar := range strings.Split(self.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ self.Value.Value = envVal
+ break
+ }
+ }
+ }
+
+ eachName(self.Name, func(name string) {
+ set.Var(self.Value, self.Name, "a: "+self.Usage)
+ })
}
func prefixFor(name string) (prefix string) {
- if len(name) == 1 {
- prefix = "-"
- } else {
- prefix = "--"
- }
+ if len(name) == 1 {
+ prefix = "-"
+ } else {
+ prefix = "--"
+ }
- return
+ return
}
func prefixedNames(fullName string) (prefixed string) {
- parts := strings.Split(fullName, ",")
- for i, name := range parts {
- name = strings.Trim(name, " ")
- prefixed += prefixFor(name) + name
- if i < len(parts)-1 {
- prefixed += ", "
- }
- }
- return
+ parts := strings.Split(fullName, ",")
+ for i, name := range parts {
+ name = strings.Trim(name, " ")
+ prefixed += prefixFor(name) + name
+ if i < len(parts)-1 {
+ prefixed += ", "
+ }
+ }
+ return
}
func withEnvHint(envVar, str string) string {
- envText := ""
- if envVar != "" {
- envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
- }
- return str + envText
+ envText := ""
+ if envVar != "" {
+ envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
+ }
+ return str + envText
}
func (self DirectoryFlag) getName() string {
- return self.Name
+ return self.Name
}
func (self *DirectoryFlag) Set(value string) {
- self.Value.Value = value
+ self.Value.Value = value
}
// Expands a file path
@@ -118,16 +121,13 @@ func (self *DirectoryFlag) Set(value string) {
// 3. cleans the path, e.g. /a/b/../c -> /a/c
// Note, it has limitations, e.g. ~someuser/tmp will not be expanded
func expandPath(p string) string {
- if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
- if user, err := user.Current(); err == nil {
- if err == nil {
- p = strings.Replace(p, "~", user.HomeDir, 1)
- }
- }
- }
-
- return filepath.Clean(os.ExpandEnv(p))
+ if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
+ if user, err := user.Current(); err == nil {
+ if err == nil {
+ p = strings.Replace(p, "~", user.HomeDir, 1)
+ }
+ }
+ }
+
+ return filepath.Clean(os.ExpandEnv(p))
}
-
-
-
diff --git a/cmd/utils/customflags_test.go b/cmd/utils/customflags_test.go
index 5674b939e..11deb38ef 100644
--- a/cmd/utils/customflags_test.go
+++ b/cmd/utils/customflags_test.go
@@ -1,28 +1,28 @@
package utils
import (
- "testing"
- "os"
- "os/user"
+ "os"
+ "os/user"
+ "testing"
)
func TestPathExpansion(t *testing.T) {
- user, _ := user.Current()
+ user, _ := user.Current()
- tests := map[string]string {
- "/home/someuser/tmp": "/home/someuser/tmp",
- "~/tmp": user.HomeDir + "/tmp",
- "$DDDXXX/a/b": "/tmp/a/b",
- "/a/b/": "/a/b",
- }
+ tests := map[string]string{
+ "/home/someuser/tmp": "/home/someuser/tmp",
+ "~/tmp": user.HomeDir + "/tmp",
+ "$DDDXXX/a/b": "/tmp/a/b",
+ "/a/b/": "/a/b",
+ }
- os.Setenv("DDDXXX", "/tmp")
+ os.Setenv("DDDXXX", "/tmp")
- for test, expected := range tests {
- got := expandPath(test)
- if got != expected {
- t.Errorf("test %s, got %s, expected %s\n", test, got, expected)
- }
- }
+ for test, expected := range tests {
+ got := expandPath(test)
+ if got != expected {
+ t.Errorf("test %s, got %s, expected %s\n", test, got, expected)
+ }
+ }
}
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 461d34ebc..bfd1ab990 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -69,7 +69,7 @@ func NewApp(version, usage string) *cli.App {
var (
// General settings
DataDirFlag = DirectoryFlag{
- Name: "datadir",
+ Name: "datadir",
Usage: "Data directory to be used",
Value: DirectoryString{common.DefaultDataDir()},
}
--
cgit v1.2.3
From ef393da9334adcf99187c0825df025596ae41fb3 Mon Sep 17 00:00:00 2001
From: Bas van Kervel <basvankervel@ziggo.nl>
Date: Thu, 9 Apr 2015 10:59:37 +0200
Subject: removed utility function and implemented hex conversation in crypto
functions
---
common/bytes.go | 12 ------------
crypto/crypto.go | 11 +++++++++--
2 files changed, 9 insertions(+), 14 deletions(-)
diff --git a/common/bytes.go b/common/bytes.go
index ba180ac94..5bdacd810 100644
--- a/common/bytes.go
+++ b/common/bytes.go
@@ -147,18 +147,6 @@ func Hex2Bytes(str string) []byte {
return h
}
-func HexBytes2Bytes(d []byte) []byte {
- r := make([]byte, hex.DecodedLen(len(d)))
- hex.Decode(r, d)
- return r
-}
-
-func Bytes2HexBytes(d []byte) []byte {
- r := make([]byte, hex.EncodedLen(len(d)))
- hex.Encode(r, d)
- return r
-}
-
func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) {
if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") {
ret = Hex2Bytes(str[2:])
diff --git a/crypto/crypto.go b/crypto/crypto.go
index 6e3ffbd4a..9865c87c4 100644
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -130,13 +130,20 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) {
if _, err := io.ReadFull(fd, buf); err != nil {
return nil, err
}
- return ToECDSA(common.HexBytes2Bytes(buf)), nil
+
+ key, err := hex.DecodeString(string(buf))
+ if err != nil {
+ return nil, err
+ }
+
+ return ToECDSA(key), nil
}
// SaveECDSA saves a secp256k1 private key to the given file with restrictive
// permissions
func SaveECDSA(file string, key *ecdsa.PrivateKey) error {
- return ioutil.WriteFile(file, common.Bytes2HexBytes(FromECDSA(key)), 0600)
+ k := hex.EncodeToString(FromECDSA(key))
+ return ioutil.WriteFile(file, []byte(k), 0600)
}
func GenerateKey() (*ecdsa.PrivateKey, error) {
--
cgit v1.2.3