Merge branch 'develop' of github.com-obscure:ethereum/go-ethereum into develop

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
+The keyfile is assumed to contain an unencrypted private key in hexadecimal format.
-raw bytes format.
 
 The account is saved in encrypted format, you are prompted for a passphrase.
 

cmd/utils/customflags.go

@@ -0,0 +1,133 @@
+package utils
+
+import (
+	"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
+}
+
+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))
+}

cmd/utils/customflags_test.go

@@ -0,0 +1,28 @@
+package utils
+
+import (
+	"os"
+	"os/user"
+	"testing"
+)
+
+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)
+		}
+	}
+}

cmd/utils/flags.go

@@ -68,10 +68,10 @@ func NewApp(version, usage string) *cli.App {
 
 var (
 	// General settings
-	DataDirFlag = cli.StringFlag{
+	DataDirFlag = DirectoryFlag{
 		Name:  "datadir",
 		Usage: "Data directory to be used",
-		Value: common.DefaultDataDir(),
+		Value: DirectoryString{common.DefaultDataDir()},
 	}
 	ProtocolVersionFlag = cli.IntFlag{
 		Name:  "protocolversion",

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,20 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) {
 	if _, err := io.ReadFull(fd, buf); err != nil {
 		return nil, err
 	}
-	return ToECDSA(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, FromECDSA(key), 0600)
+	k := hex.EncodeToString(FromECDSA(key))
+	return ioutil.WriteFile(file, []byte(k), 0600)
 }
 
 func GenerateKey() (*ecdsa.PrivateKey, error) {