swarm, cmd/swarm: Merge branch 'master' into multiple-ens-endpoints

Merge with changes that implement config file PR #15548.

Field *EnsApi string* in swarm/api.Config is replaced with
*EnsAPIs []string*.

A new field *EnsDisabled bool* is added to swarm/api.Config for
easy way to disable ENS resolving with config file.

Signature of function swarm.NewSwarm is changed and simplified.

13 files changed, 365 insertions, 252 deletions

diff --git a/swarm/api/config.go b/swarm/api/config.go
index d8d25b1c8..3f1a2a074 100644
--- a/swarm/api/config.go
+++ b/swarm/api/config.go
@@ -18,15 +18,15 @@ package api
 
 import (
 	"crypto/ecdsa"
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/contracts/ens"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/swarm/network"
 	"github.com/ethereum/go-ethereum/swarm/services/swap"
 	"github.com/ethereum/go-ethereum/swarm/storage"
@@ -46,101 +46,70 @@ type Config struct {
 	*network.HiveParams
 	Swap *swap.SwapParams
 	*network.SyncParams
-	Path       string
-	ListenAddr string
-	Port       string
-	PublicKey  string
-	BzzKey     string
-	EnsRoot    common.Address
-	NetworkId  uint64
+	Contract    common.Address
+	EnsRoot     common.Address
+	EnsDisabled bool
+	EnsAPIs     []string
+	Path        string
+	ListenAddr  string
+	Port        string
+	PublicKey   string
+	BzzKey      string
+	NetworkId   uint64
+	SwapEnabled bool
+	SyncEnabled bool
+	SwapApi     string
+	Cors        string
+	BzzAccount  string
+	BootNodes   string
 }
 
-// config is agnostic to where private key is coming from
-// so managing accounts is outside swarm and left to wrappers
-func NewConfig(path string, contract common.Address, prvKey *ecdsa.PrivateKey, networkId uint64) (self *Config, err error) {
-	address := crypto.PubkeyToAddress(prvKey.PublicKey) // default beneficiary address
-	dirpath := filepath.Join(path, "bzz-"+common.Bytes2Hex(address.Bytes()))
-	err = os.MkdirAll(dirpath, os.ModePerm)
-	if err != nil {
-		return
-	}
-	confpath := filepath.Join(dirpath, "config.json")
-	var data []byte
-	pubkey := crypto.FromECDSAPub(&prvKey.PublicKey)
-	pubkeyhex := common.ToHex(pubkey)
-	keyhex := crypto.Keccak256Hash(pubkey).Hex()
+//create a default config with all parameters to set to defaults
+func NewDefaultConfig() (self *Config) {
 
 	self = &Config{
-		SyncParams:    network.NewSyncParams(dirpath),
-		HiveParams:    network.NewHiveParams(dirpath),
+		StoreParams:   storage.NewDefaultStoreParams(),
 		ChunkerParams: storage.NewChunkerParams(),
-		StoreParams:   storage.NewStoreParams(dirpath),
+		HiveParams:    network.NewDefaultHiveParams(),
+		SyncParams:    network.NewDefaultSyncParams(),
+		Swap:          swap.NewDefaultSwapParams(),
 		ListenAddr:    DefaultHTTPListenAddr,
 		Port:          DefaultHTTPPort,
-		Path:          dirpath,
-		Swap:          swap.DefaultSwapParams(contract, prvKey),
-		PublicKey:     pubkeyhex,
-		BzzKey:        keyhex,
+		Path:          node.DefaultDataDir(),
+		EnsAPIs:       nil,
 		EnsRoot:       ens.TestNetAddress,
-		NetworkId:     networkId,
-	}
-	data, err = ioutil.ReadFile(confpath)
-
-	// if not set in function param, then set default for swarm network, will be overwritten by config file if present
-	if networkId == 0 {
-		self.NetworkId = network.NetworkId
+		EnsDisabled:   false,
+		NetworkId:     network.NetworkId,
+		SwapEnabled:   false,
+		SyncEnabled:   true,
+		SwapApi:       "",
+		BootNodes:     "",
 	}
 
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return
-		}
+	return
+}
 
-		// file does not exist
-		// write out config file
-		err = self.Save()
-		if err != nil {
-			err = fmt.Errorf("error writing config: %v", err)
-		}
-		return
-	}
+//some config params need to be initialized after the complete
+//config building phase is completed (e.g. due to overriding flags)
+func (self *Config) Init(prvKey *ecdsa.PrivateKey) {
 
-	// file exists, deserialise
-	err = json.Unmarshal(data, self)
+	address := crypto.PubkeyToAddress(prvKey.PublicKey)
+	self.Path = filepath.Join(self.Path, "bzz-"+common.Bytes2Hex(address.Bytes()))
+	err := os.MkdirAll(self.Path, os.ModePerm)
 	if err != nil {
-		return nil, fmt.Errorf("unable to parse config: %v", err)
-	}
-	// check public key
-	if pubkeyhex != self.PublicKey {
-		return nil, fmt.Errorf("public key does not match the one in the config file %v != %v", pubkeyhex, self.PublicKey)
-	}
-	if keyhex != self.BzzKey {
-		return nil, fmt.Errorf("bzz key does not match the one in the config file %v != %v", keyhex, self.BzzKey)
-	}
-
-	// if set in function param, replace id set from config file
-	if networkId != 0 {
-		self.NetworkId = networkId
+		log.Error(fmt.Sprintf("Error creating root swarm data directory: %v", err))
+		return
 	}
 
-	self.Swap.SetKey(prvKey)
-
-	if (self.EnsRoot == common.Address{}) {
-		self.EnsRoot = ens.TestNetAddress
-	}
+	pubkey := crypto.FromECDSAPub(&prvKey.PublicKey)
+	pubkeyhex := common.ToHex(pubkey)
+	keyhex := crypto.Keccak256Hash(pubkey).Hex()
 
-	return
-}
+	self.PublicKey = pubkeyhex
+	self.BzzKey = keyhex
 
-func (self *Config) Save() error {
-	data, err := json.MarshalIndent(self, "", "    ")
-	if err != nil {
-		return err
-	}
-	err = os.MkdirAll(self.Path, os.ModePerm)
-	if err != nil {
-		return err
-	}
-	confpath := filepath.Join(self.Path, "config.json")
-	return ioutil.WriteFile(confpath, data, os.ModePerm)
+	self.Swap.Init(self.Contract, prvKey)
+	self.SyncParams.Init(self.Path)
+	self.HiveParams.Init(self.Path)
+	self.StoreParams.Init(self.Path)
 }
diff --git a/swarm/api/config_test.go b/swarm/api/config_test.go
index 85d056270..2e03a610e 100644
--- a/swarm/api/config_test.go
+++ b/swarm/api/config_test.go
@@ -17,109 +17,53 @@
 package api
 
 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
+	"reflect"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
-var (
-	hexprvkey     = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
-	defaultConfig = `{
-    "ChunkDbPath": "` + filepath.Join("TMPDIR", "chunks") + `",
-    "DbCapacity": 5000000,
-    "CacheCapacity": 5000,
-    "Radius": 0,
-    "Branches": 128,
-    "Hash": "SHA3",
-    "CallInterval": 3000000000,
-    "KadDbPath": "` + filepath.Join("TMPDIR", "bzz-peers.json") + `",
-    "MaxProx": 8,
-    "ProxBinSize": 2,
-    "BucketSize": 4,
-    "PurgeInterval": 151200000000000,
-    "InitialRetryInterval": 42000000,
-    "MaxIdleInterval": 42000000000,
-    "ConnRetryExp": 2,
-    "Swap": {
-        "BuyAt": 20000000000,
-        "SellAt": 20000000000,
-        "PayAt": 100,
-        "DropAt": 10000,
-        "AutoCashInterval": 300000000000,
-        "AutoCashThreshold": 50000000000000,
-        "AutoDepositInterval": 300000000000,
-        "AutoDepositThreshold": 50000000000000,
-        "AutoDepositBuffer": 100000000000000,
-        "PublicKey": "0x045f5cfd26692e48d0017d380349bcf50982488bc11b5145f3ddf88b24924299048450542d43527fbe29a5cb32f38d62755393ac002e6bfdd71b8d7ba725ecd7a3",
-        "Contract": "0x0000000000000000000000000000000000000000",
-        "Beneficiary": "0x0d2f62485607cf38d9d795d93682a517661e513e"
-    },
-    "RequestDbPath": "` + filepath.Join("TMPDIR", "requests") + `",
-    "RequestDbBatchSize": 512,
-    "KeyBufferSize": 1024,
-    "SyncBatchSize": 128,
-    "SyncBufferSize": 128,
-    "SyncCacheSize": 1024,
-    "SyncPriorities": [
-        2,
-        1,
-        1,
-        0,
-        0
-    ],
-    "SyncModes": [
-        true,
-        true,
-        true,
-        true,
-        false
-    ],
-    "Path": "TMPDIR",
-    "ListenAddr": "127.0.0.1",
-    "Port": "8500",
-    "PublicKey": "0x045f5cfd26692e48d0017d380349bcf50982488bc11b5145f3ddf88b24924299048450542d43527fbe29a5cb32f38d62755393ac002e6bfdd71b8d7ba725ecd7a3",
-    "BzzKey": "0xe861964402c0b78e2d44098329b8545726f215afa737d803714a4338552fcb81",
-    "EnsRoot": "0x112234455c3a32fd11230c42e7bccd4a84e02010",
-    "NetworkId": 323
-}`
-)
+func TestConfig(t *testing.T) {
 
-func TestConfigWriteRead(t *testing.T) {
-	tmp, err := ioutil.TempDir(os.TempDir(), "bzz-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
+	var hexprvkey = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
 
 	prvkey, err := crypto.HexToECDSA(hexprvkey)
 	if err != nil {
 		t.Fatalf("failed to load private key: %v", err)
 	}
-	orig, err := NewConfig(tmp, common.Address{}, prvkey, 323)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
+
+	one := NewDefaultConfig()
+	two := NewDefaultConfig()
+
+	if equal := reflect.DeepEqual(one, two); equal == false {
+		t.Fatal("Two default configs are not equal")
 	}
-	data, err := ioutil.ReadFile(filepath.Join(orig.Path, "config.json"))
-	if err != nil {
-		t.Fatalf("default config file cannot be read: %v", err)
+
+	one.Init(prvkey)
+
+	//the init function should set the following fields
+	if one.BzzKey == "" {
+		t.Fatal("Expected BzzKey to be set")
 	}
-	exp := strings.Replace(defaultConfig, "TMPDIR", orig.Path, -1)
-	exp = strings.Replace(exp, "\\", "\\\\", -1)
-	if string(data) != exp {
-		t.Fatalf("default config mismatch:\nexpected: %v\ngot: %v", exp, string(data))
+	if one.PublicKey == "" {
+		t.Fatal("Expected PublicKey to be set")
 	}
 
-	conf, err := NewConfig(tmp, common.Address{}, prvkey, 323)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
+	//the Init function should append subdirs to the given path
+	if one.Swap.PayProfile.Beneficiary == (common.Address{}) {
+		t.Fatal("Failed to correctly initialize SwapParams")
 	}
-	if conf.Swap.Beneficiary.Hex() != orig.Swap.Beneficiary.Hex() {
-		t.Fatalf("expected beneficiary from loaded config %v to match original %v", conf.Swap.Beneficiary.Hex(), orig.Swap.Beneficiary.Hex())
+
+	if one.SyncParams.RequestDbPath == one.Path {
+		t.Fatal("Failed to correctly initialize SyncParams")
 	}
 
+	if one.HiveParams.KadDbPath == one.Path {
+		t.Fatal("Failed to correctly initialize HiveParams")
+	}
+
+	if one.StoreParams.ChunkDbPath == one.Path {
+		t.Fatal("Failed to correctly initialize StoreParams")
+	}
 }
diff --git a/swarm/api/manifest.go b/swarm/api/manifest.go
index 32b5f80a7..685a300fc 100644
--- a/swarm/api/manifest.go
+++ b/swarm/api/manifest.go
@@ -436,6 +436,16 @@ func (self *manifestTrie) findPrefixOf(path string, quitC chan bool) (entry *man
 	if len(path) <= epl {
 		if entry.Path[:len(path)] == path {
 			if entry.ContentType == ManifestType {
+				err := self.loadSubTrie(entry, quitC)
+				if err == nil && entry.subtrie != nil {
+					subentries := entry.subtrie.entries
+					for i := 0; i < len(subentries); i++ {
+						sub := subentries[i]
+						if sub != nil && sub.Path == "" {
+							return sub, len(path)
+						}
+					}
+				}
 				entry.Status = http.StatusMultipleChoices
 			}
 			pos = len(path)
diff --git a/swarm/api/manifest_test.go b/swarm/api/manifest_test.go
index f048627c5..7098ca16f 100644
--- a/swarm/api/manifest_test.go
+++ b/swarm/api/manifest_test.go
@@ -21,6 +21,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"net/http"
 	"strings"
 	"testing"
 
@@ -39,17 +40,17 @@ func manifest(paths ...string) (manifestReader storage.LazySectionReader) {
 	}
 }
 
-func testGetEntry(t *testing.T, path, match string, paths ...string) *manifestTrie {
+func testGetEntry(t *testing.T, path, match string, multiple bool, paths ...string) *manifestTrie {
 	quitC := make(chan bool)
 	trie, err := readManifest(manifest(paths...), nil, nil, quitC)
 	if err != nil {
 		t.Errorf("unexpected error making manifest: %v", err)
 	}
-	checkEntry(t, path, match, trie)
+	checkEntry(t, path, match, multiple, trie)
 	return trie
 }
 
-func checkEntry(t *testing.T, path, match string, trie *manifestTrie) {
+func checkEntry(t *testing.T, path, match string, multiple bool, trie *manifestTrie) {
 	entry, fullpath := trie.getEntry(path)
 	if match == "-" && entry != nil {
 		t.Errorf("expected no match for '%s', got '%s'", path, fullpath)
@@ -60,32 +61,55 @@ func checkEntry(t *testing.T, path, match string, trie *manifestTrie) {
 	} else if fullpath != match {
 		t.Errorf("incorrect entry retrieved for '%s'. expected path '%v', got '%s'", path, match, fullpath)
 	}
+
+	if multiple && entry.Status != http.StatusMultipleChoices {
+		t.Errorf("Expected %d Multiple Choices Status for path %s, match %s, got %d", http.StatusMultipleChoices, path, match, entry.Status)
+	} else if !multiple && entry != nil && entry.Status == http.StatusMultipleChoices {
+		t.Errorf("Were not expecting %d Multiple Choices Status for path %s, match %s, but got it", http.StatusMultipleChoices, path, match)
+	}
 }
 
 func TestGetEntry(t *testing.T) {
 	// file system manifest always contains regularized paths
-	testGetEntry(t, "a", "a", "a")
-	testGetEntry(t, "b", "-", "a")
-	testGetEntry(t, "/a//", "a", "a")
+	testGetEntry(t, "a", "a", false, "a")
+	testGetEntry(t, "b", "-", false, "a")
+	testGetEntry(t, "/a//", "a", false, "a")
 	// fallback
-	testGetEntry(t, "/a", "", "")
-	testGetEntry(t, "/a/b", "a/b", "a/b")
+	testGetEntry(t, "/a", "", false, "")
+	testGetEntry(t, "/a/b", "a/b", false, "a/b")
 	// longest/deepest math
-	testGetEntry(t, "read", "read", "readme.md", "readit.md")
-	testGetEntry(t, "rf", "-", "readme.md", "readit.md")
-	testGetEntry(t, "readme", "readme", "readme.md")
-	testGetEntry(t, "readme", "-", "readit.md")
-	testGetEntry(t, "readme.md", "readme.md", "readme.md")
-	testGetEntry(t, "readme.md", "-", "readit.md")
-	testGetEntry(t, "readmeAmd", "-", "readit.md")
-	testGetEntry(t, "readme.mdffff", "-", "readme.md")
-	testGetEntry(t, "ab", "ab", "ab/cefg", "ab/cedh", "ab/kkkkkk")
-	testGetEntry(t, "ab/ce", "ab/ce", "ab/cefg", "ab/cedh", "ab/ceuuuuuuuuuu")
-	testGetEntry(t, "abc", "abc", "abcd", "abczzzzef", "abc/def", "abc/e/g")
-	testGetEntry(t, "a/b", "a/b", "a", "a/bc", "a/ba", "a/b/c")
-	testGetEntry(t, "a/b", "a/b", "a", "a/b", "a/bb", "a/b/c")
-	testGetEntry(t, "//a//b//", "a/b", "a", "a/b", "a/bb", "a/b/c")
+	testGetEntry(t, "read", "read", true, "readme.md", "readit.md")
+	testGetEntry(t, "rf", "-", false, "readme.md", "readit.md")
+	testGetEntry(t, "readme", "readme", false, "readme.md")
+	testGetEntry(t, "readme", "-", false, "readit.md")
+	testGetEntry(t, "readme.md", "readme.md", false, "readme.md")
+	testGetEntry(t, "readme.md", "-", false, "readit.md")
+	testGetEntry(t, "readmeAmd", "-", false, "readit.md")
+	testGetEntry(t, "readme.mdffff", "-", false, "readme.md")
+	testGetEntry(t, "ab", "ab", true, "ab/cefg", "ab/cedh", "ab/kkkkkk")
+	testGetEntry(t, "ab/ce", "ab/ce", true, "ab/cefg", "ab/cedh", "ab/ceuuuuuuuuuu")
+	testGetEntry(t, "abc", "abc", true, "abcd", "abczzzzef", "abc/def", "abc/e/g")
+	testGetEntry(t, "a/b", "a/b", true, "a", "a/bc", "a/ba", "a/b/c")
+	testGetEntry(t, "a/b", "a/b", false, "a", "a/b", "a/bb", "a/b/c")
+	testGetEntry(t, "//a//b//", "a/b", false, "a", "a/b", "a/bb", "a/b/c")
 }
+
+func TestExactMatch(t *testing.T) {
+	quitC := make(chan bool)
+	mf := manifest("shouldBeExactMatch.css", "shouldBeExactMatch.css.map")
+	trie, err := readManifest(mf, nil, nil, quitC)
+	if err != nil {
+		t.Errorf("unexpected error making manifest: %v", err)
+	}
+	entry, _ := trie.getEntry("shouldBeExactMatch.css")
+	if entry.Path != "" {
+		t.Errorf("Expected entry to match %s, got: %s", "shouldBeExactMatch.css", entry.Path)
+	}
+	if entry.Status == http.StatusMultipleChoices {
+		t.Errorf("Got status %d, which is unexepcted", http.StatusMultipleChoices)
+	}
+}
+
 func TestDeleteEntry(t *testing.T) {
 
 }
@@ -108,15 +132,15 @@ func TestAddFileWithManifestPath(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	checkEntry(t, "ab", "ab", trie)
-	checkEntry(t, "ac", "ac", trie)
+	checkEntry(t, "ab", "ab", false, trie)
+	checkEntry(t, "ac", "ac", false, trie)
 
 	// now add path "a" and check we can still get "ab" and "ac"
 	entry := &manifestTrieEntry{}
 	entry.Path = "a"
 	entry.Hash = "a"
 	trie.addEntry(entry, nil)
-	checkEntry(t, "ab", "ab", trie)
-	checkEntry(t, "ac", "ac", trie)
-	checkEntry(t, "a", "a", trie)
+	checkEntry(t, "ab", "ab", false, trie)
+	checkEntry(t, "ac", "ac", false, trie)
+	checkEntry(t, "a", "a", false, trie)
 }
diff --git a/swarm/network/hive.go b/swarm/network/hive.go
index d37b7e400..2504a4610 100644
--- a/swarm/network/hive.go
+++ b/swarm/network/hive.go
@@ -70,19 +70,25 @@ type HiveParams struct {
 	*kademlia.KadParams
 }
 
-func NewHiveParams(path string) *HiveParams {
-	kad := kademlia.NewKadParams()
+//create default params
+func NewDefaultHiveParams() *HiveParams {
+	kad := kademlia.NewDefaultKadParams()
 	// kad.BucketSize = bucketSize
 	// kad.MaxProx = maxProx
 	// kad.ProxBinSize = proxBinSize
 
 	return &HiveParams{
 		CallInterval: callInterval,
-		KadDbPath:    filepath.Join(path, "bzz-peers.json"),
 		KadParams:    kad,
 	}
 }
 
+//this can only finally be set after all config options (file, cmd line, env vars)
+//have been evaluated
+func (self *HiveParams) Init(path string) {
+	self.KadDbPath = filepath.Join(path, "bzz-peers.json")
+}
+
 func NewHive(addr common.Hash, params *HiveParams, swapEnabled, syncEnabled bool) *Hive {
 	kad := kademlia.New(kademlia.Address(addr), params.KadParams)
 	return &Hive{
diff --git a/swarm/network/kademlia/kaddb.go b/swarm/network/kademlia/kaddb.go
index cb0869467..b37ced5ba 100644
--- a/swarm/network/kademlia/kaddb.go
+++ b/swarm/network/kademlia/kaddb.go
@@ -330,7 +330,7 @@ func (self *KadDb) load(path string, cb func(*NodeRecord, Node) error) (err erro
 				}
 			}
 			n++
-			if (node.After == time.Time{}) {
+			if node.After.IsZero() {
 				node.After = time.Now()
 			}
 			self.index[node.Addr] = node
diff --git a/swarm/network/kademlia/kademlia.go b/swarm/network/kademlia/kademlia.go
index bf976a3e1..0abc42a19 100644
--- a/swarm/network/kademlia/kademlia.go
+++ b/swarm/network/kademlia/kademlia.go
@@ -52,7 +52,7 @@ type KadParams struct {
 	ConnRetryExp         int
 }
 
-func NewKadParams() *KadParams {
+func NewDefaultKadParams() *KadParams {
 	return &KadParams{
 		MaxProx:              maxProx,
 		ProxBinSize:          proxBinSize,
diff --git a/swarm/network/kademlia/kademlia_test.go b/swarm/network/kademlia/kademlia_test.go
index 417ccecae..88858908a 100644
--- a/swarm/network/kademlia/kademlia_test.go
+++ b/swarm/network/kademlia/kademlia_test.go
@@ -63,7 +63,7 @@ func TestOn(t *testing.T) {
 	if !ok1 || !ok2 {
 		t.Errorf("oops")
 	}
-	kad := New(addr, NewKadParams())
+	kad := New(addr, NewDefaultKadParams())
 	err := kad.On(&testNode{addr: other}, nil)
 	_ = err
 }
@@ -72,7 +72,7 @@ func TestBootstrap(t *testing.T) {
 
 	test := func(test *bootstrapTest) bool {
 		// for any node kad.le, Target and N
-		params := NewKadParams()
+		params := NewDefaultKadParams()
 		params.MaxProx = test.MaxProx
 		params.BucketSize = test.BucketSize
 		params.ProxBinSize = test.BucketSize
@@ -127,7 +127,7 @@ func TestFindClosest(t *testing.T) {
 
 	test := func(test *FindClosestTest) bool {
 		// for any node kad.le, Target and N
-		params := NewKadParams()
+		params := NewDefaultKadParams()
 		params.MaxProx = 7
 		kad := New(test.Self, params)
 		var err error
@@ -198,7 +198,7 @@ var (
 func TestProxAdjust(t *testing.T) {
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	self := gen(Address{}, r).(Address)
-	params := NewKadParams()
+	params := NewDefaultKadParams()
 	params.MaxProx = 7
 	kad := New(self, params)
 
@@ -232,7 +232,7 @@ func TestSaveLoad(t *testing.T) {
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	addresses := gen([]Address{}, r).([]Address)
 	self := RandomAddress()
-	params := NewKadParams()
+	params := NewDefaultKadParams()
 	params.MaxProx = 7
 	kad := New(self, params)
 
diff --git a/swarm/network/syncer.go b/swarm/network/syncer.go
index d76af022c..6d729fcb9 100644
--- a/swarm/network/syncer.go
+++ b/swarm/network/syncer.go
@@ -131,9 +131,8 @@ type SyncParams struct {
 }
 
 // constructor with default values
-func NewSyncParams(bzzdir string) *SyncParams {
+func NewDefaultSyncParams() *SyncParams {
 	return &SyncParams{
-		RequestDbPath:      filepath.Join(bzzdir, "requests"),
 		RequestDbBatchSize: requestDbBatchSize,
 		KeyBufferSize:      keyBufferSize,
 		SyncBufferSize:     syncBufferSize,
@@ -144,6 +143,12 @@ func NewSyncParams(bzzdir string) *SyncParams {
 	}
 }
 
+//this can only finally be set after all config options (file, cmd line, env vars)
+//have been evaluated
+func (self *SyncParams) Init(path string) {
+	self.RequestDbPath = filepath.Join(path, "requests")
+}
+
 // syncer is the agent that manages content distribution/storage replication/chunk storeRequest forwarding
 type syncer struct {
 	*SyncParams                     // sync parameters
diff --git a/swarm/services/swap/swap.go b/swarm/services/swap/swap.go
index 093892e8d..1f9b22b90 100644
--- a/swarm/services/swap/swap.go
+++ b/swarm/services/swap/swap.go
@@ -80,17 +80,10 @@ type PayProfile struct {
 	lock        sync.RWMutex
 }
 
-func DefaultSwapParams(contract common.Address, prvkey *ecdsa.PrivateKey) *SwapParams {
-	pubkey := &prvkey.PublicKey
+//create params with default values
+func NewDefaultSwapParams() *SwapParams {
 	return &SwapParams{
-		PayProfile: &PayProfile{
-			PublicKey:   common.ToHex(crypto.FromECDSAPub(pubkey)),
-			Contract:    contract,
-			Beneficiary: crypto.PubkeyToAddress(*pubkey),
-			privateKey:  prvkey,
-			publicKey:   pubkey,
-			owner:       crypto.PubkeyToAddress(*pubkey),
-		},
+		PayProfile: &PayProfile{},
 		Params: &swap.Params{
 			Profile: &swap.Profile{
 				BuyAt:  buyAt,
@@ -109,6 +102,21 @@ func DefaultSwapParams(contract common.Address, prvkey *ecdsa.PrivateKey) *SwapP
 	}
 }
 
+//this can only finally be set after all config options (file, cmd line, env vars)
+//have been evaluated
+func (self *SwapParams) Init(contract common.Address, prvkey *ecdsa.PrivateKey) {
+	pubkey := &prvkey.PublicKey
+
+	self.PayProfile = &PayProfile{
+		PublicKey:   common.ToHex(crypto.FromECDSAPub(pubkey)),
+		Contract:    contract,
+		Beneficiary: crypto.PubkeyToAddress(*pubkey),
+		privateKey:  prvkey,
+		publicKey:   pubkey,
+		owner:       crypto.PubkeyToAddress(*pubkey),
+	}
+}
+
 // swap constructor, parameters
 // * global chequebook, assume deployed service and
 // * the balance is at buffer.
diff --git a/swarm/storage/netstore.go b/swarm/storage/netstore.go
index 7b0612edc..5d4f17deb 100644
--- a/swarm/storage/netstore.go
+++ b/swarm/storage/netstore.go
@@ -57,15 +57,21 @@ type StoreParams struct {
 	Radius        int
 }
 
-func NewStoreParams(path string) (self *StoreParams) {
+//create params with default values
+func NewDefaultStoreParams() (self *StoreParams) {
 	return &StoreParams{
-		ChunkDbPath:   filepath.Join(path, "chunks"),
 		DbCapacity:    defaultDbCapacity,
 		CacheCapacity: defaultCacheCapacity,
 		Radius:        defaultRadius,
 	}
 }
 
+//this can only finally be set after all config options (file, cmd line, env vars)
+//have been evaluated
+func (self *StoreParams) Init(path string) {
+	self.ChunkDbPath = filepath.Join(path, "chunks")
+}
+
 // netstore contructor, takes path argument that is used to initialise dbStore,
 // the persistent (disk) storage component of LocalStore
 // the second argument is the hive, the connection/logistics manager for the node
diff --git a/swarm/swarm.go b/swarm/swarm.go
index 9b6abc5b9..ae6805dfd 100644
--- a/swarm/swarm.go
+++ b/swarm/swarm.go
@@ -23,7 +23,9 @@ import (
 	"fmt"
 	"math/big"
 	"net"
+	"strings"
 	"time"
+	"unicode"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -79,7 +81,7 @@ func (self *Swarm) API() *SwarmAPI {
 
 // creates a new swarm service instance
 // implements node.Service
-func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClientConfigs []ENSClientConfig, config *api.Config, swapEnabled, syncEnabled bool, cors string) (self *Swarm, err error) {
+func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.Config) (self *Swarm, err error) {
 	if bytes.Equal(common.FromHex(config.PublicKey), storage.ZeroKey) {
 		return nil, fmt.Errorf("empty public key")
 	}
@@ -89,10 +91,10 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClientCon
 
 	self = &Swarm{
 		config:      config,
-		swapEnabled: swapEnabled,
+		swapEnabled: config.SwapEnabled,
 		backend:     backend,
 		privateKey:  config.Swap.PrivateKey(),
-		corsString:  cors,
+		corsString:  config.Cors,
 	}
 	log.Debug(fmt.Sprintf("Setting up Swarm service components"))
 
@@ -112,8 +114,8 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClientCon
 	self.hive = network.NewHive(
 		common.HexToHash(self.config.BzzKey), // key to hive (kademlia base address)
 		config.HiveParams,                    // configuration parameters
-		swapEnabled,                          // SWAP enabled
-		syncEnabled,                          // syncronisation enabled
+		config.SwapEnabled,                   // SWAP enabled
+		config.SyncEnabled,                   // syncronisation enabled
 	)
 	log.Debug(fmt.Sprintf("Set up swarm network with Kademlia hive"))
 
@@ -136,21 +138,26 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClientCon
 	self.dpa = storage.NewDPA(dpaChunkStore, self.config.ChunkerParams)
 	log.Debug(fmt.Sprintf("-> Content Store API"))
 
-	if len(ensClientConfigs) == 1 {
-		self.dns, err = newEnsClient(ensClientConfigs[0].Endpoint, ensClientConfigs[0].ContractAddress, config)
-		if err != nil {
-			return nil, err
-		}
-	} else if len(ensClientConfigs) > 1 {
-		opts := []api.MultiResolverOption{}
-		for _, c := range ensClientConfigs {
-			r, err := newEnsClient(c.Endpoint, c.ContractAddress, config)
+	if !config.EnsDisabled {
+		if len(config.EnsAPIs) == 0 {
+			// ENS is enabled and has no specific configuration,
+			// use defaults
+			self.dns, err = newEnsClient(node.DefaultIPCEndpoint("geth"), config.EnsRoot, config)
 			if err != nil {
 				return nil, err
 			}
-			opts = append(opts, api.MultiResolverOptionWithResolver(r, c.TLD))
+		} else {
+			opts := []api.MultiResolverOption{}
+			for _, c := range config.EnsAPIs {
+				tld, endpoint, addr := parseEnsAPIAddress(c)
+				r, err := newEnsClient(endpoint, addr, config)
+				if err != nil {
+					return nil, err
+				}
+				opts = append(opts, api.MultiResolverOptionWithResolver(r, tld))
+			}
+			self.dns = api.NewMultiResolver(opts...)
 		}
-		self.dns = api.NewMultiResolver(opts...)
 	}
 
 	self.api = api.NewApi(self.dpa, self.dns)
@@ -163,19 +170,36 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClientCon
 	return self, nil
 }
 
-// ENSClientConfig holds information to construct ENS resolver. If TLD is non-empty,
-// the resolver will be used only for that TLD. If ContractAddress is empty,
-// it will be discovered by the client, or used one from the configuration.
-type ENSClientConfig struct {
-	Endpoint        string
-	ContractAddress string
-	TLD             string
+// parseEnsAPIAddress parses string according to format
+// [tld:][contract-addr@]url and returns ENSClientConfig structure
+// with endpoint, contract address and TLD.
+func parseEnsAPIAddress(s string) (tld, endpoint string, addr common.Address) {
+	isAllLetterString := func(s string) bool {
+		for _, r := range s {
+			if !unicode.IsLetter(r) {
+				return false
+			}
+		}
+		return true
+	}
+	endpoint = s
+	if i := strings.Index(endpoint, ":"); i > 0 {
+		if isAllLetterString(endpoint[:i]) && len(endpoint) > i+2 && endpoint[i+1:i+3] != "//" {
+			tld = endpoint[:i]
+			endpoint = endpoint[i+1:]
+		}
+	}
+	if i := strings.Index(endpoint, "@"); i > 0 {
+		addr = common.HexToAddress(endpoint[:i])
+		endpoint = endpoint[i+1:]
+	}
+	return
 }
 
 // newEnsClient creates a new ENS client for that is a consumer of
 // a ENS API on a specific endpoint. It is used as a helper function
 // for creating multiple resolvers in NewSwarm function.
-func newEnsClient(endpoint, addr string, config *api.Config) (*ens.ENS, error) {
+func newEnsClient(endpoint string, addr common.Address, config *api.Config) (*ens.ENS, error) {
 	log.Info("connecting to ENS API", "url", endpoint)
 	client, err := rpc.Dial(endpoint)
 	if err != nil {
@@ -184,8 +208,8 @@ func newEnsClient(endpoint, addr string, config *api.Config) (*ens.ENS, error) {
 	ensClient := ethclient.NewClient(client)
 
 	ensRoot := config.EnsRoot
-	if addr != "" {
-		ensRoot = common.HexToAddress(addr)
+	if addr != (common.Address{}) {
+		ensRoot = addr
 	} else {
 		a, err := detectEnsAddr(client)
 		if err == nil {
@@ -299,7 +323,7 @@ func (self *Swarm) Start(srv *p2p.Server) error {
 // stops all component services.
 func (self *Swarm) Stop() error {
 	self.dpa.Stop()
-	self.hive.Stop()
+	err := self.hive.Stop()
 	if ch := self.config.Swap.Chequebook(); ch != nil {
 		ch.Stop()
 		ch.Save()
@@ -309,7 +333,7 @@ func (self *Swarm) Stop() error {
 		self.lstore.DbStore.Close()
 	}
 	self.sfs.Stop()
-	return self.config.Save()
+	return err
 }
 
 // implements the node.Service interface
@@ -380,7 +404,6 @@ func (self *Swarm) SetChequebook(ctx context.Context) error {
 		return err
 	}
 	log.Info(fmt.Sprintf("new chequebook set (%v): saving config file, resetting all connections in the hive", self.config.Swap.Contract.Hex()))
-	self.config.Save()
 	self.hive.DropAll()
 	return nil
 }
@@ -393,10 +416,9 @@ func NewLocalSwarm(datadir, port string) (self *Swarm, err error) {
 		return
 	}
 
-	config, err := api.NewConfig(datadir, common.Address{}, prvKey, network.NetworkId)
-	if err != nil {
-		return
-	}
+	config := api.NewDefaultConfig()
+	config.Path = datadir
+	config.Init(prvKey)
 	config.Port = port
 
 	dpa, err := storage.NewLocalDPA(datadir)
diff --git a/swarm/swarm_test.go b/swarm/swarm_test.go
new file mode 100644
index 000000000..8b1ae2888
--- /dev/null
+++ b/swarm/swarm_test.go
@@ -0,0 +1,119 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package swarm
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func TestParseEnsAPIAddress(t *testing.T) {
+	for _, x := range []struct {
+		description string
+		value       string
+		tld         string
+		endpoint    string
+		addr        common.Address
+	}{
+		{
+			description: "IPC endpoint",
+			value:       "/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+		},
+		{
+			description: "HTTP endpoint",
+			value:       "http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+		},
+		{
+			description: "WS endpoint",
+			value:       "ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+		},
+		{
+			description: "IPC Endpoint and TLD",
+			value:       "test:/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			tld:         "test",
+		},
+		{
+			description: "HTTP endpoint and TLD",
+			value:       "test:http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			tld:         "test",
+		},
+		{
+			description: "WS endpoint and TLD",
+			value:       "test:ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			tld:         "test",
+		},
+		{
+			description: "IPC Endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "HTTP endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "WS endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "IPC Endpoint, TLD and contract address",
+			value:       "test:314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "test",
+		},
+		{
+			description: "HTTP endpoint, TLD and contract address",
+			value:       "eth:314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "eth",
+		},
+		{
+			description: "WS endpoint, TLD and contract address",
+			value:       "eth:314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "eth",
+		},
+	} {
+		t.Run(x.description, func(t *testing.T) {
+			tld, endpoint, addr := parseEnsAPIAddress(x.value)
+			if endpoint != x.endpoint {
+				t.Errorf("expected Endpoint %q, got %q", x.endpoint, endpoint)
+			}
+			if addr != x.addr {
+				t.Errorf("expected ContractAddress %q, got %q", x.addr.String(), addr.String())
+			}
+			if tld != x.tld {
+				t.Errorf("expected TLD %q, got %q", x.tld, tld)
+			}
+		})
+	}
+}