cmd/geth: add --config file flag (#13875)

* p2p/discover, p2p/discv5: add marshaling methods to Node

* p2p/netutil: make Netlist decodable from TOML

* common/math: encode nil HexOrDecimal256 as 0x0

* cmd/geth: add --config file flag

* cmd/geth: add missing license header

* eth: prettify Config again, fix tests

* eth: use gasprice.Config instead of duplicating its fields

* eth/gasprice: hide nil default from dumpconfig output

* cmd/geth: hide genesis block in dumpconfig output

* node: make tests compile

* console: fix tests

* cmd/geth: make TOML keys look exactly like Go struct fields

* p2p: use discovery by default

This makes the zero Config slightly more useful. It also fixes package
node tests because Node detects reuse of the datadir through the
NodeDatabase.

* cmd/geth: make ethstats URL settable through config file

* cmd/faucet: fix configuration

* cmd/geth: dedup attach tests

* eth: add comment for DefaultConfig

* eth: pass downloader.SyncMode in Config

This removes the FastSync, LightSync flags in favour of a more
general SyncMode flag.

* cmd/utils: remove jitvm flags

* cmd/utils: make mutually exclusive flag error prettier

It now reads:

   Fatal: flags --dev, --testnet can't be used at the same time

* p2p: fix typo

* node: add DefaultConfig, use it for geth

* mobile: add missing NoDiscovery option

* cmd/utils: drop MakeNode

This exposed a couple of places that needed to be updated to use
node.DefaultConfig.

* node: fix typo

* eth: make fast sync the default mode

* cmd/utils: remove IPCApiFlag (unused)

* node: remove default IPC path

Set it in the frontends instead.

* cmd/geth: add --syncmode

* cmd/utils: make --ipcdisable and --ipcpath mutually exclusive

* cmd/utils: don't enable WS, HTTP when setting addr

* cmd/utils: fix --identity

vendor/github.com/naoina/toml/error.go

@@ -0,0 +1,107 @@
+package toml
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+var (
+	errArrayMultiType = errors.New("array can't contain multiple types")
+)
+
+// LineError is returned by Unmarshal, UnmarshalTable and Parse
+// if the error is local to a line.
+type LineError struct {
+	Line        int
+	StructField string
+	Err         error
+}
+
+func (err *LineError) Error() string {
+	field := ""
+	if err.StructField != "" {
+		field = "(" + err.StructField + ") "
+	}
+	return fmt.Sprintf("line %d: %s%v", err.Line, field, err.Err)
+}
+
+func lineError(line int, err error) error {
+	if err == nil {
+		return nil
+	}
+	if _, ok := err.(*LineError); ok {
+		return err
+	}
+	return &LineError{Line: line, Err: err}
+}
+
+func lineErrorField(line int, field string, err error) error {
+	if lerr, ok := err.(*LineError); ok {
+		return lerr
+	} else if err != nil {
+		err = &LineError{Line: line, StructField: field, Err: err}
+	}
+	return err
+}
+
+type overflowError struct {
+	kind reflect.Kind
+	v    string
+}
+
+func (err *overflowError) Error() string {
+	return fmt.Sprintf("value %s is out of range for %v", err.v, err.kind)
+}
+
+func convertNumError(kind reflect.Kind, err error) error {
+	if numerr, ok := err.(*strconv.NumError); ok && numerr.Err == strconv.ErrRange {
+		return &overflowError{kind, numerr.Num}
+	}
+	return err
+}
+
+type invalidUnmarshalError struct {
+	typ reflect.Type
+}
+
+func (err *invalidUnmarshalError) Error() string {
+	if err.typ == nil {
+		return "toml: Unmarshal(nil)"
+	}
+	if err.typ.Kind() != reflect.Ptr {
+		return "toml: Unmarshal(non-pointer " + err.typ.String() + ")"
+	}
+	return "toml: Unmarshal(nil " + err.typ.String() + ")"
+}
+
+type unmarshalTypeError struct {
+	what string
+	want string
+	typ  reflect.Type
+}
+
+func (err *unmarshalTypeError) Error() string {
+	msg := fmt.Sprintf("cannot unmarshal TOML %s into %s", err.what, err.typ)
+	if err.want != "" {
+		msg += " (need " + err.want + ")"
+	}
+	return msg
+}
+
+type marshalNilError struct {
+	typ reflect.Type
+}
+
+func (err *marshalNilError) Error() string {
+	return fmt.Sprintf("toml: cannot marshal nil %s", err.typ)
+}
+
+type marshalTableError struct {
+	typ reflect.Type
+}
+
+func (err *marshalTableError) Error() string {
+	return fmt.Sprintf("toml: cannot marshal %s as table, want struct or map type", err.typ)
+}