One more translation update

Reject Index and Request messages with unexpected flags

AUTHORS

@@ -8,6 +8,7 @@ Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
 Ben Schulz <ueomkail@gmail.com> <uok@users.noreply.github.com>
 Ben Sidhom <bsidhom@gmail.com>
 Brandon Philips <brandon@ifup.org>
+Brendan Long <self@brendanlong.com>
 Caleb Callaway <enlightened.despot@gmail.com>
 Cathryne Linenweaver <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
 Chris Joel <chris@scriptolo.gy>
@@ -15,6 +16,7 @@ Daniel Martí <mvdan@mvdan.cc>
 Dennis Wilson <dw@risu.io>
 Dominik Heidler <dominik@heidler.eu>
 Emil Hessman <emil@hessman.se>
+Federico Castagnini <federico.castagnini@gmail.com>
 Felix Ableitner <me@nutomic.com>
 Felix Unterpaintner <bigbear2nd@gmail.com>
 Gilli Sigurdsson <gilli@vx.is>
@@ -25,10 +27,12 @@ Jochen Voss <voss@seehuhn.de>
 Lode Hoste <zillode@zillode.be>
 Marcin Dziadus <dziadus.marcin@gmail.com>
 Michael Tilli <pyfisch@gmail.com>
+Peter Hoeg <peter@speartail.com>
 Philippe Schommers <philippe@schommers.be>
 Phill Luby <phill.luby@newredo.com>
 Piotr Bejda <piotrb10@gmail.com>
 Ryan Sullivan <kayoticsully@gmail.com>
+Tim Abell <tim@timwise.co.uk>
 Tomas Cerveny <kozec@kozec.com>
 Tully Robinson <tully@tojr.org>
 Veeti Paananen <veeti.paananen@rojekti.fi>

Godeps/Godeps.json

@@ -1,6 +1,6 @@
 {
 	"ImportPath": "github.com/syncthing/syncthing",
-	"GoVersion": "go1.4rc1",
+	"GoVersion": "go1.4",
 	"Packages": [
 		"./cmd/..."
 	],
@@ -23,7 +23,7 @@
 		},
 		{
 			"ImportPath": "github.com/calmh/xdr",
-			"Rev": "45c46b7db7ff83b8b9ee09bbd95f36ab50043ece"
+			"Rev": "214788d8fedfc310c18eca9ed12be408a5054cd5"
 		},
 		{
 			"ImportPath": "github.com/juju/ratelimit",
@@ -31,7 +31,7 @@
 		},
 		{
 			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "97e257099d2ab9578151ba85e2641e2cd14d3ca8"
+			"Rev": "63c9e642efad852f49e20a6f90194cae112fd2ac"
 		},
 		{
 			"ImportPath": "github.com/syndtr/gosnappy/snappy",
@@ -51,23 +51,19 @@
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Comment": "null-236",
-			"Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Comment": "null-236",
-			"Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
 		},
 		{
 			"ImportPath": "golang.org/x/text/transform",
-			"Comment": "null-112",
-			"Rev": "2f707e0ad64637ca1318279be7201f5ed19c4050"
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		},
 		{
 			"ImportPath": "golang.org/x/text/unicode/norm",
-			"Comment": "null-112",
-			"Rev": "2f707e0ad64637ca1318279be7201f5ed19c4050"
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		}
 	]
 }

Godeps/_workspace/src/github.com/calmh/xdr/reader.go

@@ -154,6 +154,10 @@ func (e XDRError) Error() string {
 	return "xdr " + e.op + ": " + e.err.Error()
 }
 
+func (e XDRError) IsEOF() bool {
+	return e.err == io.EOF
+}
+
 func (r *Reader) Error() error {
 	if r.err == nil {
 		return nil

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go

@@ -8,152 +8,669 @@
 package cache
 
 import (
+	"sync"
 	"sync/atomic"
+	"unsafe"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
-// SetFunc is the function that will be called by Namespace.Get to create
-// a cache object, if charge is less than one than the cache object will
-// not be registered to cache tree, if value is nil then the cache object
-// will not be created.
-type SetFunc func() (charge int, value interface{})
-
-// DelFin is the function that will be called as the result of a delete operation.
-// Exist == true is indication that the object is exist, and pending == true is
-// indication of deletion already happen but haven't done yet (wait for all handles
-// to be released). And exist == false means the object doesn't exist.
-type DelFin func(exist, pending bool)
-
-// PurgeFin is the function that will be called as the result of a purge operation.
-type PurgeFin func(ns, key uint64)
-
-// Cache is a cache tree. A cache instance must be goroutine-safe.
-type Cache interface {
-	// SetCapacity sets cache tree capacity.
-	SetCapacity(capacity int)
-
-	// Capacity returns cache tree capacity.
+// Cacher provides interface to implements a caching functionality.
+// An implementation must be goroutine-safe.
+type Cacher interface {
+	// Capacity returns cache capacity.
 	Capacity() int
 
-	// Used returns used cache tree capacity.
-	Used() int
+	// SetCapacity sets cache capacity.
+	SetCapacity(capacity int)
 
-	// Size returns entire alive cache objects size.
-	Size() int
+	// Promote promotes the 'cache node'.
+	Promote(n *Node)
 
-	// NumObjects returns number of alive objects.
-	NumObjects() int
+	// Ban evicts the 'cache node' and prevent subsequent 'promote'.
+	Ban(n *Node)
 
-	// GetNamespace gets cache namespace with the given id.
-	// GetNamespace is never return nil.
-	GetNamespace(id uint64) Namespace
+	// Evict evicts the 'cache node'.
+	Evict(n *Node)
 
-	// PurgeNamespace purges cache namespace with the given id from this cache tree.
-	// Also read Namespace.Purge.
-	PurgeNamespace(id uint64, fin PurgeFin)
+	// EvictNS evicts 'cache node' with the given namespace.
+	EvictNS(ns uint64)
 
-	// ZapNamespace detaches cache namespace with the given id from this cache tree.
-	// Also read Namespace.Zap.
-	ZapNamespace(id uint64)
+	// EvictAll evicts all 'cache node'.
+	EvictAll()
 
-	// Purge purges all cache namespace from this cache tree.
-	// This is behave the same as calling Namespace.Purge method on all cache namespace.
-	Purge(fin PurgeFin)
-
-	// Zap detaches all cache namespace from this cache tree.
-	// This is behave the same as calling Namespace.Zap method on all cache namespace.
-	Zap()
+	// Close closes the 'cache tree'
+	Close() error
 }
 
-// Namespace is a cache namespace. A namespace instance must be goroutine-safe.
-type Namespace interface {
-	// Get gets cache object with the given key.
-	// If cache object is not found and setf is not nil, Get will atomically creates
-	// the cache object by calling setf. Otherwise Get will returns nil.
-	//
-	// The returned cache handle should be released after use by calling Release
-	// method.
-	Get(key uint64, setf SetFunc) Handle
+// Value is a 'cacheable object'. It may implements util.Releaser, if
+// so the the Release method will be called once object is released.
+type Value interface{}
 
-	// Delete removes cache object with the given key from cache tree.
-	// A deleted cache object will be released as soon as all of its handles have
-	// been released.
-	// Delete only happen once, subsequent delete will consider cache object doesn't
-	// exist, even if the cache object ins't released yet.
-	//
-	// If not nil, fin will be called if the cache object doesn't exist or when
-	// finally be released.
-	//
-	// Delete returns true if such cache object exist and never been deleted.
-	Delete(key uint64, fin DelFin) bool
-
-	// Purge removes all cache objects within this namespace from cache tree.
-	// This is the same as doing delete on all cache objects.
-	//
-	// If not nil, fin will be called on all cache objects when its finally be
-	// released.
-	Purge(fin PurgeFin)
-
-	// Zap detaches namespace from cache tree and release all its cache objects.
-	// A zapped namespace can never be filled again.
-	// Calling Get on zapped namespace will always return nil.
-	Zap()
+type CacheGetter struct {
+	Cache *Cache
+	NS    uint64
 }
 
-// Handle is a cache handle.
-type Handle interface {
-	// Release releases this cache handle. This method can be safely called mutiple
-	// times.
-	Release()
-
-	// Value returns value of this cache handle.
-	// Value will returns nil after this cache handle have be released.
-	Value() interface{}
+func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
+	return g.Cache.Get(g.NS, key, setFunc)
 }
 
+// The hash tables implementation is based on:
+// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
+
 const (
-	DelNotExist = iota
-	DelExist
-	DelPendig
+	mInitialSize           = 1 << 4
+	mOverflowThreshold     = 1 << 5
+	mOverflowGrowThreshold = 1 << 7
 )
 
-// Namespace state.
-type nsState int
-
-const (
-	nsEffective nsState = iota
-	nsZapped
-)
-
-// Node state.
-type nodeState int
-
-const (
-	nodeZero nodeState = iota
-	nodeEffective
-	nodeEvicted
-	nodeDeleted
-)
-
-// Fake handle.
-type fakeHandle struct {
-	value interface{}
-	fin   func()
-	once  uint32
+type mBucket struct {
+	mu     sync.Mutex
+	node   []*Node
+	frozen bool
 }
 
-func (h *fakeHandle) Value() interface{} {
-	if atomic.LoadUint32(&h.once) == 0 {
-		return h.value
+func (b *mBucket) freeze() []*Node {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.frozen {
+		b.frozen = true
+	}
+	return b.node
+}
+
+func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	for _, n := range b.node {
+		if n.hash == hash && n.ns == ns && n.key == key {
+			atomic.AddInt32(&n.ref, 1)
+			b.mu.Unlock()
+			return true, false, n
+		}
+	}
+
+	// Get only.
+	if noset {
+		b.mu.Unlock()
+		return true, false, nil
+	}
+
+	// Create node.
+	n = &Node{
+		r:    r,
+		hash: hash,
+		ns:   ns,
+		key:  key,
+		ref:  1,
+	}
+	// Add node to bucket.
+	b.node = append(b.node, n)
+	bLen := len(b.node)
+	b.mu.Unlock()
+
+	// Update counter.
+	grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
+	if bLen > mOverflowThreshold {
+		grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
+	}
+
+	// Grow.
+	if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+		nhLen := len(h.buckets) << 1
+		nh := &mNode{
+			buckets:         make([]unsafe.Pointer, nhLen),
+			mask:            uint32(nhLen) - 1,
+			pred:            unsafe.Pointer(h),
+			growThreshold:   int32(nhLen * mOverflowThreshold),
+			shrinkThreshold: int32(nhLen >> 1),
+		}
+		ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+		if !ok {
+			panic("BUG: failed swapping head")
+		}
+		go nh.initBuckets()
+	}
+
+	return true, true, n
+}
+
+func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	var (
+		n    *Node
+		bLen int
+	)
+	for i := range b.node {
+		n = b.node[i]
+		if n.ns == ns && n.key == key {
+			if atomic.LoadInt32(&n.ref) == 0 {
+				deleted = true
+
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Remove node from bucket.
+				b.node = append(b.node[:i], b.node[i+1:]...)
+				bLen = len(b.node)
+			}
+			break
+		}
+	}
+	b.mu.Unlock()
+
+	if deleted {
+		// Call OnDel.
+		for _, f := range n.onDel {
+			f()
+		}
+
+		// Update counter.
+		atomic.AddInt32(&r.size, int32(n.size)*-1)
+		shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
+		if bLen >= mOverflowThreshold {
+			atomic.AddInt32(&h.overflow, -1)
+		}
+
+		// Shrink.
+		if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+			nhLen := len(h.buckets) >> 1
+			nh := &mNode{
+				buckets:         make([]unsafe.Pointer, nhLen),
+				mask:            uint32(nhLen) - 1,
+				pred:            unsafe.Pointer(h),
+				growThreshold:   int32(nhLen * mOverflowThreshold),
+				shrinkThreshold: int32(nhLen >> 1),
+			}
+			ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+			if !ok {
+				panic("BUG: failed swapping head")
+			}
+			go nh.initBuckets()
+		}
+	}
+
+	return true, deleted
+}
+
+type mNode struct {
+	buckets         []unsafe.Pointer // []*mBucket
+	mask            uint32
+	pred            unsafe.Pointer // *mNode
+	resizeInProgess int32
+
+	overflow        int32
+	growThreshold   int32
+	shrinkThreshold int32
+}
+
+func (n *mNode) initBucket(i uint32) *mBucket {
+	if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
+		return b
+	}
+
+	p := (*mNode)(atomic.LoadPointer(&n.pred))
+	if p != nil {
+		var node []*Node
+		if n.mask > p.mask {
+			// Grow.
+			pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
+			if pb == nil {
+				pb = p.initBucket(i & p.mask)
+			}
+			m := pb.freeze()
+			// Split nodes.
+			for _, x := range m {
+				if x.hash&n.mask == i {
+					node = append(node, x)
+				}
+			}
+		} else {
+			// Shrink.
+			pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
+			if pb0 == nil {
+				pb0 = p.initBucket(i)
+			}
+			pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
+			if pb1 == nil {
+				pb1 = p.initBucket(i + uint32(len(n.buckets)))
+			}
+			m0 := pb0.freeze()
+			m1 := pb1.freeze()
+			// Merge nodes.
+			node = make([]*Node, 0, len(m0)+len(m1))
+			node = append(node, m0...)
+			node = append(node, m1...)
+		}
+		b := &mBucket{node: node}
+		if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
+			if len(node) > mOverflowThreshold {
+				atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
+			}
+			return b
+		}
+	}
+
+	return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
+}
+
+func (n *mNode) initBuckets() {
+	for i := range n.buckets {
+		n.initBucket(uint32(i))
+	}
+	atomic.StorePointer(&n.pred, nil)
+}
+
+// Cache is a 'cache map'.
+type Cache struct {
+	mu     sync.RWMutex
+	mHead  unsafe.Pointer // *mNode
+	nodes  int32
+	size   int32
+	cacher Cacher
+	closed bool
+}
+
+// NewCache creates a new 'cache map'. The cacher is optional and
+// may be nil.
+func NewCache(cacher Cacher) *Cache {
+	h := &mNode{
+		buckets:         make([]unsafe.Pointer, mInitialSize),
+		mask:            mInitialSize - 1,
+		growThreshold:   int32(mInitialSize * mOverflowThreshold),
+		shrinkThreshold: 0,
+	}
+	for i := range h.buckets {
+		h.buckets[i] = unsafe.Pointer(&mBucket{})
+	}
+	r := &Cache{
+		mHead:  unsafe.Pointer(h),
+		cacher: cacher,
+	}
+	return r
+}
+
+func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
+	h := (*mNode)(atomic.LoadPointer(&r.mHead))
+	i := hash & h.mask
+	b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
+	if b == nil {
+		b = h.initBucket(i)
+	}
+	return h, b
+}
+
+func (r *Cache) delete(n *Node) bool {
+	for {
+		h, b := r.getBucket(n.hash)
+		done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
+		if done {
+			return deleted
+		}
+	}
+	return false
+}
+
+// Nodes returns number of 'cache node' in the map.
+func (r *Cache) Nodes() int {
+	return int(atomic.LoadInt32(&r.nodes))
+}
+
+// Size returns sums of 'cache node' size in the map.
+func (r *Cache) Size() int {
+	return int(atomic.LoadInt32(&r.size))
+}
+
+// Capacity returns cache capacity.
+func (r *Cache) Capacity() int {
+	if r.cacher == nil {
+		return 0
+	}
+	return r.cacher.Capacity()
+}
+
+// SetCapacity sets cache capacity.
+func (r *Cache) SetCapacity(capacity int) {
+	if r.cacher != nil {
+		r.cacher.SetCapacity(capacity)
+	}
+}
+
+// Get gets 'cache node' with the given namespace and key.
+// If cache node is not found and setFunc is not nil, Get will atomically creates
+// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
+//
+// The returned 'cache handle' should be released after use by calling Release
+// method.
+func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return nil
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
+		if done {
+			if n != nil {
+				n.mu.Lock()
+				if n.value == nil {
+					if setFunc == nil {
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+
+					n.size, n.value = setFunc()
+					if n.value == nil {
+						n.size = 0
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+					atomic.AddInt32(&r.size, int32(n.size))
+				}
+				n.mu.Unlock()
+				if r.cacher != nil {
+					r.cacher.Promote(n)
+				}
+				return &Handle{unsafe.Pointer(n)}
+			}
+
+			break
+		}
 	}
 	return nil
 }
 
-func (h *fakeHandle) Release() {
-	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
+// Delete removes and ban 'cache node' with the given namespace and key.
+// A banned 'cache node' will never inserted into the 'cache tree'. Ban
+// only attributed to the particular 'cache node', so when a 'cache node'
+// is recreated it will not be banned.
+//
+// If onDel is not nil, then it will be executed if such 'cache node'
+// doesn't exist or once the 'cache node' is released.
+//
+// Delete return true is such 'cache node' exist.
+func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if onDel != nil {
+					n.mu.Lock()
+					n.onDel = append(n.onDel, onDel)
+					n.mu.Unlock()
+				}
+				if r.cacher != nil {
+					r.cacher.Ban(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	if onDel != nil {
+		onDel()
+	}
+
+	return false
+}
+
+// Evict evicts 'cache node' with the given namespace and key. This will
+// simply call Cacher.Evict.
+//
+// Evict return true is such 'cache node' exist.
+func (r *Cache) Evict(ns, key uint64) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if r.cacher != nil {
+					r.cacher.Evict(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	return false
+}
+
+// EvictNS evicts 'cache node' with the given namespace. This will
+// simply call Cacher.EvictNS.
+func (r *Cache) EvictNS(ns uint64) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
 		return
 	}
-	if h.fin != nil {
-		h.fin()
-		h.fin = nil
+
+	if r.cacher != nil {
+		r.cacher.EvictNS(ns)
 	}
 }
+
+// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
+func (r *Cache) EvictAll() {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return
+	}
+
+	if r.cacher != nil {
+		r.cacher.EvictAll()
+	}
+}
+
+// Close closes the 'cache map' and releases all 'cache node'.
+func (r *Cache) Close() error {
+	r.mu.Lock()
+	if !r.closed {
+		r.closed = true
+
+		if r.cacher != nil {
+			if err := r.cacher.Close(); err != nil {
+				return err
+			}
+		}
+
+		h := (*mNode)(r.mHead)
+		h.initBuckets()
+
+		for i := range h.buckets {
+			b := (*mBucket)(h.buckets[i])
+			for _, n := range b.node {
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Call OnDel.
+				for _, f := range n.onDel {
+					f()
+				}
+			}
+		}
+	}
+	r.mu.Unlock()
+	return nil
+}
+
+// Node is a 'cache node'.
+type Node struct {
+	r *Cache
+
+	hash    uint32
+	ns, key uint64
+
+	mu    sync.Mutex
+	size  int
+	value Value
+
+	ref   int32
+	onDel []func()
+
+	CacheData unsafe.Pointer
+}
+
+// NS returns this 'cache node' namespace.
+func (n *Node) NS() uint64 {
+	return n.ns
+}
+
+// Key returns this 'cache node' key.
+func (n *Node) Key() uint64 {
+	return n.key
+}
+
+// Size returns this 'cache node' size.
+func (n *Node) Size() int {
+	return n.size
+}
+
+// Value returns this 'cache node' value.
+func (n *Node) Value() Value {
+	return n.value
+}
+
+// Ref returns this 'cache node' ref counter.
+func (n *Node) Ref() int32 {
+	return atomic.LoadInt32(&n.ref)
+}
+
+// GetHandle returns an handle for this 'cache node'.
+func (n *Node) GetHandle() *Handle {
+	if atomic.AddInt32(&n.ref, 1) <= 1 {
+		panic("BUG: Node.GetHandle on zero ref")
+	}
+	return &Handle{unsafe.Pointer(n)}
+}
+
+func (n *Node) unref() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.delete(n)
+	}
+}
+
+func (n *Node) unrefLocked() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.mu.RLock()
+		if !n.r.closed {
+			n.r.delete(n)
+		}
+		n.r.mu.RUnlock()
+	}
+}
+
+type Handle struct {
+	n unsafe.Pointer // *Node
+}
+
+func (h *Handle) Value() Value {
+	n := (*Node)(atomic.LoadPointer(&h.n))
+	if n != nil {
+		return n.value
+	}
+	return nil
+}
+
+func (h *Handle) Release() {
+	nPtr := atomic.LoadPointer(&h.n)
+	if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
+		n := (*Node)(nPtr)
+		n.unrefLocked()
+	}
+}
+
+func murmur32(ns, key uint64, seed uint32) uint32 {
+	const (
+		m = uint32(0x5bd1e995)
+		r = 24
+	)
+
+	k1 := uint32(ns >> 32)
+	k2 := uint32(ns)
+	k3 := uint32(key >> 32)
+	k4 := uint32(key)
+
+	k1 *= m
+	k1 ^= k1 >> r
+	k1 *= m
+
+	k2 *= m
+	k2 ^= k2 >> r
+	k2 *= m
+
+	k3 *= m
+	k3 ^= k3 >> r
+	k3 *= m
+
+	k4 *= m
+	k4 ^= k4 >> r
+	k4 *= m
+
+	h := seed
+
+	h *= m
+	h ^= k1
+	h *= m
+	h ^= k2
+	h *= m
+	h ^= k3
+	h *= m
+	h ^= k4
+
+	h ^= h >> 13
+	h *= m
+	h ^= h >> 15
+
+	return h
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go

@@ -13,11 +13,26 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
+	"unsafe"
 )
 
+type int32o int32
+
+func (o *int32o) acquire() {
+	if atomic.AddInt32((*int32)(o), 1) != 1 {
+		panic("BUG: invalid ref")
+	}
+}
+
+func (o *int32o) Release() {
+	if atomic.AddInt32((*int32)(o), -1) != 0 {
+		panic("BUG: invalid ref")
+	}
+}
+
 type releaserFunc struct {
 	fn    func()
-	value interface{}
+	value Value
 }
 
 func (r releaserFunc) Release() {
@@ -26,8 +41,8 @@ func (r releaserFunc) Release() {
 	}
 }
 
-func set(ns Namespace, key uint64, value interface{}, charge int, relf func()) Handle {
-	return ns.Get(key, func() (int, interface{}) {
+func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle {
+	return c.Get(ns, key, func() (int, Value) {
 		if relf != nil {
 			return charge, releaserFunc{relf, value}
 		} else {
@@ -36,7 +51,246 @@ func set(ns Namespace, key uint64, value interface{}, charge int, relf func()) H
 	})
 }
 
-func TestCache_HitMiss(t *testing.T) {
+func TestCacheMap(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	nsx := []struct {
+		nobjects, nhandles, concurrent, repeat int
+	}{
+		{10000, 400, 50, 3},
+		{100000, 1000, 100, 10},
+	}
+
+	var (
+		objects [][]int32o
+		handles [][]unsafe.Pointer
+	)
+
+	for _, x := range nsx {
+		objects = append(objects, make([]int32o, x.nobjects))
+		handles = append(handles, make([]unsafe.Pointer, x.nhandles))
+	}
+
+	c := NewCache(nil)
+
+	wg := new(sync.WaitGroup)
+	var done int32
+
+	for ns, x := range nsx {
+		for i := 0; i < x.concurrent; i++ {
+			wg.Add(1)
+			go func(ns, i, repeat int, objects []int32o, handles []unsafe.Pointer) {
+				defer wg.Done()
+				r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+				for j := len(objects) * repeat; j >= 0; j-- {
+					key := uint64(r.Intn(len(objects)))
+					h := c.Get(uint64(ns), key, func() (int, Value) {
+						o := &objects[key]
+						o.acquire()
+						return 1, o
+					})
+					if v := h.Value().(*int32o); v != &objects[key] {
+						t.Fatalf("#%d invalid value: want=%p got=%p", ns, &objects[key], v)
+					}
+					if objects[key] != 1 {
+						t.Fatalf("#%d invalid object %d: %d", ns, key, objects[key])
+					}
+					if !atomic.CompareAndSwapPointer(&handles[r.Intn(len(handles))], nil, unsafe.Pointer(h)) {
+						h.Release()
+					}
+				}
+			}(ns, i, x.repeat, objects[ns], handles[ns])
+		}
+
+		go func(handles []unsafe.Pointer) {
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+			for atomic.LoadInt32(&done) == 0 {
+				i := r.Intn(len(handles))
+				h := (*Handle)(atomic.LoadPointer(&handles[i]))
+				if h != nil && atomic.CompareAndSwapPointer(&handles[i], unsafe.Pointer(h), nil) {
+					h.Release()
+				}
+				time.Sleep(time.Millisecond)
+			}
+		}(handles[ns])
+	}
+
+	go func() {
+		handles := make([]*Handle, 100000)
+		for atomic.LoadInt32(&done) == 0 {
+			for i := range handles {
+				handles[i] = c.Get(999999999, uint64(i), func() (int, Value) {
+					return 1, 1
+				})
+			}
+			for _, h := range handles {
+				h.Release()
+			}
+		}
+	}()
+
+	wg.Wait()
+
+	atomic.StoreInt32(&done, 1)
+
+	for _, handles0 := range handles {
+		for i := range handles0 {
+			h := (*Handle)(atomic.LoadPointer(&handles0[i]))
+			if h != nil && atomic.CompareAndSwapPointer(&handles0[i], unsafe.Pointer(h), nil) {
+				h.Release()
+			}
+		}
+	}
+
+	for ns, objects0 := range objects {
+		for i, o := range objects0 {
+			if o != 0 {
+				t.Fatalf("invalid object #%d.%d: ref=%d", ns, i, o)
+			}
+		}
+	}
+}
+
+func TestCacheMap_NodesAndSize(t *testing.T) {
+	c := NewCache(nil)
+	if c.Nodes() != 0 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+	}
+	if c.Size() != 0 {
+		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+	}
+	set(c, 0, 1, 1, 1, nil)
+	set(c, 0, 2, 2, 2, nil)
+	set(c, 1, 1, 3, 3, nil)
+	set(c, 2, 1, 4, 1, nil)
+	if c.Nodes() != 4 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 4, c.Nodes())
+	}
+	if c.Size() != 7 {
+		t.Errorf("invalid size counter: want=%d got=%d", 4, c.Size())
+	}
+}
+
+func TestLRUCache_Capacity(t *testing.T) {
+	c := NewCache(NewLRU(10))
+	if c.Capacity() != 10 {
+		t.Errorf("invalid capacity: want=%d got=%d", 10, c.Capacity())
+	}
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 2, nil).Release()
+	set(c, 1, 1, 3, 3, nil).Release()
+	set(c, 2, 1, 4, 1, nil).Release()
+	set(c, 2, 2, 5, 1, nil).Release()
+	set(c, 2, 3, 6, 1, nil).Release()
+	set(c, 2, 4, 7, 1, nil).Release()
+	set(c, 2, 5, 8, 1, nil).Release()
+	if c.Nodes() != 7 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 7, c.Nodes())
+	}
+	if c.Size() != 10 {
+		t.Errorf("invalid size counter: want=%d got=%d", 10, c.Size())
+	}
+	c.SetCapacity(9)
+	if c.Capacity() != 9 {
+		t.Errorf("invalid capacity: want=%d got=%d", 9, c.Capacity())
+	}
+	if c.Nodes() != 6 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 6, c.Nodes())
+	}
+	if c.Size() != 8 {
+		t.Errorf("invalid size counter: want=%d got=%d", 8, c.Size())
+	}
+}
+
+func TestCacheMap_NilValue(t *testing.T) {
+	c := NewCache(NewLRU(10))
+	h := c.Get(0, 0, func() (size int, value Value) {
+		return 1, nil
+	})
+	if h != nil {
+		t.Error("cache handle is non-nil")
+	}
+	if c.Nodes() != 0 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+	}
+	if c.Size() != 0 {
+		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+	}
+}
+
+func TestLRUCache_GetLatency(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	const (
+		concurrentSet = 30
+		concurrentGet = 3
+		duration      = 3 * time.Second
+		delay         = 3 * time.Millisecond
+		maxkey        = 100000
+	)
+
+	var (
+		set, getHit, getAll        int32
+		getMaxLatency, getDuration int64
+	)
+
+	c := NewCache(NewLRU(5000))
+	wg := &sync.WaitGroup{}
+	until := time.Now().Add(duration)
+	for i := 0; i < concurrentSet; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+			for time.Now().Before(until) {
+				c.Get(0, uint64(r.Intn(maxkey)), func() (int, Value) {
+					time.Sleep(delay)
+					atomic.AddInt32(&set, 1)
+					return 1, 1
+				}).Release()
+			}
+		}(i)
+	}
+	for i := 0; i < concurrentGet; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+			for {
+				mark := time.Now()
+				if mark.Before(until) {
+					h := c.Get(0, uint64(r.Intn(maxkey)), nil)
+					latency := int64(time.Now().Sub(mark))
+					m := atomic.LoadInt64(&getMaxLatency)
+					if latency > m {
+						atomic.CompareAndSwapInt64(&getMaxLatency, m, latency)
+					}
+					atomic.AddInt64(&getDuration, latency)
+					if h != nil {
+						atomic.AddInt32(&getHit, 1)
+						h.Release()
+					}
+					atomic.AddInt32(&getAll, 1)
+				} else {
+					break
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	getAvglatency := time.Duration(getDuration) / time.Duration(getAll)
+	t.Logf("set=%d getHit=%d getAll=%d getMaxLatency=%v getAvgLatency=%v",
+		set, getHit, getAll, time.Duration(getMaxLatency), getAvglatency)
+
+	if getAvglatency > delay/3 {
+		t.Errorf("get avg latency > %v: got=%v", delay/3, getAvglatency)
+	}
+}
+
+func TestLRUCache_HitMiss(t *testing.T) {
 	cases := []struct {
 		key   uint64
 		value string
@@ -54,14 +308,13 @@ func TestCache_HitMiss(t *testing.T) {
 	}
 
 	setfin := 0
-	c := NewLRUCache(1000)
-	ns := c.GetNamespace(0)
+	c := NewCache(NewLRU(1000))
 	for i, x := range cases {
-		set(ns, x.key, x.value, len(x.value), func() {
+		set(c, 0, x.key, x.value, len(x.value), func() {
 			setfin++
 		}).Release()
 		for j, y := range cases {
-			h := ns.Get(y.key, nil)
+			h := c.Get(0, y.key, nil)
 			if j <= i {
 				// should hit
 				if h == nil {
@@ -85,7 +338,7 @@ func TestCache_HitMiss(t *testing.T) {
 
 	for i, x := range cases {
 		finalizerOk := false
-		ns.Delete(x.key, func(exist, pending bool) {
+		c.Delete(0, x.key, func() {
 			finalizerOk = true
 		})
 
@@ -94,7 +347,7 @@ func TestCache_HitMiss(t *testing.T) {
 		}
 
 		for j, y := range cases {
-			h := ns.Get(y.key, nil)
+			h := c.Get(0, y.key, nil)
 			if j > i {
 				// should hit
 				if h == nil {
@@ -122,20 +375,19 @@ func TestCache_HitMiss(t *testing.T) {
 }
 
 func TestLRUCache_Eviction(t *testing.T) {
-	c := NewLRUCache(12)
-	ns := c.GetNamespace(0)
-	o1 := set(ns, 1, 1, 1, nil)
-	set(ns, 2, 2, 1, nil).Release()
-	set(ns, 3, 3, 1, nil).Release()
-	set(ns, 4, 4, 1, nil).Release()
-	set(ns, 5, 5, 1, nil).Release()
-	if h := ns.Get(2, nil); h != nil { // 1,3,4,5,2
+	c := NewCache(NewLRU(12))
+	o1 := set(c, 0, 1, 1, 1, nil)
+	set(c, 0, 2, 2, 1, nil).Release()
+	set(c, 0, 3, 3, 1, nil).Release()
+	set(c, 0, 4, 4, 1, nil).Release()
+	set(c, 0, 5, 5, 1, nil).Release()
+	if h := c.Get(0, 2, nil); h != nil { // 1,3,4,5,2
 		h.Release()
 	}
-	set(ns, 9, 9, 10, nil).Release() // 5,2,9
+	set(c, 0, 9, 9, 10, nil).Release() // 5,2,9
 
 	for _, key := range []uint64{9, 2, 5, 1} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -147,7 +399,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 	o1.Release()
 	for _, key := range []uint64{1, 2, 5} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -158,7 +410,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 		}
 	}
 	for _, key := range []uint64{3, 4, 9} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h != nil {
 			t.Errorf("hit for key '%d'", key)
 			if x := h.Value().(int); x != int(key) {
@@ -169,487 +421,150 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 }
 
-func TestLRUCache_SetGet(t *testing.T) {
-	c := NewLRUCache(13)
-	ns := c.GetNamespace(0)
-	for i := 0; i < 200; i++ {
-		n := uint64(rand.Intn(99999) % 20)
-		set(ns, n, n, 1, nil).Release()
-		if h := ns.Get(n, nil); h != nil {
-			if h.Value() == nil {
-				t.Errorf("key '%d' contains nil value", n)
+func TestLRUCache_Evict(t *testing.T) {
+	c := NewCache(NewLRU(6))
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 1, nil).Release()
+	set(c, 1, 1, 4, 1, nil).Release()
+	set(c, 1, 2, 5, 1, nil).Release()
+	set(c, 2, 1, 6, 1, nil).Release()
+	set(c, 2, 2, 7, 1, nil).Release()
+
+	for ns := 0; ns < 3; ns++ {
+		for key := 1; key < 3; key++ {
+			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+				h.Release()
 			} else {
-				if x := h.Value().(uint64); x != n {
-					t.Errorf("invalid value for key '%d' want '%d', got '%d'", n, n, x)
-				}
+				t.Errorf("Cache.Get on #%d.%d return nil", ns, key)
 			}
+		}
+	}
+
+	if ok := c.Evict(0, 1); !ok {
+		t.Error("first Cache.Evict on #0.1 return false")
+	}
+	if ok := c.Evict(0, 1); ok {
+		t.Error("second Cache.Evict on #0.1 return true")
+	}
+	if h := c.Get(0, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #0.1 return non-nil: %v", h.Value())
+	}
+
+	c.EvictNS(1)
+	if h := c.Get(1, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #1.1 return non-nil: %v", h.Value())
+	}
+	if h := c.Get(1, 2, nil); h != nil {
+		t.Errorf("Cache.Get on #1.2 return non-nil: %v", h.Value())
+	}
+
+	c.EvictAll()
+	for ns := 0; ns < 3; ns++ {
+		for key := 1; key < 3; key++ {
+			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+				t.Errorf("Cache.Get on #%d.%d return non-nil: %v", ns, key, h.Value())
+			}
+		}
+	}
+}
+
+func TestLRUCache_Delete(t *testing.T) {
+	delFuncCalled := 0
+	delFunc := func() {
+		delFuncCalled++
+	}
+
+	c := NewCache(NewLRU(2))
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 1, nil).Release()
+
+	if ok := c.Delete(0, 1, delFunc); !ok {
+		t.Error("Cache.Delete on #1 return false")
+	}
+	if h := c.Get(0, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #1 return non-nil: %v", h.Value())
+	}
+	if ok := c.Delete(0, 1, delFunc); ok {
+		t.Error("Cache.Delete on #1 return true")
+	}
+
+	h2 := c.Get(0, 2, nil)
+	if h2 == nil {
+		t.Error("Cache.Get on #2 return nil")
+	}
+	if ok := c.Delete(0, 2, delFunc); !ok {
+		t.Error("(1) Cache.Delete on #2 return false")
+	}
+	if ok := c.Delete(0, 2, delFunc); !ok {
+		t.Error("(2) Cache.Delete on #2 return false")
+	}
+
+	set(c, 0, 3, 3, 1, nil).Release()
+	set(c, 0, 4, 4, 1, nil).Release()
+	c.Get(0, 2, nil).Release()
+
+	for key := 2; key <= 4; key++ {
+		if h := c.Get(0, uint64(key), nil); h != nil {
 			h.Release()
 		} else {
-			t.Errorf("key '%d' doesn't exist", n)
-		}
-	}
-}
-
-func TestLRUCache_Purge(t *testing.T) {
-	c := NewLRUCache(3)
-	ns1 := c.GetNamespace(0)
-	o1 := set(ns1, 1, 1, 1, nil)
-	o2 := set(ns1, 2, 2, 1, nil)
-	ns1.Purge(nil)
-	set(ns1, 3, 3, 1, nil).Release()
-	for _, key := range []uint64{1, 2, 3} {
-		h := ns1.Get(key, nil)
-		if h == nil {
-			t.Errorf("miss for key '%d'", key)
-		} else {
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-	o1.Release()
-	o2.Release()
-	for _, key := range []uint64{1, 2} {
-		h := ns1.Get(key, nil)
-		if h != nil {
-			t.Errorf("hit for key '%d'", key)
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-}
-
-type testingCacheObjectCounter struct {
-	created  uint
-	released uint
-}
-
-func (c *testingCacheObjectCounter) createOne() {
-	c.created++
-}
-
-func (c *testingCacheObjectCounter) releaseOne() {
-	c.released++
-}
-
-type testingCacheObject struct {
-	t   *testing.T
-	cnt *testingCacheObjectCounter
-
-	ns, key uint64
-
-	releaseCalled bool
-}
-
-func (x *testingCacheObject) Release() {
-	if !x.releaseCalled {
-		x.releaseCalled = true
-		x.cnt.releaseOne()
-	} else {
-		x.t.Errorf("duplicate setfin NS#%d KEY#%d", x.ns, x.key)
-	}
-}
-
-func TestLRUCache_ConcurrentSetGet(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	seed := time.Now().UnixNano()
-	t.Logf("seed=%d", seed)
-
-	const (
-		N = 2000000
-		M = 4000
-		C = 3
-	)
-
-	var set, get uint32
-
-	wg := &sync.WaitGroup{}
-	c := NewLRUCache(M / 4)
-	for ni := uint64(0); ni < C; ni++ {
-		r0 := rand.New(rand.NewSource(seed + int64(ni)))
-		r1 := rand.New(rand.NewSource(seed + int64(ni) + 1))
-		ns := c.GetNamespace(ni)
-
-		wg.Add(2)
-		go func(ns Namespace, r *rand.Rand) {
-			for i := 0; i < N; i++ {
-				x := uint64(r.Int63n(M))
-				o := ns.Get(x, func() (int, interface{}) {
-					atomic.AddUint32(&set, 1)
-					return 1, x
-				})
-				if v := o.Value().(uint64); v != x {
-					t.Errorf("#%d invalid value, got=%d", x, v)
-				}
-				o.Release()
-			}
-			wg.Done()
-		}(ns, r0)
-		go func(ns Namespace, r *rand.Rand) {
-			for i := 0; i < N; i++ {
-				x := uint64(r.Int63n(M))
-				o := ns.Get(x, nil)
-				if o != nil {
-					atomic.AddUint32(&get, 1)
-					if v := o.Value().(uint64); v != x {
-						t.Errorf("#%d invalid value, got=%d", x, v)
-					}
-					o.Release()
-				}
-			}
-			wg.Done()
-		}(ns, r1)
-	}
-
-	wg.Wait()
-
-	t.Logf("set=%d get=%d", set, get)
-}
-
-func TestLRUCache_Finalizer(t *testing.T) {
-	const (
-		capacity   = 100
-		goroutines = 100
-		iterations = 10000
-		keymax     = 8000
-	)
-
-	cnt := &testingCacheObjectCounter{}
-
-	c := NewLRUCache(capacity)
-
-	type instance struct {
-		seed       int64
-		rnd        *rand.Rand
-		nsid       uint64
-		ns         Namespace
-		effective  int
-		handles    []Handle
-		handlesMap map[uint64]int
-
-		delete          bool
-		purge           bool
-		zap             bool
-		wantDel         int
-		delfinCalled    int
-		delfinCalledAll int
-		delfinCalledEff int
-		purgefinCalled  int
-	}
-
-	instanceGet := func(p *instance, key uint64) {
-		h := p.ns.Get(key, func() (charge int, value interface{}) {
-			to := &testingCacheObject{
-				t: t, cnt: cnt,
-				ns:  p.nsid,
-				key: key,
-			}
-			p.effective++
-			cnt.createOne()
-			return 1, releaserFunc{func() {
-				to.Release()
-				p.effective--
-			}, to}
-		})
-		p.handles = append(p.handles, h)
-		p.handlesMap[key] = p.handlesMap[key] + 1
-	}
-	instanceRelease := func(p *instance, i int) {
-		h := p.handles[i]
-		key := h.Value().(releaserFunc).value.(*testingCacheObject).key
-		if n := p.handlesMap[key]; n == 0 {
-			t.Fatal("key ref == 0")
-		} else if n > 1 {
-			p.handlesMap[key] = n - 1
-		} else {
-			delete(p.handlesMap, key)
-		}
-		h.Release()
-		p.handles = append(p.handles[:i], p.handles[i+1:]...)
-		p.handles[len(p.handles) : len(p.handles)+1][0] = nil
-	}
-
-	seed := time.Now().UnixNano()
-	t.Logf("seed=%d", seed)
-
-	instances := make([]*instance, goroutines)
-	for i := range instances {
-		p := &instance{}
-		p.handlesMap = make(map[uint64]int)
-		p.seed = seed + int64(i)
-		p.rnd = rand.New(rand.NewSource(p.seed))
-		p.nsid = uint64(i)
-		p.ns = c.GetNamespace(p.nsid)
-		p.delete = i%6 == 0
-		p.purge = i%8 == 0
-		p.zap = i%12 == 0 || i%3 == 0
-		instances[i] = p
-	}
-
-	runr := rand.New(rand.NewSource(seed - 1))
-	run := func(rnd *rand.Rand, x []*instance, init func(p *instance) bool, fn func(p *instance, i int) bool) {
-		var (
-			rx []*instance
-			rn []int
-		)
-		if init == nil {
-			rx = append([]*instance{}, x...)
-			rn = make([]int, len(x))
-		} else {
-			for _, p := range x {
-				if init(p) {
-					rx = append(rx, p)
-					rn = append(rn, 0)
-				}
-			}
-		}
-		for len(rx) > 0 {
-			i := rand.Intn(len(rx))
-			if fn(rx[i], rn[i]) {
-				rn[i]++
-			} else {
-				rx = append(rx[:i], rx[i+1:]...)
-				rn = append(rn[:i], rn[i+1:]...)
-			}
+			t.Errorf("Cache.Get on #%d return nil", key)
 		}
 	}
 
-	// Get and release.
-	run(runr, instances, nil, func(p *instance, i int) bool {
-		if i < iterations {
-			if len(p.handles) == 0 || p.rnd.Int()%2 == 0 {
-				instanceGet(p, uint64(p.rnd.Intn(keymax)))
-			} else {
-				instanceRelease(p, p.rnd.Intn(len(p.handles)))
-			}
-			return true
-		} else {
-			return false
+	h2.Release()
+	if h := c.Get(0, 2, nil); h != nil {
+		t.Errorf("Cache.Get on #2 return non-nil: %v", h.Value())
+	}
+
+	if delFuncCalled != 4 {
+		t.Errorf("delFunc isn't called 4 times: got=%d", delFuncCalled)
+	}
+}
+
+func TestLRUCache_Close(t *testing.T) {
+	relFuncCalled := 0
+	relFunc := func() {
+		relFuncCalled++
+	}
+	delFuncCalled := 0
+	delFunc := func() {
+		delFuncCalled++
+	}
+
+	c := NewCache(NewLRU(2))
+	set(c, 0, 1, 1, 1, relFunc).Release()
+	set(c, 0, 2, 2, 1, relFunc).Release()
+
+	h3 := set(c, 0, 3, 3, 1, relFunc)
+	if h3 == nil {
+		t.Error("Cache.Get on #3 return nil")
+	}
+	if ok := c.Delete(0, 3, delFunc); !ok {
+		t.Error("Cache.Delete on #3 return false")
+	}
+
+	c.Close()
+
+	if relFuncCalled != 3 {
+		t.Errorf("relFunc isn't called 3 times: got=%d", relFuncCalled)
+	}
+	if delFuncCalled != 1 {
+		t.Errorf("delFunc isn't called 1 times: got=%d", delFuncCalled)
+	}
+}
+
+func BenchmarkLRUCache(b *testing.B) {
+	c := NewCache(NewLRU(10000))
+
+	b.SetParallelism(10)
+	b.RunParallel(func(pb *testing.PB) {
+		r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+		for pb.Next() {
+			key := uint64(r.Intn(1000000))
+			c.Get(0, key, func() (int, Value) {
+				return 1, key
+			}).Release()
 		}
 	})
-
-	if used, cap := c.Used(), c.Capacity(); used > cap {
-		t.Errorf("Used > capacity, used=%d cap=%d", used, cap)
-	}
-
-	// Check effective objects.
-	for i, p := range instances {
-		if int(p.effective) < len(p.handlesMap) {
-			t.Errorf("#%d effective objects < acquired handle, eo=%d ah=%d", i, p.effective, len(p.handlesMap))
-		}
-	}
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// First delete.
-	run(runr, instances, func(p *instance) bool {
-		p.wantDel = p.effective
-		return p.delete
-	}, func(p *instance, i int) bool {
-		key := uint64(i)
-		if key < keymax {
-			_, wantExist := p.handlesMap[key]
-			gotExist := p.ns.Delete(key, func(exist, pending bool) {
-				p.delfinCalledAll++
-				if exist {
-					p.delfinCalledEff++
-				}
-			})
-			if !gotExist && wantExist {
-				t.Errorf("delete on NS#%d KEY#%d not found", p.nsid, key)
-			}
-			return true
-		} else {
-			return false
-		}
-	})
-
-	// Second delete.
-	run(runr, instances, func(p *instance) bool {
-		p.delfinCalled = 0
-		return p.delete
-	}, func(p *instance, i int) bool {
-		key := uint64(i)
-		if key < keymax {
-			gotExist := p.ns.Delete(key, func(exist, pending bool) {
-				if exist && !pending {
-					t.Errorf("delete fin on NS#%d KEY#%d exist and not pending for deletion", p.nsid, key)
-				}
-				p.delfinCalled++
-			})
-			if gotExist {
-				t.Errorf("delete on NS#%d KEY#%d found", p.nsid, key)
-			}
-			return true
-		} else {
-			if p.delfinCalled != keymax {
-				t.Errorf("(2) NS#%d not all delete fin called, diff=%d", p.nsid, keymax-p.delfinCalled)
-			}
-			return false
-		}
-	})
-
-	// Purge.
-	run(runr, instances, func(p *instance) bool {
-		return p.purge
-	}, func(p *instance, i int) bool {
-		p.ns.Purge(func(ns, key uint64) {
-			p.purgefinCalled++
-		})
-		return false
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// Release.
-	run(runr, instances, func(p *instance) bool {
-		return !p.zap
-	}, func(p *instance, i int) bool {
-		if len(p.handles) > 0 {
-			instanceRelease(p, len(p.handles)-1)
-			return true
-		} else {
-			return false
-		}
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// Zap.
-	run(runr, instances, func(p *instance) bool {
-		return p.zap
-	}, func(p *instance, i int) bool {
-		p.ns.Zap()
-		p.handles = nil
-		p.handlesMap = nil
-		return false
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	if notrel, used := int(cnt.created-cnt.released), c.Used(); notrel != used {
-		t.Errorf("Invalid used value, want=%d got=%d", notrel, used)
-	}
-
-	c.Purge(nil)
-
-	for _, p := range instances {
-		if p.delete {
-			if p.delfinCalledAll != keymax {
-				t.Errorf("#%d not all delete fin called, purge=%v zap=%v diff=%d", p.nsid, p.purge, p.zap, keymax-p.delfinCalledAll)
-			}
-			if p.delfinCalledEff != p.wantDel {
-				t.Errorf("#%d not all effective delete fin called, diff=%d", p.nsid, p.wantDel-p.delfinCalledEff)
-			}
-			if p.purge && p.purgefinCalled > 0 {
-				t.Errorf("#%d some purge fin called, delete=%v zap=%v n=%d", p.nsid, p.delete, p.zap, p.purgefinCalled)
-			}
-		} else {
-			if p.purge {
-				if p.purgefinCalled != p.wantDel {
-					t.Errorf("#%d not all purge fin called, delete=%v zap=%v diff=%d", p.nsid, p.delete, p.zap, p.wantDel-p.purgefinCalled)
-				}
-			}
-		}
-	}
-
-	if cnt.created != cnt.released {
-		t.Errorf("Some cache object weren't released, created=%d released=%d", cnt.created, cnt.released)
-	}
-}
-
-func BenchmarkLRUCache_Set(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-}
-
-func BenchmarkLRUCache_Get(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		ns.Get(i, nil)
-	}
-}
-
-func BenchmarkLRUCache_Get2(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		ns.Get(i, func() (charge int, value interface{}) {
-			return 0, nil
-		})
-	}
-}
-
-func BenchmarkLRUCache_Release(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	handles := make([]Handle, b.N)
-	for i := uint64(0); i < uint64(b.N); i++ {
-		handles[i] = set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for _, h := range handles {
-		h.Release()
-	}
-}
-
-func BenchmarkLRUCache_SetRelease(b *testing.B) {
-	capacity := b.N / 100
-	if capacity <= 0 {
-		capacity = 10
-	}
-	c := NewLRUCache(capacity)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
-}
-
-func BenchmarkLRUCache_SetReleaseTwice(b *testing.B) {
-	capacity := b.N / 100
-	if capacity <= 0 {
-		capacity = 10
-	}
-	c := NewLRUCache(capacity)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-
-	na := b.N / 2
-	nb := b.N - na
-
-	for i := uint64(0); i < uint64(na); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
-
-	for i := uint64(0); i < uint64(nb); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go

@@ -0,0 +1,195 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package cache
+
+import (
+	"sync"
+	"unsafe"
+)
+
+type lruNode struct {
+	n   *Node
+	h   *Handle
+	ban bool
+
+	next, prev *lruNode
+}
+
+func (n *lruNode) insert(at *lruNode) {
+	x := at.next
+	at.next = n
+	n.prev = at
+	n.next = x
+	x.prev = n
+}
+
+func (n *lruNode) remove() {
+	if n.prev != nil {
+		n.prev.next = n.next
+		n.next.prev = n.prev
+		n.prev = nil
+		n.next = nil
+	} else {
+		panic("BUG: removing removed node")
+	}
+}
+
+type lru struct {
+	mu       sync.Mutex
+	capacity int
+	used     int
+	recent   lruNode
+}
+
+func (r *lru) reset() {
+	r.recent.next = &r.recent
+	r.recent.prev = &r.recent
+	r.used = 0
+}
+
+func (r *lru) Capacity() int {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.capacity
+}
+
+func (r *lru) SetCapacity(capacity int) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	r.capacity = capacity
+	for r.used > r.capacity {
+		rn := r.recent.prev
+		if rn == nil {
+			panic("BUG: invalid LRU used or capacity counter")
+		}
+		rn.remove()
+		rn.n.CacheData = nil
+		r.used -= rn.n.Size()
+		evicted = append(evicted, rn)
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Promote(n *Node) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	if n.CacheData == nil {
+		if n.Size() <= r.capacity {
+			rn := &lruNode{n: n, h: n.GetHandle()}
+			rn.insert(&r.recent)
+			n.CacheData = unsafe.Pointer(rn)
+			r.used += n.Size()
+
+			for r.used > r.capacity {
+				rn := r.recent.prev
+				if rn == nil {
+					panic("BUG: invalid LRU used or capacity counter")
+				}
+				rn.remove()
+				rn.n.CacheData = nil
+				r.used -= rn.n.Size()
+				evicted = append(evicted, rn)
+			}
+		}
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.insert(&r.recent)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Ban(n *Node) {
+	r.mu.Lock()
+	if n.CacheData == nil {
+		n.CacheData = unsafe.Pointer(&lruNode{n: n, ban: true})
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.ban = true
+			r.used -= rn.n.Size()
+			r.mu.Unlock()
+
+			rn.h.Release()
+			rn.h = nil
+			return
+		}
+	}
+	r.mu.Unlock()
+}
+
+func (r *lru) Evict(n *Node) {
+	r.mu.Lock()
+	rn := (*lruNode)(n.CacheData)
+	if rn == nil || rn.ban {
+		r.mu.Unlock()
+		return
+	}
+	n.CacheData = nil
+	r.mu.Unlock()
+
+	rn.h.Release()
+}
+
+func (r *lru) EvictNS(ns uint64) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	for e := r.recent.prev; e != &r.recent; {
+		rn := e
+		e = e.prev
+		if rn.n.NS() == ns {
+			rn.remove()
+			rn.n.CacheData = nil
+			r.used -= rn.n.Size()
+			evicted = append(evicted, rn)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) EvictAll() {
+	r.mu.Lock()
+	back := r.recent.prev
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.n.CacheData = nil
+	}
+	r.reset()
+	r.mu.Unlock()
+
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Close() error {
+	return nil
+}
+
+// NewLRU create a new LRU-cache.
+func NewLRU(capacity int) Cacher {
+	r := &lru{capacity: capacity}
+	r.reset()
+	return r
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru_cache.go

@@ -1,622 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package cache
-
-import (
-	"sync"
-	"sync/atomic"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-// The LLRB implementation were taken from https://github.com/petar/GoLLRB.
-// Which contains the following header:
-//
-// Copyright 2010 Petar Maymounkov. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// lruCache represent a LRU cache state.
-type lruCache struct {
-	mu                sync.Mutex
-	recent            lruNode
-	table             map[uint64]*lruNs
-	capacity          int
-	used, size, alive int
-}
-
-// NewLRUCache creates a new initialized LRU cache with the given capacity.
-func NewLRUCache(capacity int) Cache {
-	c := &lruCache{
-		table:    make(map[uint64]*lruNs),
-		capacity: capacity,
-	}
-	c.recent.rNext = &c.recent
-	c.recent.rPrev = &c.recent
-	return c
-}
-
-func (c *lruCache) Capacity() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.capacity
-}
-
-func (c *lruCache) Used() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.used
-}
-
-func (c *lruCache) Size() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.size
-}
-
-func (c *lruCache) NumObjects() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.alive
-}
-
-// SetCapacity set cache capacity.
-func (c *lruCache) SetCapacity(capacity int) {
-	c.mu.Lock()
-	c.capacity = capacity
-	c.evict()
-	c.mu.Unlock()
-}
-
-// GetNamespace return namespace object for given id.
-func (c *lruCache) GetNamespace(id uint64) Namespace {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if ns, ok := c.table[id]; ok {
-		return ns
-	}
-
-	ns := &lruNs{lru: c, id: id}
-	c.table[id] = ns
-	return ns
-}
-
-func (c *lruCache) ZapNamespace(id uint64) {
-	c.mu.Lock()
-	if ns, exist := c.table[id]; exist {
-		ns.zapNB()
-		delete(c.table, id)
-	}
-	c.mu.Unlock()
-}
-
-func (c *lruCache) PurgeNamespace(id uint64, fin PurgeFin) {
-	c.mu.Lock()
-	if ns, exist := c.table[id]; exist {
-		ns.purgeNB(fin)
-	}
-	c.mu.Unlock()
-}
-
-// Purge purge entire cache.
-func (c *lruCache) Purge(fin PurgeFin) {
-	c.mu.Lock()
-	for _, ns := range c.table {
-		ns.purgeNB(fin)
-	}
-	c.mu.Unlock()
-}
-
-func (c *lruCache) Zap() {
-	c.mu.Lock()
-	for _, ns := range c.table {
-		ns.zapNB()
-	}
-	c.table = make(map[uint64]*lruNs)
-	c.mu.Unlock()
-}
-
-func (c *lruCache) evict() {
-	top := &c.recent
-	for n := c.recent.rPrev; c.used > c.capacity && n != top; {
-		if n.state != nodeEffective {
-			panic("evicting non effective node")
-		}
-		n.state = nodeEvicted
-		n.rRemove()
-		n.derefNB()
-		c.used -= n.charge
-		n = c.recent.rPrev
-	}
-}
-
-type lruNs struct {
-	lru    *lruCache
-	id     uint64
-	rbRoot *lruNode
-	state  nsState
-}
-
-func (ns *lruNs) rbGetOrCreateNode(h *lruNode, key uint64) (hn, n *lruNode) {
-	if h == nil {
-		n = &lruNode{ns: ns, key: key}
-		return n, n
-	}
-
-	if key < h.key {
-		hn, n = ns.rbGetOrCreateNode(h.rbLeft, key)
-		if hn != nil {
-			h.rbLeft = hn
-		} else {
-			return nil, n
-		}
-	} else if key > h.key {
-		hn, n = ns.rbGetOrCreateNode(h.rbRight, key)
-		if hn != nil {
-			h.rbRight = hn
-		} else {
-			return nil, n
-		}
-	} else {
-		return nil, h
-	}
-
-	if rbIsRed(h.rbRight) && !rbIsRed(h.rbLeft) {
-		h = rbRotLeft(h)
-	}
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-	}
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbRight) {
-		rbFlip(h)
-	}
-	return h, n
-}
-
-func (ns *lruNs) getOrCreateNode(key uint64) *lruNode {
-	hn, n := ns.rbGetOrCreateNode(ns.rbRoot, key)
-	if hn != nil {
-		ns.rbRoot = hn
-		ns.rbRoot.rbBlack = true
-	}
-	return n
-}
-
-func (ns *lruNs) rbGetNode(key uint64) *lruNode {
-	h := ns.rbRoot
-	for h != nil {
-		switch {
-		case key < h.key:
-			h = h.rbLeft
-		case key > h.key:
-			h = h.rbRight
-		default:
-			return h
-		}
-	}
-	return nil
-}
-
-func (ns *lruNs) getNode(key uint64) *lruNode {
-	return ns.rbGetNode(key)
-}
-
-func (ns *lruNs) rbDeleteNode(h *lruNode, key uint64) *lruNode {
-	if h == nil {
-		return nil
-	}
-
-	if key < h.key {
-		if h.rbLeft == nil { // key not present. Nothing to delete
-			return h
-		}
-		if !rbIsRed(h.rbLeft) && !rbIsRed(h.rbLeft.rbLeft) {
-			h = rbMoveLeft(h)
-		}
-		h.rbLeft = ns.rbDeleteNode(h.rbLeft, key)
-	} else {
-		if rbIsRed(h.rbLeft) {
-			h = rbRotRight(h)
-		}
-		// If @key equals @h.key and no right children at @h
-		if h.key == key && h.rbRight == nil {
-			return nil
-		}
-		if h.rbRight != nil && !rbIsRed(h.rbRight) && !rbIsRed(h.rbRight.rbLeft) {
-			h = rbMoveRight(h)
-		}
-		// If @key equals @h.key, and (from above) 'h.Right != nil'
-		if h.key == key {
-			var x *lruNode
-			h.rbRight, x = rbDeleteMin(h.rbRight)
-			if x == nil {
-				panic("logic")
-			}
-			x.rbLeft, h.rbLeft = h.rbLeft, nil
-			x.rbRight, h.rbRight = h.rbRight, nil
-			x.rbBlack = h.rbBlack
-			h = x
-		} else { // Else, @key is bigger than @h.key
-			h.rbRight = ns.rbDeleteNode(h.rbRight, key)
-		}
-	}
-
-	return rbFixup(h)
-}
-
-func (ns *lruNs) deleteNode(key uint64) {
-	ns.rbRoot = ns.rbDeleteNode(ns.rbRoot, key)
-	if ns.rbRoot != nil {
-		ns.rbRoot.rbBlack = true
-	}
-}
-
-func (ns *lruNs) rbIterateNodes(h *lruNode, pivot uint64, iter func(n *lruNode) bool) bool {
-	if h == nil {
-		return true
-	}
-	if h.key >= pivot {
-		if !ns.rbIterateNodes(h.rbLeft, pivot, iter) {
-			return false
-		}
-		if !iter(h) {
-			return false
-		}
-	}
-	return ns.rbIterateNodes(h.rbRight, pivot, iter)
-}
-
-func (ns *lruNs) iterateNodes(iter func(n *lruNode) bool) {
-	ns.rbIterateNodes(ns.rbRoot, 0, iter)
-}
-
-func (ns *lruNs) Get(key uint64, setf SetFunc) Handle {
-	ns.lru.mu.Lock()
-	defer ns.lru.mu.Unlock()
-
-	if ns.state != nsEffective {
-		return nil
-	}
-
-	var n *lruNode
-	if setf == nil {
-		n = ns.getNode(key)
-		if n == nil {
-			return nil
-		}
-	} else {
-		n = ns.getOrCreateNode(key)
-	}
-	switch n.state {
-	case nodeZero:
-		charge, value := setf()
-		if value == nil {
-			ns.deleteNode(key)
-			return nil
-		}
-		if charge < 0 {
-			charge = 0
-		}
-
-		n.value = value
-		n.charge = charge
-		n.state = nodeEvicted
-
-		ns.lru.size += charge
-		ns.lru.alive++
-
-		fallthrough
-	case nodeEvicted:
-		if n.charge == 0 {
-			break
-		}
-
-		// Insert to recent list.
-		n.state = nodeEffective
-		n.ref++
-		ns.lru.used += n.charge
-		ns.lru.evict()
-
-		fallthrough
-	case nodeEffective:
-		// Bump to front.
-		n.rRemove()
-		n.rInsert(&ns.lru.recent)
-	case nodeDeleted:
-		// Do nothing.
-	default:
-		panic("invalid state")
-	}
-	n.ref++
-
-	return &lruHandle{node: n}
-}
-
-func (ns *lruNs) Delete(key uint64, fin DelFin) bool {
-	ns.lru.mu.Lock()
-	defer ns.lru.mu.Unlock()
-
-	if ns.state != nsEffective {
-		if fin != nil {
-			fin(false, false)
-		}
-		return false
-	}
-
-	n := ns.getNode(key)
-	if n == nil {
-		if fin != nil {
-			fin(false, false)
-		}
-		return false
-
-	}
-
-	switch n.state {
-	case nodeEffective:
-		ns.lru.used -= n.charge
-		n.state = nodeDeleted
-		n.delfin = fin
-		n.rRemove()
-		n.derefNB()
-	case nodeEvicted:
-		n.state = nodeDeleted
-		n.delfin = fin
-	case nodeDeleted:
-		if fin != nil {
-			fin(true, true)
-		}
-		return false
-	default:
-		panic("invalid state")
-	}
-
-	return true
-}
-
-func (ns *lruNs) purgeNB(fin PurgeFin) {
-	if ns.state == nsEffective {
-		var nodes []*lruNode
-		ns.iterateNodes(func(n *lruNode) bool {
-			nodes = append(nodes, n)
-			return true
-		})
-		for _, n := range nodes {
-			switch n.state {
-			case nodeEffective:
-				ns.lru.used -= n.charge
-				n.state = nodeDeleted
-				n.purgefin = fin
-				n.rRemove()
-				n.derefNB()
-			case nodeEvicted:
-				n.state = nodeDeleted
-				n.purgefin = fin
-			case nodeDeleted:
-			default:
-				panic("invalid state")
-			}
-		}
-	}
-}
-
-func (ns *lruNs) Purge(fin PurgeFin) {
-	ns.lru.mu.Lock()
-	ns.purgeNB(fin)
-	ns.lru.mu.Unlock()
-}
-
-func (ns *lruNs) zapNB() {
-	if ns.state == nsEffective {
-		ns.state = nsZapped
-
-		ns.iterateNodes(func(n *lruNode) bool {
-			if n.state == nodeEffective {
-				ns.lru.used -= n.charge
-				n.rRemove()
-			}
-			ns.lru.size -= n.charge
-			n.state = nodeDeleted
-			n.fin()
-
-			return true
-		})
-		ns.rbRoot = nil
-	}
-}
-
-func (ns *lruNs) Zap() {
-	ns.lru.mu.Lock()
-	ns.zapNB()
-	delete(ns.lru.table, ns.id)
-	ns.lru.mu.Unlock()
-}
-
-type lruNode struct {
-	ns *lruNs
-
-	rNext, rPrev    *lruNode
-	rbLeft, rbRight *lruNode
-	rbBlack         bool
-
-	key      uint64
-	value    interface{}
-	charge   int
-	ref      int
-	state    nodeState
-	delfin   DelFin
-	purgefin PurgeFin
-}
-
-func (n *lruNode) rInsert(at *lruNode) {
-	x := at.rNext
-	at.rNext = n
-	n.rPrev = at
-	n.rNext = x
-	x.rPrev = n
-}
-
-func (n *lruNode) rRemove() bool {
-	if n.rPrev == nil {
-		return false
-	}
-
-	n.rPrev.rNext = n.rNext
-	n.rNext.rPrev = n.rPrev
-	n.rPrev = nil
-	n.rNext = nil
-
-	return true
-}
-
-func (n *lruNode) fin() {
-	if r, ok := n.value.(util.Releaser); ok {
-		r.Release()
-	}
-	if n.purgefin != nil {
-		if n.delfin != nil {
-			panic("conflicting delete and purge fin")
-		}
-		n.purgefin(n.ns.id, n.key)
-		n.purgefin = nil
-	} else if n.delfin != nil {
-		n.delfin(true, false)
-		n.delfin = nil
-	}
-}
-
-func (n *lruNode) derefNB() {
-	n.ref--
-	if n.ref == 0 {
-		if n.ns.state == nsEffective {
-			// Remove elemement.
-			n.ns.deleteNode(n.key)
-			n.ns.lru.size -= n.charge
-			n.ns.lru.alive--
-			n.fin()
-		}
-		n.value = nil
-	} else if n.ref < 0 {
-		panic("leveldb/cache: lruCache: negative node reference")
-	}
-}
-
-func (n *lruNode) deref() {
-	n.ns.lru.mu.Lock()
-	n.derefNB()
-	n.ns.lru.mu.Unlock()
-}
-
-type lruHandle struct {
-	node *lruNode
-	once uint32
-}
-
-func (h *lruHandle) Value() interface{} {
-	if atomic.LoadUint32(&h.once) == 0 {
-		return h.node.value
-	}
-	return nil
-}
-
-func (h *lruHandle) Release() {
-	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
-		return
-	}
-	h.node.deref()
-	h.node = nil
-}
-
-func rbIsRed(h *lruNode) bool {
-	if h == nil {
-		return false
-	}
-	return !h.rbBlack
-}
-
-func rbRotLeft(h *lruNode) *lruNode {
-	x := h.rbRight
-	if x.rbBlack {
-		panic("rotating a black link")
-	}
-	h.rbRight = x.rbLeft
-	x.rbLeft = h
-	x.rbBlack = h.rbBlack
-	h.rbBlack = false
-	return x
-}
-
-func rbRotRight(h *lruNode) *lruNode {
-	x := h.rbLeft
-	if x.rbBlack {
-		panic("rotating a black link")
-	}
-	h.rbLeft = x.rbRight
-	x.rbRight = h
-	x.rbBlack = h.rbBlack
-	h.rbBlack = false
-	return x
-}
-
-func rbFlip(h *lruNode) {
-	h.rbBlack = !h.rbBlack
-	h.rbLeft.rbBlack = !h.rbLeft.rbBlack
-	h.rbRight.rbBlack = !h.rbRight.rbBlack
-}
-
-func rbMoveLeft(h *lruNode) *lruNode {
-	rbFlip(h)
-	if rbIsRed(h.rbRight.rbLeft) {
-		h.rbRight = rbRotRight(h.rbRight)
-		h = rbRotLeft(h)
-		rbFlip(h)
-	}
-	return h
-}
-
-func rbMoveRight(h *lruNode) *lruNode {
-	rbFlip(h)
-	if rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-		rbFlip(h)
-	}
-	return h
-}
-
-func rbFixup(h *lruNode) *lruNode {
-	if rbIsRed(h.rbRight) {
-		h = rbRotLeft(h)
-	}
-
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-	}
-
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbRight) {
-		rbFlip(h)
-	}
-
-	return h
-}
-
-func rbDeleteMin(h *lruNode) (hn, n *lruNode) {
-	if h == nil {
-		return nil, nil
-	}
-	if h.rbLeft == nil {
-		return nil, h
-	}
-
-	if !rbIsRed(h.rbLeft) && !rbIsRed(h.rbLeft.rbLeft) {
-		h = rbMoveLeft(h)
-	}
-
-	h.rbLeft, n = rbDeleteMin(h.rbLeft)
-
-	return rbFixup(h), n
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go

@@ -9,14 +9,12 @@ package leveldb
 import (
 	"bytes"
 	"fmt"
-	"io"
-	"math/rand"
-	"testing"
-
-	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 	"github.com/syndtr/goleveldb/leveldb/storage"
+	"io"
+	"math/rand"
+	"testing"
 )
 
 const ctValSize = 1000
@@ -33,8 +31,8 @@ func newDbCorruptHarnessWopt(t *testing.T, o *opt.Options) *dbCorruptHarness {
 
 func newDbCorruptHarness(t *testing.T) *dbCorruptHarness {
 	return newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCache: cache.NewLRUCache(100),
-		Strict:     opt.StrictJournalChecksum,
+		BlockCacheCapacity: 100,
+		Strict:             opt.StrictJournalChecksum,
 	})
 }
 
@@ -269,9 +267,9 @@ func TestCorruptDB_TableIndex(t *testing.T) {
 func TestCorruptDB_MissingManifest(t *testing.T) {
 	rnd := rand.New(rand.NewSource(0x0badda7a))
 	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCache:  cache.NewLRUCache(100),
-		Strict:      opt.StrictJournalChecksum,
-		WriteBuffer: 1000 * 60,
+		BlockCacheCapacity: 100,
+		Strict:             opt.StrictJournalChecksum,
+		WriteBuffer:        1000 * 60,
 	})
 
 	h.build(1000)

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go

@@ -823,8 +823,8 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 	case p == "blockpool":
 		value = fmt.Sprintf("%v", db.s.tops.bpool)
 	case p == "cachedblock":
-		if bc := db.s.o.GetBlockCache(); bc != nil {
-			value = fmt.Sprintf("%d", bc.Size())
+		if db.s.tops.bcache != nil {
+			value = fmt.Sprintf("%d", db.s.tops.bcache.Size())
 		} else {
 			value = "<nil>"
 		}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go

@@ -8,6 +8,7 @@ package leveldb
 
 import (
 	"container/list"
+	"fmt"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -89,6 +90,10 @@ func (db *DB) newSnapshot() *Snapshot {
 	return snap
 }
 
+func (snap *Snapshot) String() string {
+	return fmt.Sprintf("leveldb.Snapshot{%d}", snap.elem.seq)
+}
+
 // Get gets the value for the given key. It returns ErrNotFound if
 // the DB does not contains the key.
 //

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_test.go

@@ -1271,7 +1271,7 @@ func TestDB_DeletionMarkers2(t *testing.T) {
 }
 
 func TestDB_CompactionTableOpenError(t *testing.T) {
-	h := newDbHarnessWopt(t, &opt.Options{CachedOpenFiles: -1})
+	h := newDbHarnessWopt(t, &opt.Options{OpenFilesCacheCapacity: -1})
 	defer h.close()
 
 	im := 10
@@ -1629,8 +1629,8 @@ func TestDB_ManualCompaction(t *testing.T) {
 
 func TestDB_BloomFilter(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
-		BlockCache: opt.NoCache,
-		Filter:     filter.NewBloomFilter(10),
+		DisableBlockCache: true,
+		Filter:            filter.NewBloomFilter(10),
 	})
 	defer h.close()
 
@@ -2066,8 +2066,8 @@ func TestDB_GetProperties(t *testing.T) {
 
 func TestDB_GoleveldbIssue72and83(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
-		WriteBuffer:     1 * opt.MiB,
-		CachedOpenFiles: 3,
+		WriteBuffer:            1 * opt.MiB,
+		OpenFilesCacheCapacity: 3,
 	})
 	defer h.close()
 
@@ -2200,7 +2200,7 @@ func TestDB_GoleveldbIssue72and83(t *testing.T) {
 func TestDB_TransientError(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
 		WriteBuffer:              128 * opt.KiB,
-		CachedOpenFiles:          3,
+		OpenFilesCacheCapacity:   3,
 		DisableCompactionBackoff: true,
 	})
 	defer h.close()
@@ -2410,7 +2410,7 @@ func TestDB_TableCompactionBuilder(t *testing.T) {
 		CompactionTableSize:         43 * opt.KiB,
 		CompactionExpandLimitFactor: 1,
 		CompactionGPOverlapsFactor:  1,
-		BlockCache:                  opt.NoCache,
+		DisableBlockCache:           true,
 	}
 	s, err := newSession(stor, o)
 	if err != nil {

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go

@@ -112,9 +112,9 @@ func (db *DB) flush(n int) (mem *memDB, nn int, err error) {
 		db.writeDelay += time.Since(start)
 		db.writeDelayN++
 	} else if db.writeDelayN > 0 {
+		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
 		db.writeDelay = 0
 		db.writeDelayN = 0
-		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
 	}
 	return
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go

@@ -17,14 +17,14 @@ import (
 var _ = testutil.Defer(func() {
 	Describe("Leveldb external", func() {
 		o := &opt.Options{
-			BlockCache:           opt.NoCache,
-			BlockRestartInterval: 5,
-			BlockSize:            80,
-			Compression:          opt.NoCompression,
-			CachedOpenFiles:      -1,
-			Strict:               opt.StrictAll,
-			WriteBuffer:          1000,
-			CompactionTableSize:  2000,
+			DisableBlockCache:      true,
+			BlockRestartInterval:   5,
+			BlockSize:              80,
+			Compression:            opt.NoCompression,
+			OpenFilesCacheCapacity: -1,
+			Strict:                 opt.StrictAll,
+			WriteBuffer:            1000,
+			CompactionTableSize:    2000,
 		}
 
 		Describe("write test", func() {

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go

@@ -106,7 +106,7 @@ func (ik iKey) assert() {
 		panic("leveldb: nil iKey")
 	}
 	if len(ik) < 8 {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", ik, len(ik)))
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", []byte(ik), len(ik)))
 	}
 }
 
@@ -124,7 +124,7 @@ func (ik iKey) parseNum() (seq uint64, kt kType) {
 	num := ik.num()
 	seq, kt = uint64(num>>8), kType(num&0xff)
 	if kt > ktVal {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", ik, len(ik), kt))
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))
 	}
 	return
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go

@@ -20,8 +20,9 @@ const (
 	GiB = MiB * 1024
 )
 
-const (
-	DefaultBlockCacheSize                = 8 * MiB
+var (
+	DefaultBlockCacher                   = LRUCacher
+	DefaultBlockCacheCapacity            = 8 * MiB
 	DefaultBlockRestartInterval          = 16
 	DefaultBlockSize                     = 4 * KiB
 	DefaultCompactionExpandLimitFactor   = 25
@@ -33,7 +34,8 @@ const (
 	DefaultCompactionTotalSize           = 10 * MiB
 	DefaultCompactionTotalSizeMultiplier = 10.0
 	DefaultCompressionType               = SnappyCompression
-	DefaultCachedOpenFiles               = 500
+	DefaultOpenFilesCacher               = LRUCacher
+	DefaultOpenFilesCacheCapacity        = 500
 	DefaultMaxMemCompationLevel          = 2
 	DefaultNumLevel                      = 7
 	DefaultWriteBuffer                   = 4 * MiB
@@ -41,22 +43,33 @@ const (
 	DefaultWriteL0SlowdownTrigger        = 8
 )
 
-type noCache struct{}
+// Cacher is a caching algorithm.
+type Cacher interface {
+	New(capacity int) cache.Cacher
+}
 
-func (noCache) SetCapacity(capacity int)                     {}
-func (noCache) Capacity() int                                { return 0 }
-func (noCache) Used() int                                    { return 0 }
-func (noCache) Size() int                                    { return 0 }
-func (noCache) NumObjects() int                              { return 0 }
-func (noCache) GetNamespace(id uint64) cache.Namespace       { return nil }
-func (noCache) PurgeNamespace(id uint64, fin cache.PurgeFin) {}
-func (noCache) ZapNamespace(id uint64)                       {}
-func (noCache) Purge(fin cache.PurgeFin)                     {}
-func (noCache) Zap()                                         {}
+type CacherFunc struct {
+	NewFunc func(capacity int) cache.Cacher
+}
 
-var NoCache cache.Cache = noCache{}
+func (f *CacherFunc) New(capacity int) cache.Cacher {
+	if f.NewFunc != nil {
+		return f.NewFunc(capacity)
+	}
+	return nil
+}
 
-// Compression is the per-block compression algorithm to use.
+func noCacher(int) cache.Cacher { return nil }
+
+var (
+	// LRUCacher is the LRU-cache algorithm.
+	LRUCacher = &CacherFunc{cache.NewLRU}
+
+	// NoCacher is the value to disable caching algorithm.
+	NoCacher = &CacherFunc{}
+)
+
+// Compression is the 'sorted table' block compression algorithm to use.
 type Compression uint
 
 func (c Compression) String() string {
@@ -133,16 +146,17 @@ type Options struct {
 	// The default value is nil
 	AltFilters []filter.Filter
 
-	// BlockCache provides per-block caching for LevelDB. Specify NoCache to
-	// disable block caching.
+	// BlockCacher provides cache algorithm for LevelDB 'sorted table' block caching.
+	// Specify NoCacher to disable caching algorithm.
 	//
-	// By default LevelDB will create LRU-cache with capacity of BlockCacheSize.
-	BlockCache cache.Cache
+	// The default value is LRUCacher.
+	BlockCacher Cacher
 
-	// BlockCacheSize defines the capacity of the default 'block cache'.
+	// BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+	// Use -1 for zero, this has same effect with specifying NoCacher to BlockCacher.
 	//
 	// The default value is 8MiB.
-	BlockCacheSize int
+	BlockCacheCapacity int
 
 	// BlockRestartInterval is the number of keys between restart points for
 	// delta encoding of keys.
@@ -156,13 +170,6 @@ type Options struct {
 	// The default value is 4KiB.
 	BlockSize int
 
-	// CachedOpenFiles defines number of open files to kept around when not
-	// in-use, the counting includes still in-use files.
-	// Set this to negative value to disable caching.
-	//
-	// The default value is 500.
-	CachedOpenFiles int
-
 	// CompactionExpandLimitFactor limits compaction size after expanded.
 	// This will be multiplied by table size limit at compaction target level.
 	//
@@ -237,11 +244,17 @@ type Options struct {
 	// The default value uses the same ordering as bytes.Compare.
 	Comparer comparer.Comparer
 
-	// Compression defines the per-block compression to use.
+	// Compression defines the 'sorted table' block compression to use.
 	//
 	// The default value (DefaultCompression) uses snappy compression.
 	Compression Compression
 
+	// DisableBlockCache allows disable use of cache.Cache functionality on
+	// 'sorted table' block.
+	//
+	// The default value is false.
+	DisableBlockCache bool
+
 	// DisableCompactionBackoff allows disable compaction retry backoff.
 	//
 	// The default value is false.
@@ -288,6 +301,18 @@ type Options struct {
 	// The default is 7.
 	NumLevel int
 
+	// OpenFilesCacher provides cache algorithm for open files caching.
+	// Specify NoCacher to disable caching algorithm.
+	//
+	// The default value is LRUCacher.
+	OpenFilesCacher Cacher
+
+	// OpenFilesCacheCapacity defines the capacity of the open files caching.
+	// Use -1 for zero, this has same effect with specifying NoCacher to OpenFilesCacher.
+	//
+	// The default value is 500.
+	OpenFilesCacheCapacity int
+
 	// Strict defines the DB strict level.
 	Strict Strict
 
@@ -320,18 +345,22 @@ func (o *Options) GetAltFilters() []filter.Filter {
 	return o.AltFilters
 }
 
-func (o *Options) GetBlockCache() cache.Cache {
-	if o == nil {
+func (o *Options) GetBlockCacher() Cacher {
+	if o == nil || o.BlockCacher == nil {
+		return DefaultBlockCacher
+	} else if o.BlockCacher == NoCacher {
 		return nil
 	}
-	return o.BlockCache
+	return o.BlockCacher
 }
 
-func (o *Options) GetBlockCacheSize() int {
-	if o == nil || o.BlockCacheSize <= 0 {
-		return DefaultBlockCacheSize
+func (o *Options) GetBlockCacheCapacity() int {
+	if o == nil || o.BlockCacheCapacity <= 0 {
+		return DefaultBlockCacheCapacity
+	} else if o.BlockCacheCapacity == -1 {
+		return 0
 	}
-	return o.BlockCacheSize
+	return o.BlockCacheCapacity
 }
 
 func (o *Options) GetBlockRestartInterval() int {
@@ -348,15 +377,6 @@ func (o *Options) GetBlockSize() int {
 	return o.BlockSize
 }
 
-func (o *Options) GetCachedOpenFiles() int {
-	if o == nil || o.CachedOpenFiles == 0 {
-		return DefaultCachedOpenFiles
-	} else if o.CachedOpenFiles < 0 {
-		return 0
-	}
-	return o.CachedOpenFiles
-}
-
 func (o *Options) GetCompactionExpandLimit(level int) int {
 	factor := DefaultCompactionExpandLimitFactor
 	if o != nil && o.CompactionExpandLimitFactor > 0 {
@@ -494,6 +514,25 @@ func (o *Options) GetNumLevel() int {
 	return o.NumLevel
 }
 
+func (o *Options) GetOpenFilesCacher() Cacher {
+	if o == nil || o.OpenFilesCacher == nil {
+		return DefaultOpenFilesCacher
+	}
+	if o.OpenFilesCacher == NoCacher {
+		return nil
+	}
+	return o.OpenFilesCacher
+}
+
+func (o *Options) GetOpenFilesCacheCapacity() int {
+	if o == nil || o.OpenFilesCacheCapacity <= 0 {
+		return DefaultOpenFilesCacheCapacity
+	} else if o.OpenFilesCacheCapacity == -1 {
+		return 0
+	}
+	return o.OpenFilesCacheCapacity
+}
+
 func (o *Options) GetStrict(strict Strict) bool {
 	if o == nil || o.Strict == 0 {
 		return DefaultStrict&strict != 0

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go

@@ -7,7 +7,6 @@
 package leveldb
 
 import (
-	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 )
@@ -32,13 +31,6 @@ func (s *session) setOptions(o *opt.Options) {
 			no.AltFilters[i] = &iFilter{filter}
 		}
 	}
-	// Block cache.
-	switch o.GetBlockCache() {
-	case nil:
-		no.BlockCache = cache.NewLRUCache(o.GetBlockCacheSize())
-	case opt.NoCache:
-		no.BlockCache = nil
-	}
 	// Comparer.
 	s.icmp = &iComparer{o.GetComparer()}
 	no.Comparer = s.icmp

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session.go

@@ -73,7 +73,7 @@ func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
 		stCompPtrs: make([]iKey, o.GetNumLevel()),
 	}
 	s.setOptions(o)
-	s.tops = newTableOps(s, s.o.GetCachedOpenFiles())
+	s.tops = newTableOps(s)
 	s.setVersion(newVersion(s))
 	s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
 	return
@@ -82,9 +82,6 @@ func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
 // Close session.
 func (s *session) close() {
 	s.tops.close()
-	if bc := s.o.GetBlockCache(); bc != nil {
-		bc.Purge(nil)
-	}
 	if s.manifest != nil {
 		s.manifest.Close()
 	}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go

@@ -221,7 +221,7 @@ func (fs *fileStorage) GetManifest() (f File, err error) {
 					fs.log(fmt.Sprintf("skipping %s: invalid file name", fn))
 					continue
 				}
-				if _, e1 := strconv.ParseUint(fn[7:], 10, 0); e1 != nil {
+				if _, e1 := strconv.ParseUint(fn[8:], 10, 0); e1 != nil {
 					fs.log(fmt.Sprintf("skipping %s: invalid file num: %v", fn, e1))
 					continue
 				}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table.go

@@ -286,10 +286,10 @@ func (x *tFilesSortByNum) Less(i, j int) bool {
 
 // Table operations.
 type tOps struct {
-	s       *session
-	cache   cache.Cache
-	cacheNS cache.Namespace
-	bpool   *util.BufferPool
+	s      *session
+	cache  *cache.Cache
+	bcache *cache.Cache
+	bpool  *util.BufferPool
 }
 
 // Creates an empty table and returns table writer.
@@ -338,26 +338,28 @@ func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
 
 // Opens table. It returns a cache handle, which should
 // be released after use.
-func (t *tOps) open(f *tFile) (ch cache.Handle, err error) {
+func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
 	num := f.file.Num()
-	ch = t.cacheNS.Get(num, func() (charge int, value interface{}) {
+	ch = t.cache.Get(0, num, func() (size int, value cache.Value) {
 		var r storage.Reader
 		r, err = f.file.Open()
 		if err != nil {
 			return 0, nil
 		}
 
-		var bcacheNS cache.Namespace
-		if bc := t.s.o.GetBlockCache(); bc != nil {
-			bcacheNS = bc.GetNamespace(num)
+		var bcache *cache.CacheGetter
+		if t.bcache != nil {
+			bcache = &cache.CacheGetter{Cache: t.bcache, NS: num}
 		}
+
 		var tr *table.Reader
-		tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcacheNS, t.bpool, t.s.o.Options)
+		tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcache, t.bpool, t.s.o.Options)
 		if err != nil {
 			r.Close()
 			return 0, nil
 		}
 		return 1, tr
+
 	})
 	if ch == nil && err == nil {
 		err = ErrClosed
@@ -412,16 +414,14 @@ func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) ite
 // no one use the the table.
 func (t *tOps) remove(f *tFile) {
 	num := f.file.Num()
-	t.cacheNS.Delete(num, func(exist, pending bool) {
-		if !pending {
-			if err := f.file.Remove(); err != nil {
-				t.s.logf("table@remove removing @%d %q", num, err)
-			} else {
-				t.s.logf("table@remove removed @%d", num)
-			}
-			if bc := t.s.o.GetBlockCache(); bc != nil {
-				bc.ZapNamespace(num)
-			}
+	t.cache.Delete(0, num, func() {
+		if err := f.file.Remove(); err != nil {
+			t.s.logf("table@remove removing @%d %q", num, err)
+		} else {
+			t.s.logf("table@remove removed @%d", num)
+		}
+		if t.bcache != nil {
+			t.bcache.EvictNS(num)
 		}
 	})
 }
@@ -429,18 +429,34 @@ func (t *tOps) remove(f *tFile) {
 // Closes the table ops instance. It will close all tables,
 // regadless still used or not.
 func (t *tOps) close() {
-	t.cache.Zap()
 	t.bpool.Close()
+	t.cache.Close()
+	if t.bcache != nil {
+		t.bcache.Close()
+	}
 }
 
 // Creates new initialized table ops instance.
-func newTableOps(s *session, cacheCap int) *tOps {
-	c := cache.NewLRUCache(cacheCap)
+func newTableOps(s *session) *tOps {
+	var (
+		cacher cache.Cacher
+		bcache *cache.Cache
+	)
+	if s.o.GetOpenFilesCacheCapacity() > 0 {
+		cacher = cache.NewLRU(s.o.GetOpenFilesCacheCapacity())
+	}
+	if !s.o.DisableBlockCache {
+		var bcacher cache.Cacher
+		if s.o.GetBlockCacheCapacity() > 0 {
+			bcacher = cache.NewLRU(s.o.GetBlockCacheCapacity())
+		}
+		bcache = cache.NewCache(bcacher)
+	}
 	return &tOps{
-		s:       s,
-		cache:   c,
-		cacheNS: c.GetNamespace(0),
-		bpool:   util.NewBufferPool(s.o.GetBlockSize() + 5),
+		s:      s,
+		cache:  cache.NewCache(cacher),
+		bcache: bcache,
+		bpool:  util.NewBufferPool(s.o.GetBlockSize() + 5),
 	}
 }
 

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/reader.go

@@ -509,7 +509,7 @@ type Reader struct {
 	mu     sync.RWMutex
 	fi     *storage.FileInfo
 	reader io.ReaderAt
-	cache  cache.Namespace
+	cache  *cache.CacheGetter
 	err    error
 	bpool  *util.BufferPool
 	// Options
@@ -613,18 +613,22 @@ func (r *Reader) readBlock(bh blockHandle, verifyChecksum bool) (*block, error)
 
 func (r *Reader) readBlockCached(bh blockHandle, verifyChecksum, fillCache bool) (*block, util.Releaser, error) {
 	if r.cache != nil {
-		var err error
-		ch := r.cache.Get(bh.offset, func() (charge int, value interface{}) {
-			if !fillCache {
-				return 0, nil
-			}
-			var b *block
-			b, err = r.readBlock(bh, verifyChecksum)
-			if err != nil {
-				return 0, nil
-			}
-			return cap(b.data), b
-		})
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *block
+				b, err = r.readBlock(bh, verifyChecksum)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
 		if ch != nil {
 			b, ok := ch.Value().(*block)
 			if !ok {
@@ -667,18 +671,22 @@ func (r *Reader) readFilterBlock(bh blockHandle) (*filterBlock, error) {
 
 func (r *Reader) readFilterBlockCached(bh blockHandle, fillCache bool) (*filterBlock, util.Releaser, error) {
 	if r.cache != nil {
-		var err error
-		ch := r.cache.Get(bh.offset, func() (charge int, value interface{}) {
-			if !fillCache {
-				return 0, nil
-			}
-			var b *filterBlock
-			b, err = r.readFilterBlock(bh)
-			if err != nil {
-				return 0, nil
-			}
-			return cap(b.data), b
-		})
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *filterBlock
+				b, err = r.readFilterBlock(bh)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
 		if ch != nil {
 			b, ok := ch.Value().(*filterBlock)
 			if !ok {
@@ -980,7 +988,7 @@ func (r *Reader) Release() {
 // The fi, cache and bpool is optional and can be nil.
 //
 // The returned table reader instance is goroutine-safe.
-func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache cache.Namespace, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
+func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache *cache.CacheGetter, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
 	if f == nil {
 		return nil, errors.New("leveldb/table: nil file")
 	}

Godeps/_workspace/src/golang.org/x/text/transform/transform_test.go

@@ -16,7 +16,7 @@ import (
 	"unicode/utf8"
 )
 
-type lowerCaseASCII struct{ transform.NopResetter }
+type lowerCaseASCII struct{ NopResetter }
 
 func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -34,7 +34,7 @@ func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, er
 
 var errYouMentionedX = errors.New("you mentioned X")
 
-type dontMentionX struct{ transform.NopResetter }
+type dontMentionX struct{ NopResetter }
 
 func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -52,7 +52,7 @@ func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 
 // doublerAtEOF is a strange Transformer that transforms "this" to "tthhiiss",
 // but only if atEOF is true.
-type doublerAtEOF struct{ transform.NopResetter }
+type doublerAtEOF struct{ NopResetter }
 
 func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	if !atEOF {
@@ -71,7 +71,7 @@ func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 // rleDecode and rleEncode implement a toy run-length encoding: "aabbbbbbbbbb"
 // is encoded as "2a10b". The decoding is assumed to not contain any numbers.
 
-type rleDecode struct{ transform.NopResetter }
+type rleDecode struct{ NopResetter }
 
 func (rleDecode) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 loop:
@@ -104,7 +104,7 @@ loop:
 }
 
 type rleEncode struct {
-	transform.NopResetter
+	NopResetter
 
 	// allowStutter means that "xxxxxxxx" can be encoded as "5x3x"
 	// instead of always as "8x".

NICKS

@@ -10,11 +10,13 @@ alex2108	<register-github@alex-graf.de>
 andrew-d	<andrew@du.nham.ca>
 asdil12		<dominik@heidler.eu>
 bigbear2nd	<bigbear2nd@gmail.com>
+brendanlong	<self@brendanlong.com>
 bsidhom		<bsidhom@gmail.com>
 calmh		<jakob@nym.se>
 cdata		<chris@scriptolo.gy>
 ceh		<emil@hessman.se>
 cqcallaw	<enlightened.despot@gmail.com>
+facastagnini	<federico.castagnini@gmail.com>
 filoozoom	<philippe@schommers.be>
 frioux		<frew@afoolishmanifesto.com> <frioux@gmail.com>
 gillisig	<gilli@vx.is>
@@ -23,6 +25,7 @@ jpjp		<jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
 kozec		<kozec@kozec.com>
 marcindziadus	<dziadus.marcin@gmail.com>
 mvdan		<mvdan@mvdan.cc>
+peterhoeg	<peter@speartail.com>
 philips		<brandon@ifup.org>
 piobpl		<piotrb10@gmail.com>
 pluby		<phill.luby@newredo.com>
@@ -30,6 +33,7 @@ pyfisch		<pyfisch@gmail.com>
 qbit		<qbit@deftly.net>
 seehuhn		<voss@seehuhn.de>
 snnd		<dw@risu.io>
+timabell	<tim@timwise.co.uk>
 tojrobinson	<tully@tojr.org>
 uok		<ueomkail@gmail.com> <uok@users.noreply.github.com>
 veeti		<veeti.paananen@rojekti.fi>

README.md

@@ -11,7 +11,7 @@ This is the `syncthing` project. The following are the project goals:
     collaborating devices. The protocol should be well defined, unambiguous,
     easily understood, free to use, efficient, secure and language neutral.
     This is the [Block Exchange
-    Protocol](https://github.com/syncthing/protocol/blob/master/BEPv1.md).
+    Protocol](https://github.com/syncthing/specs/blob/master/BEPv1.md).
 
  2. Provide the reference implementation to demonstrate the usability of
     said protocol. This is the `syncthing` utility. It is the hope that
@@ -25,7 +25,8 @@ for incompatible changes.
 Getting Started
 ---------------
 
-Take a look at the [getting started guide](http://discourse.syncthing.net/t/46).
+Take a look at the [getting started
+guide](https://github.com/syncthing/syncthing/wiki/Getting-Started).
 
 There are a few examples for keeping syncthing running in the background
 on your system in [the etc directory](https://github.com/syncthing/syncthing/blob/master/etc).
@@ -37,23 +38,23 @@ Building
 --------
 
 Building Syncthing from source is easy, and there's a
-[guide](http://discourse.syncthing.net/t/44)
+[guide](https://github.com/syncthing/syncthing/wiki/Building).
 that describes it for both Unix and Windows.
 
 Signed Releases
 ---------------
 
-As of v0.7.0 and onwards, git tags and release binaries are GPG signed with
-the key BCE524C7 (http://nym.se/gpg.txt). For release binaries, MD5 and
-SHA1 checksums are calculated and signed, available in the
-md5sum.txt.asc and sha1sum.txt.asc files.
+As of v0.10.15 and onwards, git tags and release binaries are GPG signed
+with the key D26E6ED000654A3E (see http://syncthing.net/security.html).
+For release binaries, MD5 and SHA1 checksums are calculated and signed,
+available in the md5sum.txt.asc and sha1sum.txt.asc files.
 
 Documentation
 =============
 
 The [syncthing
-documentation](http://discourse.syncthing.net/category/documentation) is
-on the discourse site.
+documentation](https://github.com/syncthing/syncthing/wiki/) is on the
+Github wiki.
 
 All code is licensed under the
 [GPL](https://github.com/syncthing/syncthing/blob/master/LICENSE), v3 or

build.go

@@ -73,7 +73,7 @@ func main() {
 	flag.Parse()
 
 	switch goarch {
-	case "386", "amd64", "arm", "armv5", "armv6", "armv7":
+	case "386", "amd64", "arm":
 		break
 	default:
 		log.Printf("Unknown goarch %q; proceed with caution!", goarch)
@@ -226,15 +226,20 @@ func buildTar() {
 	build("./cmd/syncthing", tags)
 	filename := name + ".tar.gz"
 	files := []archiveFile{
-		{"README.md", name + "/README.txt"},
-		{"LICENSE", name + "/LICENSE.txt"},
-		{"AUTHORS", name + "/AUTHORS.txt"},
-		{"syncthing", name + "/syncthing"},
-		{"syncthing.md5", name + "/syncthing.md5"},
+		{src: "README.md", dst: name + "/README.txt"},
+		{src: "LICENSE", dst: name + "/LICENSE.txt"},
+		{src: "AUTHORS", dst: name + "/AUTHORS.txt"},
+		{src: "syncthing", dst: name + "/syncthing"},
+		{src: "syncthing.md5", dst: name + "/syncthing.md5"},
 	}
+
 	for _, file := range listFiles("etc") {
-		files = append(files, archiveFile{file, name + "/" + file})
+		files = append(files, archiveFile{src: file, dst: name + "/" + file})
 	}
+	for _, file := range listFiles("extra") {
+		files = append(files, archiveFile{src: file, dst: name + "/" + filepath.Base(file)})
+	}
+
 	tarGz(filename, files)
 	log.Println(filename)
 }
@@ -249,12 +254,17 @@ func buildZip() {
 	build("./cmd/syncthing", tags)
 	filename := name + ".zip"
 	files := []archiveFile{
-		{"README.md", name + "/README.txt"},
-		{"LICENSE", name + "/LICENSE.txt"},
-		{"AUTHORS", name + "/AUTHORS.txt"},
-		{"syncthing.exe", name + "/syncthing.exe"},
-		{"syncthing.exe.md5", name + "/syncthing.exe.md5"},
+		{src: "README.md", dst: name + "/README.txt"},
+		{src: "LICENSE", dst: name + "/LICENSE.txt"},
+		{src: "AUTHORS", dst: name + "/AUTHORS.txt"},
+		{src: "syncthing.exe", dst: name + "/syncthing.exe"},
+		{src: "syncthing.exe.md5", dst: name + "/syncthing.exe.md5"},
 	}
+
+	for _, file := range listFiles("extra") {
+		files = append(files, archiveFile{src: file, dst: name + "/" + filepath.Base(file)})
+	}
+
 	zipFile(filename, files)
 	log.Println(filename)
 }
@@ -275,15 +285,7 @@ func listFiles(dir string) []string {
 
 func setBuildEnv() {
 	os.Setenv("GOOS", goos)
-	if strings.HasPrefix(goarch, "armv") {
-		os.Setenv("GOARCH", "arm")
-		os.Setenv("GOARM", goarch[4:])
-	} else {
-		os.Setenv("GOARCH", goarch)
-	}
-	if goarch == "386" {
-		os.Setenv("GO386", "387")
-	}
+	os.Setenv("GOARCH", goarch)
 	wd, err := os.Getwd()
 	if err != nil {
 		log.Println("Warning: can't determine current dir:", err)

build.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 IFS=$'\n\t'
 
-DOCKERIMGV=1.4-4
+DOCKERIMGV=1.4-5
 
 case "${1:-default}" in
 	default)
@@ -52,9 +52,7 @@ case "${1:-default}" in
 	all)
 		go run build.go -goos linux -goarch amd64 tar
 		go run build.go -goos linux -goarch 386 tar
-		go run build.go -goos linux -goarch armv5 tar
-		go run build.go -goos linux -goarch armv6 tar
-		go run build.go -goos linux -goarch armv7 tar
+		go run build.go -goos linux -goarch arm tar
 
 		go run build.go -goos freebsd -goarch amd64 tar
 		go run build.go -goos freebsd -goarch 386 tar

cmd/stcompdirs/main.go

@@ -0,0 +1,177 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"crypto/md5"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/syncthing/syncthing/internal/symlinks"
+)
+
+func main() {
+	flag.Parse()
+	log.Println(compareDirectories(flag.Args()...))
+}
+
+// Compare a number of directories. Returns nil if the contents are identical,
+// otherwise an error describing the first found difference.
+func compareDirectories(dirs ...string) error {
+	chans := make([]chan fileInfo, len(dirs))
+	for i := range chans {
+		chans[i] = make(chan fileInfo)
+	}
+	errcs := make([]chan error, len(dirs))
+	abort := make(chan struct{})
+
+	for i := range dirs {
+		errcs[i] = startWalker(dirs[i], chans[i], abort)
+	}
+
+	res := make([]fileInfo, len(dirs))
+	for {
+		numDone := 0
+		for i := range chans {
+			fi, ok := <-chans[i]
+			if !ok {
+				err, hasError := <-errcs[i]
+				if hasError {
+					close(abort)
+					return err
+				}
+				numDone++
+			}
+			res[i] = fi
+		}
+
+		for i := 1; i < len(res); i++ {
+			if res[i] != res[0] {
+				close(abort)
+				if res[i].name < res[0].name {
+					return fmt.Errorf("%s missing %v (present in %s)", dirs[0], res[i], dirs[i])
+				} else if res[i].name > res[0].name {
+					return fmt.Errorf("%s missing %v (present in %s)", dirs[i], res[0], dirs[0])
+				}
+				return fmt.Errorf("Mismatch; %v (%s) != %v (%s)", res[i], dirs[i], res[0], dirs[0])
+			}
+		}
+
+		if numDone == len(dirs) {
+			return nil
+		}
+	}
+}
+
+type fileInfo struct {
+	name string
+	mode os.FileMode
+	mod  int64
+	hash [16]byte
+}
+
+func (f fileInfo) String() string {
+	return fmt.Sprintf("%s %04o %d %x", f.name, f.mode, f.mod, f.hash)
+}
+
+func startWalker(dir string, res chan<- fileInfo, abort <-chan struct{}) chan error {
+	walker := func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		rn, _ := filepath.Rel(dir, path)
+		if rn == "." || rn == ".stfolder" {
+			return nil
+		}
+		if rn == ".stversions" {
+			return filepath.SkipDir
+		}
+
+		var f fileInfo
+		if info.Mode()&os.ModeSymlink != 0 {
+			f = fileInfo{
+				name: rn,
+				mode: os.ModeSymlink,
+			}
+
+			tgt, _, err := symlinks.Read(path)
+			if err != nil {
+				return err
+			}
+			h := md5.New()
+			h.Write([]byte(tgt))
+			hash := h.Sum(nil)
+
+			copy(f.hash[:], hash)
+		} else if info.IsDir() {
+			f = fileInfo{
+				name: rn,
+				mode: info.Mode(),
+				// hash and modtime zero for directories
+			}
+		} else {
+			f = fileInfo{
+				name: rn,
+				mode: info.Mode(),
+				mod:  info.ModTime().Unix(),
+			}
+			sum, err := md5file(path)
+			if err != nil {
+				return err
+			}
+			f.hash = sum
+		}
+
+		select {
+		case res <- f:
+			return nil
+		case <-abort:
+			return errors.New("abort")
+		}
+	}
+
+	errc := make(chan error)
+	go func() {
+		err := filepath.Walk(dir, walker)
+		close(res)
+		if err != nil {
+			errc <- err
+		}
+		close(errc)
+	}()
+	return errc
+}
+
+func md5file(fname string) (hash [16]byte, err error) {
+	f, err := os.Open(fname)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+
+	h := md5.New()
+	io.Copy(h, f)
+	hb := h.Sum(nil)
+	copy(hash[:], hb)
+
+	return
+}

cmd/stfinddevice/main.go

@@ -0,0 +1,52 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+
+	"github.com/syncthing/syncthing/internal/discover"
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stdout)
+
+	var server string
+
+	flag.StringVar(&server, "server", "udp4://announce.syncthing.net:22026", "Announce server")
+	flag.Parse()
+
+	if len(flag.Args()) != 1 || server == "" {
+		log.Printf("Usage: %s [-server=\"udp4://announce.syncthing.net:22026\"] <device>", os.Args[0])
+		os.Exit(64)
+	}
+
+	id, err := protocol.DeviceIDFromString(flag.Args()[0])
+	if err != nil {
+		log.Println(err)
+		os.Exit(1)
+	}
+
+	discoverer := discover.NewDiscoverer(protocol.LocalDeviceID, nil)
+	discoverer.StartGlobal([]string{server}, 1)
+	for _, addr := range discoverer.Lookup(id) {
+		log.Println(addr)
+	}
+}

cmd/stindex/main.go

@@ -43,8 +43,8 @@ func main() {
 
 	if *device == "" {
 		log.Printf("*** Global index for folder %q", *folder)
-		fs.WithGlobalTruncated(func(fi protocol.FileIntf) bool {
-			f := fi.(protocol.FileInfoTruncated)
+		fs.WithGlobalTruncated(func(fi files.FileIntf) bool {
+			f := fi.(files.FileInfoTruncated)
 			fmt.Println(f)
 			fmt.Println("\t", fs.Availability(f.Name))
 			return true
@@ -55,8 +55,8 @@ func main() {
 			log.Fatal(err)
 		}
 		log.Printf("*** Have index for folder %q device %q", *folder, n)
-		fs.WithHaveTruncated(n, func(fi protocol.FileIntf) bool {
-			f := fi.(protocol.FileInfoTruncated)
+		fs.WithHaveTruncated(n, func(fi files.FileIntf) bool {
+			f := fi.(files.FileInfoTruncated)
 			fmt.Println(f)
 			return true
 		})

cmd/syncthing/gui.go

@@ -36,6 +36,7 @@ import (
 	"github.com/syncthing/syncthing/internal/config"
 	"github.com/syncthing/syncthing/internal/discover"
 	"github.com/syncthing/syncthing/internal/events"
+	"github.com/syncthing/syncthing/internal/files"
 	"github.com/syncthing/syncthing/internal/model"
 	"github.com/syncthing/syncthing/internal/osutil"
 	"github.com/syncthing/syncthing/internal/protocol"
@@ -149,6 +150,7 @@ func startGUI(cfg config.GUIConfiguration, assetDir string, m *model.Model) erro
 	postRestMux.HandleFunc("/rest/shutdown", restPostShutdown)
 	postRestMux.HandleFunc("/rest/upgrade", restPostUpgrade)
 	postRestMux.HandleFunc("/rest/scan", withModel(m, restPostScan))
+	postRestMux.HandleFunc("/rest/bump", withModel(m, restPostBump))
 
 	// A handler that splits requests between the two above and disables
 	// caching
@@ -314,19 +316,12 @@ func restGetNeed(m *model.Model, w http.ResponseWriter, r *http.Request) {
 	var qs = r.URL.Query()
 	var folder = qs.Get("folder")
 
-	files := m.NeedFolderFilesLimited(folder, 100) // max 100 files
+	progress, queued, rest := m.NeedFolderFiles(folder, 100)
 	// Convert the struct to a more loose structure, and inject the size.
-	output := make([]map[string]interface{}, 0, len(files))
-	for _, file := range files {
-		output = append(output, map[string]interface{}{
-			"Name":         file.Name,
-			"Flags":        file.Flags,
-			"Modified":     file.Modified,
-			"Version":      file.Version,
-			"LocalVersion": file.LocalVersion,
-			"NumBlocks":    file.NumBlocks,
-			"Size":         protocol.BlocksToSize(file.NumBlocks),
-		})
+	output := map[string][]map[string]interface{}{
+		"progress": toNeedSlice(progress),
+		"queued":   toNeedSlice(queued),
+		"rest":     toNeedSlice(rest),
 	}
 
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
@@ -454,6 +449,7 @@ func restGetSystem(w http.ResponseWriter, r *http.Request) {
 	}
 	cpuUsageLock.RUnlock()
 	res["cpuPercent"] = cpusum / 10
+	res["pathSeparator"] = string(filepath.Separator)
 
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	json.NewEncoder(w).Encode(res)
@@ -577,6 +573,10 @@ func restGetEvents(w http.ResponseWriter, r *http.Request) {
 }
 
 func restGetUpgrade(w http.ResponseWriter, r *http.Request) {
+	if noUpgrade {
+		http.Error(w, upgrade.ErrUpgradeUnsupported.Error(), 500)
+		return
+	}
 	rel, err := upgrade.LatestRelease(strings.Contains(Version, "-beta"))
 	if err != nil {
 		http.Error(w, err.Error(), 500)
@@ -650,6 +650,14 @@ func restPostScan(m *model.Model, w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func restPostBump(m *model.Model, w http.ResponseWriter, r *http.Request) {
+	qs := r.URL.Query()
+	folder := qs.Get("folder")
+	file := qs.Get("file")
+	m.BringToFront(folder, file)
+	restGetNeed(m, w, r)
+}
+
 func getQR(w http.ResponseWriter, r *http.Request) {
 	var qs = r.URL.Query()
 	var text = qs.Get("text")
@@ -775,3 +783,19 @@ func mimeTypeForFile(file string) string {
 		return mime.TypeByExtension(ext)
 	}
 }
+
+func toNeedSlice(fs []files.FileInfoTruncated) []map[string]interface{} {
+	output := make([]map[string]interface{}, len(fs))
+	for i, file := range fs {
+		output[i] = map[string]interface{}{
+			"Name":         file.Name,
+			"Flags":        file.Flags,
+			"Modified":     file.Modified,
+			"Version":      file.Version,
+			"LocalVersion": file.LocalVersion,
+			"NumBlocks":    file.NumBlocks,
+			"Size":         files.BlocksToSize(file.NumBlocks),
+		}
+	}
+	return output
+}

cmd/syncthing/main.go

@@ -341,7 +341,7 @@ func main() {
 
 		if doUpgrade {
 			// Use leveldb database locks to protect against concurrent upgrades
-			_, err = leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{CachedOpenFiles: 100})
+			_, err = leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{OpenFilesCacheCapacity: 100})
 			if err != nil {
 				l.Fatalln("Cannot upgrade, database seems to be locked. Is another copy of Syncthing already running?")
 			}
@@ -489,7 +489,7 @@ func syncthingMain() {
 		readRateLimit = ratelimit.NewBucketWithRate(float64(1000*opts.MaxRecvKbps), int64(5*1000*opts.MaxRecvKbps))
 	}
 
-	db, err := leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{CachedOpenFiles: 100})
+	db, err := leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{OpenFilesCacheCapacity: 100})
 	if err != nil {
 		l.Fatalln("Cannot open database:", err, "- Is another copy of Syncthing already running?")
 	}
@@ -795,7 +795,7 @@ func setupExternalPort(igd *upnp.IGD, port int) int {
 
 	for i := 0; i < 10; i++ {
 		r := 1024 + predictableRandom.Intn(65535-1024)
-		err := igd.AddPortMapping(upnp.TCP, r, port, "syncthing", cfg.Options().UPnPLease*60)
+		err := igd.AddPortMapping(upnp.TCP, r, port, fmt.Sprintf("syncthing-%d", r), cfg.Options().UPnPLease*60)
 		if err == nil {
 			return r
 		}
@@ -975,11 +975,16 @@ next:
 			}
 		}
 
-		events.Default.Log(events.DeviceRejected, map[string]string{
-			"device":  remoteID.String(),
-			"address": conn.RemoteAddr().String(),
-		})
-		l.Infof("Connection from %s with unknown device ID %s; ignoring", conn.RemoteAddr(), remoteID)
+		if !cfg.IgnoredDevice(remoteID) {
+			events.Default.Log(events.DeviceRejected, map[string]string{
+				"device":  remoteID.String(),
+				"address": conn.RemoteAddr().String(),
+			})
+			l.Infof("Connection from %s with unknown device ID %s", conn.RemoteAddr(), remoteID)
+		} else {
+			l.Infof("Connection from %s with ignored device ID %s", conn.RemoteAddr(), remoteID)
+		}
+
 		conn.Close()
 	}
 }
@@ -1254,27 +1259,35 @@ func standbyMonitor() {
 }
 
 func autoUpgrade() {
-	var skipped bool
-	interval := time.Duration(cfg.Options().AutoUpgradeIntervalH) * time.Hour
+	timer := time.NewTimer(0)
+	sub := events.Default.Subscribe(events.DeviceConnected)
 	for {
-		if skipped {
-			time.Sleep(interval)
-		} else {
-			skipped = true
+		select {
+		case event := <-sub.C():
+			data, ok := event.Data.(map[string]string)
+			if !ok || data["clientName"] != "syncthing" || upgrade.CompareVersions(data["clientVersion"], Version) != upgrade.Newer {
+				continue
+			}
+			l.Infof("Connected to device %s with a newer version (current %q < remote %q). Checking for upgrades.", data["id"], Version, data["clientVersion"])
+		case <-timer.C:
 		}
 
 		rel, err := upgrade.LatestRelease(IsBeta)
 		if err == upgrade.ErrUpgradeUnsupported {
+			events.Default.Unsubscribe(sub)
 			return
 		}
 		if err != nil {
 			// Don't complain too loudly here; we might simply not have
 			// internet connectivity, or the upgrade server might be down.
 			l.Infoln("Automatic upgrade:", err)
+			timer.Reset(time.Duration(cfg.Options().AutoUpgradeIntervalH) * time.Hour)
 			continue
 		}
 
-		if upgrade.CompareVersions(rel.Tag, Version) <= 0 {
+		if upgrade.CompareVersions(rel.Tag, Version) != upgrade.Newer {
+			// Skip equal, older or majorly newer (incompatible) versions
+			timer.Reset(time.Duration(cfg.Options().AutoUpgradeIntervalH) * time.Hour)
 			continue
 		}
 
@@ -1282,8 +1295,10 @@ func autoUpgrade() {
 		err = upgrade.To(rel)
 		if err != nil {
 			l.Warnln("Automatic upgrade:", err)
+			timer.Reset(time.Duration(cfg.Options().AutoUpgradeIntervalH) * time.Hour)
 			continue
 		}
+		events.Default.Unsubscribe(sub)
 		l.Warnf("Automatically upgraded to version %q. Restarting in 1 minute.", rel.Tag)
 		time.Sleep(time.Minute)
 		stop <- exitUpgrading

cmd/syncthing/random_test.go

@@ -15,14 +15,21 @@
 
 package main
 
-import "testing"
+import (
+	"sync"
+	"testing"
+)
+
+var predictableRandomTest sync.Once
 
 func TestPredictableRandom(t *testing.T) {
-	// predictable random sequence is predictable
-	e := 3440579354231278675
-	if v := predictableRandom.Int(); v != e {
-		t.Errorf("Unexpected random value %d != %d", v, e)
-	}
+	predictableRandomTest.Do(func() {
+		// predictable random sequence is predictable
+		e := 3440579354231278675
+		if v := predictableRandom.Int(); v != e {
+			t.Errorf("Unexpected random value %d != %d", v, e)
+		}
+	})
 }
 
 func TestSeedFromBytes(t *testing.T) {

docker/Dockerfile

@@ -17,9 +17,12 @@ RUN curl -sSL https://golang.org/dl/go${GOLANG_VERSION}.linux-amd64.tar.gz \
         | tar -v -C /usr/local -xz
 
 ENV PATH /usr/local/go/bin:$PATH
-RUN mkdir /go
 ENV GOPATH /go
+ENV GO386 387
+ENV GOARM 5
 ENV PATH /go/bin:$PATH
+
+RUN mkdir /go
 WORKDIR /go
 
 # Use gonative to install native Go for most arch/OS combos
@@ -45,8 +48,6 @@ RUN bash -xec '\
                 for platform in linux/386 freebsd/386 windows/386 linux/arm openbsd/amd64 openbsd/386; do \
                         GOOS=${platform%/*} \
                         GOARCH=${platform##*/} \
-                        GOARM=5 \
-                        GO386=387 \
                         CGO_ENABLED=0 \
                         ./make.bash --no-clean 2>&1; \
                 done \

etc/linux-systemd/README.md

@@ -0,0 +1,27 @@
+This directory contains a configuration for running syncthing under the
+"systemd" service manager on Linux both under either a systemd system service or
+systemd user service.
+
+ 1. Install systemd.
+
+ 2. If you are running this as a system level service:
+
+   1. Create the user you will be running the service as (foo in this example).
+
+   2. Copy the syncthing@.service files to /etc/systemd/system
+
+   3. Enable and start the service
+      systemctl enable syncthing@foo.service
+      systemctl start syncthing@foo.service
+
+ 3. If you are running this as a user level service:
+
+   1. Log in as the user you will be running the service as
+
+   2. Copy the syncthing.service files to /etc/systemd/user
+
+   3. Enable and start the service
+      systemctl --user enable syncthing.service
+      systemctl --user start syncthing.service
+
+Log output is sent to the journal.

etc/linux-systemd/system/syncthing@.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Syncthing service for %i
+After=network.target
+
+[Service]
+User=%i
+Environment=STARGS=
+EnvironmentFile=-/etc/default/syncthing
+Environment=STNORESTART=yes
+ExecStart=/usr/bin/syncthing ${STARGS}
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target

etc/linux-systemd/user/syncthing.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=Syncthing service
+
+[Service]
+Environment=STARGS=
+EnvironmentFile=-%h/.config/syncthing/environment
+Environment=STNORESTART=yes
+ExecStart=/usr/bin/syncthing ${STARGS}
+Restart=on-failure
+
+[Install]
+WantedBy=cmdline.target

gui/assets/css/overrides.css

@@ -39,6 +39,8 @@ ul+h5 {
 
 .panel-title {
     position: relative;
+    text-overflow: ellipsis;
+    overflow: hidden;
 }
 
 identicon {
@@ -54,6 +56,10 @@ identicon {
     margin-top: 0px;
 }
 
+.checkbox input[type="checkbox"], .radio input[type="radio"] {
+    float: none; /* issue #1197 */
+}
+
 .popover {
     max-width: none;
 }
@@ -69,6 +75,10 @@ identicon {
     top: 1px;
 }
 
+.panel-heading .glyphicon {
+    margin-right: 15px;
+}
+
 .panel-heading {
     position: relative;
     overflow: hidden;
@@ -195,3 +205,15 @@ ul.three-columns li, ul.two-columns li {
     padding-left: 0.5em;
     text-indent: -0.5em;
 }
+
+/** Footer nav on small devices **/
+
+@media (max-width: 767px) {
+    body {
+        padding-bottom: 0;
+    }
+
+    .navbar-fixed-bottom {
+        position: static;
+    }
+}

gui/assets/lang/lang-be.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Ключ API",
     "About": "Аб праграме",
+    "Add": "Add",
     "Add Device": "Дадаць прыладу",
     "Add Folder": "Дадаць каталёг",
+    "Add new folder?": "Add new folder?",
     "Address": "Адрас",
     "Addresses": "Адрасы",
     "Allow Anonymous Usage Reporting?": "Allow Anonymous Usage Reporting?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatic upgrades",
     "Bugs": "Bugs",
     "CPU Utilization": "CPU Utilization",
+    "Changelog": "Changelog",
     "Close": "Close",
     "Comment, when used at the start of a line": "Comment, when used at the start of a line",
     "Compression is recommended in most setups.": "Compression is recommended in most setups.",
@@ -22,6 +25,8 @@
     "Device ID": "Device ID",
     "Device Identification": "Device Identification",
     "Device Name": "Device Name",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Disconnected",
     "Documentation": "Documentation",
     "Download Rate": "Download Rate",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Global Discovery Server",
     "Global State": "Global State",
     "Idle": "Idle",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Ignore Patterns",
     "Ignore Permissions": "Ignore Permissions",
     "Incoming Rate Limit (KiB/s)": "Incoming Rate Limit (KiB/s)",
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Inversion of the given condition (i.e. do not exclude)",
     "Keep Versions": "Keep Versions",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Last File Synced",
     "Last seen": "Last seen",
+    "Later": "Later",
     "Latest Release": "Latest Release",
     "Local Discovery": "Local Discovery",
     "Local State": "Local State",
     "Maximum Age": "Maximum Age",
     "Multi level wildcard (matches multiple directory levels)": "Multi level wildcard (matches multiple directory levels)",
     "Never": "Never",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "No",
     "No File Versioning": "No File Versioning",
     "Notice": "Notice",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Select the devices to share this folder with.",
     "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Settings",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Share With Devices",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Shared With",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Short identifier for the folder. Must be the same on all cluster devices.",
     "Show ID": "Show ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Staggered File Versioning",
     "Start Browser": "Start Browser",
     "Stopped": "Stopped",
+    "Support": "Support",
     "Support / Forum": "Support / Forum",
     "Sync Protocol Listen Addresses": "Sync Protocol Listen Addresses",
     "Synchronization": "Synchronization",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing is restarting.",
     "Syncthing is upgrading.": "Syncthing is upgrading.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "The aggregated statistics are publicly available at {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.",
     "The device ID cannot be blank.": "The device ID cannot be blank.",
@@ -149,5 +164,6 @@
     "Yes": "Yes",
     "You must keep at least one version.": "You must keep at least one version.",
     "full documentation": "full documentation",
-    "items": "items"
+    "items": "items",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-bg.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API Ключ",
     "About": "За Програмата",
+    "Add": "Add",
     "Add Device": "Добави устройство",
     "Add Folder": "Добави папка",
+    "Add new folder?": "Add new folder?",
     "Address": "Адрес",
     "Addresses": "Адреси",
     "Allow Anonymous Usage Reporting?": "Разреши анонимен доклад за ползване на програмата?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Автоматични ъпдейти",
     "Bugs": "Бъгове",
     "CPU Utilization": "Натоварване на Процесора",
+    "Changelog": "Changelog",
     "Close": "Затвори",
     "Comment, when used at the start of a line": "Коментар, използван в началото на реда",
     "Compression is recommended in most setups.": "Компресията е препоръчителна в повечето конфигурации.",
@@ -22,6 +25,8 @@
     "Device ID": "Идентификатор на устройство",
     "Device Identification": "Идентификация на устройство",
     "Device Name": "Име на устройство",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Прекрати Връзката",
     "Documentation": "Документация",
     "Download Rate": "Скорост на Теглене",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Сървър за Глобално Откриване",
     "Global State": "Глобално състояние",
     "Idle": "Без Работа",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Шаблони за Игнориране",
     "Ignore Permissions": "Игнорирай Права за Достъп",
     "Incoming Rate Limit (KiB/s)": "Входящ Лимит на Скоростта (KiB/s)",
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Обратното на даденото условие (пр. не изключвай)",
     "Keep Versions": "Пази Версии",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Последния синхронизиран файл",
     "Last seen": "Последно видян",
+    "Later": "Later",
     "Latest Release": "Най-новата Версия",
     "Local Discovery": "Локално Откриване",
     "Local State": "Локално състояние",
     "Maximum Age": "Максимална Възраст",
     "Multi level wildcard (matches multiple directory levels)": "Маска на много нива (покрива папки с много нива)",
     "Never": "Никога",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Не",
     "No File Versioning": "Няма Файлови Версии",
     "Notice": "Известие",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Избери устройствата, с които да споделиш тази папка.",
     "Select the folders to share with this device.": "Изберете папките за споделяне с това устройство.",
     "Settings": "Настройки",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Сподели папки с това устройство",
     "Share With Devices": "Сподели с устройства",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Споделена със",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Кратък идентификатор на папката. Трябва да бъде същият на всички компютри.",
     "Show ID": "Покажи Идентификатора",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Наслагващи се Файлови Версии",
     "Start Browser": "Стартирай Браузъра",
     "Stopped": "Спряна",
+    "Support": "Support",
     "Support / Forum": "Помощ / Форум",
     "Sync Protocol Listen Addresses": "Адрес за слушане на синхронизиращия протокол",
     "Synchronization": "Синхронизация",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing се рестартирва",
     "Syncthing is upgrading.": "Syncthing се обновява.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing изглежда не е включен, или има проблем с интерент връзката. Повторен опит...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Сумарната статистика е публично достъпна на {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Конфигурацията е запазена, но не е активирана. Syncthing трябва да рестартира, за да се активира новата конфигурация.",
     "The device ID cannot be blank.": "Полето идентификатор на устройство не може да бъде празно.",
@@ -149,5 +164,6 @@
     "Yes": "Да",
     "You must keep at least one version.": "Трябва да пазиш поне една версия.",
     "full documentation": "пълна документация",
-    "items": "артикула"
+    "items": "артикула",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-cs.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API klíč",
     "About": "O aplikaci",
+    "Add": "Přidat",
     "Add Device": "Přidat přístroj",
     "Add Folder": "Přidat adresář",
+    "Add new folder?": "Přidat nový adresář?",
     "Address": "Adresa",
     "Addresses": "Adresy",
     "Allow Anonymous Usage Reporting?": "Povolit anonymní hlášení o používání?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatický upgrade",
     "Bugs": "Chyby",
     "CPU Utilization": "Využití CPU",
+    "Changelog": "Changelog",
     "Close": "Zavřít",
     "Comment, when used at the start of a line": "Komentář, pokud použito na začátku řádku",
     "Compression is recommended in most setups.": "Komprese je doporučena pro většinu nastavení.",
@@ -22,6 +25,8 @@
     "Device ID": "ID přístroje",
     "Device Identification": "Identifikace přístroje",
     "Device Name": "Jméno přístroje",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Přístroj {{device}} ({{address}}) žádá o připojení. Chcete ho přidat?",
+    "Devices": "Přístroje",
     "Disconnected": "Odpojeno",
     "Documentation": "Dokumentace",
     "Download Rate": "Rychlost stahování",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Server globálního oznamování",
     "Global State": "Všeobecný status",
     "Idle": "Nečinný",
+    "Ignore": "Ignorovat",
     "Ignore Patterns": "Ignorované vzory",
     "Ignore Permissions": "Ignorovat oprávnění",
     "Incoming Rate Limit (KiB/s)": "Omezení příchozí rychlosti (KiB/s)",
     "Introducer": "Zavaděč",
     "Inversion of the given condition (i.e. do not exclude)": "Prohození zadané podmínky (např. nevynechat)",
     "Keep Versions": "Ponechat verze",
+    "Last File Received": "Poslední soubor přijat",
     "Last File Synced": "Poslední soubor synchronizován",
     "Last seen": "Naposledy spatřen",
+    "Later": "Později",
     "Latest Release": "Poslední vydání",
     "Local Discovery": "Místní oznamování",
     "Local State": "Místní status",
     "Maximum Age": "Maximální časový limit",
     "Multi level wildcard (matches multiple directory levels)": "Víceúrovňový zástupný znak (shoda skrz více úrovní adresářů)",
     "Never": "Nikdy",
+    "New Device": "Nový přístroj",
+    "New Folder": "Nový adresář",
     "No": "Ne",
     "No File Versioning": "Bez verzí souborů",
     "Notice": "Oznámení",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Vybrat přístroje se kterými sdílet tento adresář.",
     "Select the folders to share with this device.": "Vybrat adresáře sdílené tomuto přístroji.",
     "Settings": "Nastavení",
+    "Share": "Sdílet",
+    "Share Folder": "Sdílet adresář",
     "Share Folders With Device": "Sdílet adresáře tomuto přístroji",
     "Share With Devices": "Sdílet s přístroji",
+    "Share this folder?": "Sdílet tento adresář?",
     "Shared With": "Sdíleno s",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Krátký identifikátor tohoto adresáře. Musí být stejný na všech přístrojích v clusteru.",
     "Show ID": "Zobrazit ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Vícenásobné verze souborů",
     "Start Browser": "Otevřít prohlížeč",
     "Stopped": "Pozastaveno",
+    "Support": "Podpora",
     "Support / Forum": "Podpora / Fórum",
     "Sync Protocol Listen Addresses": "Adresa naslouchání synchronizačního protokolu",
     "Synchronization": "Synchronizace",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing se restartuje.",
     "Syncthing is upgrading.": "Syncthing se aktualizuje.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing se zdá být nefunkční, nebo je problém s připojením k Internetu. Opakuji...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing má nejspíše problém s provedením vašeho požadavku. Pokud problém přetrvává, načtěte znovu data v prohlížeči nebo restartujte Syncthing.",
     "The aggregated statistics are publicly available at {%url%}.": "Souhrnné statistiky jsou veřejně dostupné na {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Konfigurace byla uložena, ale není aktivována. Pro aktivaci nové konfigurace je třeba restartovat Syncthing.",
     "The device ID cannot be blank.": "ID přístroje nemůže být prázdné.",
@@ -149,5 +164,6 @@
     "Yes": "Ano",
     "You must keep at least one version.": "Je třeba ponechat alespoň jednu verzi.",
     "full documentation": "plná dokumentace",
-    "items": "položky"
+    "items": "položky",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} chce sdílet adresář \"{{folder}}\"."
 }

gui/assets/lang/lang-de.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API-Schlüssel",
     "About": "Über Syncthing",
+    "Add": "Hinzufügen",
     "Add Device": "Gerät hinzufügen",
     "Add Folder": "Verzeichnis hinzufügen",
+    "Add new folder?": "Neues Verzeichnis hinzufügen?",
     "Address": "Adresse",
     "Addresses": "Adressen",
     "Allow Anonymous Usage Reporting?": "Übertragung von anonymen Nutzungsberichten erlauben?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automat. Updates",
     "Bugs": "Fehler",
     "CPU Utilization": "Prozessorauslastung",
+    "Changelog": "Versionsinfo",
     "Close": "Schließen",
     "Comment, when used at the start of a line": "Kommentar, wenn am Anfang der Zeile benutzt.",
     "Compression is recommended in most setups.": "Datenkomprimierung ist für die meisten Anwendungen empfohlen",
@@ -22,6 +25,8 @@
     "Device ID": "Geräte ID",
     "Device Identification": "Gerät Identifikation",
     "Device Name": "Gerätename",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Gerät {{device}} ({{address}}) möchte sich verbinden. Gerät hinzufügen?",
+    "Devices": "Geräte",
     "Disconnected": "Getrennt",
     "Documentation": "Dokumentation",
     "Download Rate": "Download",
@@ -37,7 +42,7 @@
     "Error": "Fehler",
     "File Versioning": "Dateiversionierung",
     "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Dateizugriffsrechte beim Suchen nach Veränderungen ignorieren. Bei FAT-Dateisystemen verwenden.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Dateien werden, bevor Syncthing sie löscht oder ersetzt, als datierte Versionen in einen Ordner names .stversions verschoben.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Dateien werden, bevor Syncthing sie löscht oder ersetzt, als datierte Versionen in ein Verzeichnis names .stversions verschoben.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Dateien sind vor Veränderung durch andere Geräte geschützt, auf diesem Gerät durchgeführte Veränderungen werden aber auf den Rest des Verbunds übertragen.",
     "Folder ID": "Verzeichnis ID",
     "Folder Master": "Keine Veränderungen zulassen",
@@ -51,31 +56,36 @@
     "Global Discovery Server": "Globaler Auffindungsserver",
     "Global State": "Globaler Status",
     "Idle": "Untätig",
+    "Ignore": "Ignorieren",
     "Ignore Patterns": "Ignoriermuster",
     "Ignore Permissions": "Berechtigungen ignorieren",
     "Incoming Rate Limit (KiB/s)": "Eingehendes Datenratelimit (KiB/s)",
     "Introducer": "Verteilergerät",
     "Inversion of the given condition (i.e. do not exclude)": "Umkehrung der angegebenen Bedingung (z.B. schließe nicht aus)",
     "Keep Versions": "Versionen erhalten",
+    "Last File Received": "Letzte Datei",
     "Last File Synced": "Letzte Änderung",
     "Last seen": "Zuletzt online",
+    "Later": "Später",
     "Latest Release": "Letzte Veröffentlichung",
     "Local Discovery": "Lokale Auffindung",
     "Local State": "Lokaler Status",
     "Maximum Age": "Höchstalter",
     "Multi level wildcard (matches multiple directory levels)": "Verschachteltes Maskenzeichen (wird für verschachtelte Verzeichnisse verwendet)",
     "Never": "Nie",
+    "New Device": "Neues Gerät",
+    "New Folder": "Neues Verzeichnis",
     "No": "Nein",
     "No File Versioning": "Keine Dateiversionierung",
-    "Notice": "Benachrichtigung",
-    "OK": "Ok",
+    "Notice": "Hinweis",
+    "OK": "OK",
     "Offline": "Offline",
     "Online": "Online",
     "Out Of Sync": "Nicht synchronisiert",
     "Outgoing Rate Limit (KiB/s)": "Ausgehendes Datenratelimit (KiB/s)",
     "Override Changes": "Änderungen überschreiben",
     "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Pfad zum Verzeichnis auf dem lokalen Rechner. Wird erzeugt, wenn es nicht existiert. Das Tilden-Zeichen (~) kann als Abkürzung benutzt werden für",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Pfad in dem die Versionen gespeichert werden sollen (ohne Angabe wird der Ordner .stversions im Verzeichnis verwendet).",
+    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Pfad in dem die Versionen gespeichert werden sollen (ohne Angabe wird das Verzeichnis .stversions im Verzeichnis verwendet).",
     "Please wait": "Bitte warten",
     "Preview": "Vorschau",
     "Preview Usage Report": "Vorschau des Nutzungsberichts",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Wähle die Geräte aus, mit denen Du dieses Verzeichnis teilen willst.",
     "Select the folders to share with this device.": "Wähle die Verzeichnisse aus, die du mit diesem Gerät teilen möchtest",
     "Settings": "Einstellungen",
-    "Share Folders With Device": "Teile Order mit diesem Gerät",
+    "Share": "Teilen",
+    "Share Folder": "Teile Verzeichnis",
+    "Share Folders With Device": "Teile Verzeichnisse mit diesem Gerät",
     "Share With Devices": "Teile mit diesen Geräten",
+    "Share this folder?": "Dieses Verzeichnis teilen?",
     "Shared With": "Geteilt mit",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kurze ID für das Verzeichnis. Muss auf allen Verbunds-Geräten gleich sein.",
     "Show ID": "ID anzeigen",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Stufenweise Dateiversionierung",
     "Start Browser": "Browser starten",
     "Stopped": "Gestoppt",
+    "Support": "Support",
     "Support / Forum": "Support / Forum",
     "Sync Protocol Listen Addresses": "Adresse(n) für das Synchronisierungsprotokoll",
     "Synchronization": "Synchronisierung",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing wird neu gestartet",
     "Syncthing is upgrading.": "Syncthing wird aktualisiert",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing scheint nicht erreichbar zu sein oder es gibt ein Problem mit Deiner Internetverbindung. Versuche erneut...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Es scheint als ob Syncthing ein Problem mit der Verarbeitung ihrer Eingabe hat. Bitte laden sie die Seite neu oder führen sie einen Neustart von Syncthing durch, falls das Problem weiterhin besteht.",
     "The aggregated statistics are publicly available at {%url%}.": "Die gesammelten Statistiken sind öffentlich verfügbar unter {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Die Konfiguration wurde gespeichert, aber nicht aktiviert. Syncthing muss neugestartet werden um die neue Konfiguration zu aktivieren.",
     "The device ID cannot be blank.": "Die Geräte ID darf nicht leer sein.",
@@ -149,5 +164,6 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Du musst mindestens eine Version behalten.",
     "full documentation": "Komplette Dokumentation",
-    "items": "Einträge"
+    "items": "Einträge",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} möchte das Verzeichnis \"{{folder}}\" teilen."
 }

gui/assets/lang/lang-en.json

@@ -1,8 +1,10 @@
 {
    "API Key": "API Key",
    "About": "About",
+   "Add": "Add",
    "Add Device": "Add Device",
    "Add Folder": "Add Folder",
+   "Add new folder?": "Add new folder?",
    "Address": "Address",
    "Addresses": "Addresses",
    "Allow Anonymous Usage Reporting?": "Allow Anonymous Usage Reporting?",
@@ -11,6 +13,7 @@
    "Automatic upgrades": "Automatic upgrades",
    "Bugs": "Bugs",
    "CPU Utilization": "CPU Utilization",
+   "Changelog": "Changelog",
    "Close": "Close",
    "Comment, when used at the start of a line": "Comment, when used at the start of a line",
    "Compression is recommended in most setups.": "Compression is recommended in most setups.",
@@ -22,6 +25,8 @@
    "Device ID": "Device ID",
    "Device Identification": "Device Identification",
    "Device Name": "Device Name",
+   "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+   "Devices": "Devices",
    "Disconnected": "Disconnected",
    "Documentation": "Documentation",
    "Download Rate": "Download Rate",
@@ -51,20 +56,25 @@
    "Global Discovery Server": "Global Discovery Server",
    "Global State": "Global State",
    "Idle": "Idle",
+   "Ignore": "Ignore",
    "Ignore Patterns": "Ignore Patterns",
    "Ignore Permissions": "Ignore Permissions",
    "Incoming Rate Limit (KiB/s)": "Incoming Rate Limit (KiB/s)",
    "Introducer": "Introducer",
    "Inversion of the given condition (i.e. do not exclude)": "Inversion of the given condition (i.e. do not exclude)",
    "Keep Versions": "Keep Versions",
+   "Last File Received": "Last File Received",
    "Last File Synced": "Last File Synced",
    "Last seen": "Last seen",
+   "Later": "Later",
    "Latest Release": "Latest Release",
    "Local Discovery": "Local Discovery",
    "Local State": "Local State",
    "Maximum Age": "Maximum Age",
    "Multi level wildcard (matches multiple directory levels)": "Multi level wildcard (matches multiple directory levels)",
    "Never": "Never",
+   "New Device": "New Device",
+   "New Folder": "New Folder",
    "No": "No",
    "No File Versioning": "No File Versioning",
    "Notice": "Notice",
@@ -72,6 +82,7 @@
    "Offline": "Offline",
    "Online": "Online",
    "Out Of Sync": "Out Of Sync",
+   "Out of Sync Items": "Out of Sync Items",
    "Outgoing Rate Limit (KiB/s)": "Outgoing Rate Limit (KiB/s)",
    "Override Changes": "Override Changes",
    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for",
@@ -92,20 +103,25 @@
    "Select the devices to share this folder with.": "Select the devices to share this folder with.",
    "Select the folders to share with this device.": "Select the folders to share with this device.",
    "Settings": "Settings",
+   "Share": "Share",
+   "Share Folder": "Share Folder",
    "Share Folders With Device": "Share Folders With Device",
    "Share With Devices": "Share With Devices",
+   "Share this folder?": "Share this folder?",
    "Shared With": "Shared With",
    "Short identifier for the folder. Must be the same on all cluster devices.": "Short identifier for the folder. Must be the same on all cluster devices.",
    "Show ID": "Show ID",
    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.",
    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.",
    "Shutdown": "Shutdown",
+   "Shutdown Complete": "Shutdown Complete",
    "Simple File Versioning": "Simple File Versioning",
    "Single level wildcard (matches within a directory only)": "Single level wildcard (matches within a directory only)",
    "Source Code": "Source Code",
    "Staggered File Versioning": "Staggered File Versioning",
    "Start Browser": "Start Browser",
    "Stopped": "Stopped",
+   "Support": "Support",
    "Support / Forum": "Support / Forum",
    "Sync Protocol Listen Addresses": "Sync Protocol Listen Addresses",
    "Synchronization": "Synchronization",
@@ -115,6 +131,7 @@
    "Syncthing is restarting.": "Syncthing is restarting.",
    "Syncthing is upgrading.": "Syncthing is upgrading.",
    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…",
+   "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
    "The aggregated statistics are publicly available at {%url%}.": "The aggregated statistics are publicly available at {{url}}.",
    "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.",
    "The device ID cannot be blank.": "The device ID cannot be blank.",
@@ -149,5 +166,6 @@
    "Yes": "Yes",
    "You must keep at least one version.": "You must keep at least one version.",
    "full documentation": "full documentation",
-   "items": "items"
+   "items": "items",
+   "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-es.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Clave API",
     "About": "Acerca de",
+    "Add": "Agregar",
     "Add Device": "Agregar dispositivo",
     "Add Folder": "Agregar repositorio",
+    "Add new folder?": "¿Agregar nuevo repositorio?",
     "Address": "Dirección",
     "Addresses": "Direcciones",
     "Allow Anonymous Usage Reporting?": "Permitir reporte anónimo de uso?",
@@ -11,17 +13,20 @@
     "Automatic upgrades": "Actualizaciones automáticas",
     "Bugs": "Errores",
     "CPU Utilization": "Uso de la CPU",
+    "Changelog": "Changelog",
     "Close": "Cerrar",
     "Comment, when used at the start of a line": "Comentario, cuando es utilizado al inicio de una línea.",
     "Compression is recommended in most setups.": "La compresión de datos es recomendada para la mayoría de las configuraciones.",
     "Connection Error": "Error de conexión",
-    "Copied from elsewhere": "Copied from elsewhere",
-    "Copied from original": "Copied from original",
+    "Copied from elsewhere": "Copiado de otra parte.",
+    "Copied from original": "Copiado del original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Derechos de autor © 2014 Jakob Borg y los siguientes  colaboradores:",
     "Delete": "Suprimir",
     "Device ID": "ID del dispositivo",
     "Device Identification": "Identificación del dispositivo",
     "Device Name": "Nombre del dispositivo",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "El dispositivo {{device}} ({{address}}) se quiere conectar. ¿Agregar nuevo dispositivo?",
+    "Devices": "Devices",
     "Disconnected": "Desconectado",
     "Documentation": "Documentación",
     "Download Rate": "Tasa de descarga",
@@ -49,22 +54,27 @@
     "Generate": "Generar",
     "Global Discovery": "Búsqueda en internet",
     "Global Discovery Server": "Servidor global de identificación",
-    "Global State": "Estado Global",
+    "Global State": "Estado global",
     "Idle": "Inactivo",
+    "Ignore": "Ignorar",
     "Ignore Patterns": "Patrones de exclusión",
     "Ignore Permissions": "Ignorar permisos",
     "Incoming Rate Limit (KiB/s)": "Límite de velocidad de entrada (KiB/s)",
     "Introducer": "Introductor",
     "Inversion of the given condition (i.e. do not exclude)": "Inversión de la condición dada (es decir, no excluir)",
     "Keep Versions": "Conservar versiones",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Último archivo sincronizado.",
     "Last seen": "Visto por ultima vez",
+    "Later": "Más tarde",
     "Latest Release": "Última versión",
     "Local Discovery": "Búsqueda en red local",
-    "Local State": "Estado Local",
+    "Local State": "Estado local",
     "Maximum Age": "Edad máxima",
-    "Multi level wildcard (matches multiple directory levels)": "Multi level wildcard (matches multiple directory levels)",
+    "Multi level wildcard (matches multiple directory levels)": "Carácter comodín multinivel (coincide en el directorio y  sus subdirectorios)",
     "Never": "Nunca",
+    "New Device": "Nuevo dispositivo",
+    "New Folder": "Nuevo repositorio",
     "No": "No",
     "No File Versioning": "Sin control de versiones de archivos",
     "Notice": "Aviso",
@@ -82,30 +92,34 @@
     "Quick guide to supported patterns": "Guía rápida sobre los patrones soportados",
     "RAM Utilization": "Utilización de RAM",
     "Rescan": "Reescanear",
-    "Rescan Interval": "Intervalo de Reescaneo",
+    "Rescan Interval": "Intervalo de reescaneo",
     "Restart": "Reiniciar",
     "Restart Needed": "Es necesario reiniciar",
     "Restarting": "Reiniciando",
-    "Reused": "Reused",
+    "Reused": "Reutilizado",
     "Save": "Guardar",
     "Scanning": "Actualización",
     "Select the devices to share this folder with.": "Seleccione los dispositivos con los cuales compartir este repositorio.",
     "Select the folders to share with this device.": "Seleccione los repositorios para compartir con este dispositivo.",
     "Settings": "Configuración",
+    "Share": "Compartir",
+    "Share Folder": "Compartir repositorio",
     "Share Folders With Device": "Compartir repositorios con dispositivo",
     "Share With Devices": "Compartir con los dispositivos",
+    "Share this folder?": "¿Compartir este repositorio?",
     "Shared With": "Compartido con",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Identificador corto para el repositorio. Debe ser el mismo en todos los dispositivos del grupo.",
     "Show ID": "Mostrar ID",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Mostrado en vez del ID del dispositivo en el estado del grupo. Si dejado en blanco, será usado el nombre sugerido por el dispositivo.",
+    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Mostrado en lugar de la ID del dispositivo en el estado del grupo. Será sugerido a otros dispositivos como nombre predeterminado opcional.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Mostrado en lugar de la ID del dispositivo en el estado del grupo. Si se deja en blanco, será usado el nombre sugerido por el dispositivo.",
     "Shutdown": "Apagar",
     "Simple File Versioning": "Versiones simple de archivos",
-    "Single level wildcard (matches within a directory only)": "Single level wildcard (matches within a directory only)",
+    "Single level wildcard (matches within a directory only)": "Carácter comodín de un solo nivel (coincide sólo dentro de un directorio)",
     "Source Code": "Código fuente",
     "Staggered File Versioning": "Versiones del archivo escalonado",
     "Start Browser": "Iniciar navegador",
     "Stopped": "Parado",
+    "Support": "Support",
     "Support / Forum": "Soporte / Foro",
     "Sync Protocol Listen Addresses": "Dirección de escucha del protocolo de sincronización",
     "Synchronization": "Sincronización",
@@ -115,9 +129,10 @@
     "Syncthing is restarting.": "Syncthing está reiniciando.",
     "Syncthing is upgrading.": "Syncthing se está actualizando.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing parece estar apagado, o hay un problema con su conexión de Internet. Reintentando...",
-    "The aggregated statistics are publicly available at {%url%}.": "Las estadísticas acumuladas están públicamente disponibles en {{url}}.",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing parece estar experimentando un problema al procesar su solicitud. Por favor, recargue el navegador o reinicie Syncthing si el problema persiste.",
+    "The aggregated statistics are publicly available at {%url%}.": "Las estadísticas acumuladas están disponibles públicamente en {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "La configuración ha sido guardada pero no activada.\nSyncthing debe reiniciarse para activar la nueva configuración.",
-    "The device ID cannot be blank.": "El ID del dispositivo no puede estar en blanco.",
+    "The device ID cannot be blank.": "La ID del dispositivo no puede estar en blanco.",
     "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "La ID del dispositivo a introducir se puede encontrar en la opción de menú \"Edición > Mostrar ID\" en el otro dispositivo. Espacios y guiones son opcionales (ignorados).",
     "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "El informe de uso se envía encriptado diariamente. Se utiliza para hacer un seguimiento de plataformas comunes, tamaño de repositorios y versiones de la aplicación. Si el conjunto de datos cambia será notificado mediante este dialogo nuevamente.",
     "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "La ID del dispositivo introducida no es válida. Debe ser una cadena de 52 o 56 caracteres consistente en letras y números, con espacios y guiones opcionales.",
@@ -134,7 +149,7 @@
     "The rescan interval must be at least 5 seconds.": "El intervalo de reescaneo debe ser al menos de 5 segundos.",
     "Unknown": "Desconocido",
     "Unshared": "No compartido",
-    "Unused": "Unused",
+    "Unused": "No utilizado",
     "Up to Date": "Actualizado",
     "Upgrade To {%version%}": "Actualizar a {{version}}",
     "Upgrading": "Actualizando",
@@ -149,5 +164,6 @@
     "Yes": "Sí",
     "You must keep at least one version.": "Debe mantener al menos una versión",
     "full documentation": "documentación completa",
-    "items": "Artículos"
+    "items": "Ítems",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} quiere compartir repositorio \"{{folder}}\"."
 }

gui/assets/lang/lang-fr.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Clé API",
     "About": "À propos",
+    "Add": "Ajouter",
     "Add Device": "Ajouter un périphérique",
     "Add Folder": "Ajouter un répertoire",
+    "Add new folder?": "Ajouter un nouveau répertoire ?",
     "Address": "Adresse",
     "Addresses": "Adresses",
     "Allow Anonymous Usage Reporting?": "Autoriser le rapport anonyme de statistiques d'utilisation ?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Mises à jour automatiques",
     "Bugs": "Bugs",
     "CPU Utilization": "Utilisation du CPU",
+    "Changelog": "Nouveautés",
     "Close": "Fermer",
     "Comment, when used at the start of a line": "Commentaire, lorsque utilisé en début de ligne",
     "Compression is recommended in most setups.": "La compression est recommandée pour la plupart des configurations.",
@@ -22,6 +25,8 @@
     "Device ID": "ID du périphérique",
     "Device Identification": "Identification de l'appareil",
     "Device Name": "Nom du périphérique",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "La machine {{device}} ({{address}}) veut se connecter. Voulez-vous ajouter cette machine ?",
+    "Devices": "Machine",
     "Disconnected": "Déconnecté",
     "Documentation": "Documentation",
     "Download Rate": "Débit de réception",
@@ -42,7 +47,7 @@
     "Folder ID": "ID du répertoire",
     "Folder Master": "Répertoire maître",
     "Folder Path": "Chemin du répertoire",
-    "Folders": "Dossiers",
+    "Folders": "Répertoires",
     "GUI Authentication Password": "Mot de passe d'authentification GUI",
     "GUI Authentication User": "Utilistateur autorisé GUI",
     "GUI Listen Addresses": "Adresse du GUI",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Serveur global de recherche",
     "Global State": "État global",
     "Idle": "Au repos",
+    "Ignore": "Ignorer",
     "Ignore Patterns": "Modèles à éviter",
     "Ignore Permissions": "Ignorer les permissions",
     "Incoming Rate Limit (KiB/s)": "Limite du débit entrant (KiB/s)",
     "Introducer": "Initiateur",
     "Inversion of the given condition (i.e. do not exclude)": "Inverser la condition donnée (i.e. ne pas exclure)",
     "Keep Versions": "Conserver les versions",
+    "Last File Received": "Dernier fichier reçu",
     "Last File Synced": "Dernier fichier synchronisé",
     "Last seen": "Dernière apparition",
+    "Later": "Plus tard",
     "Latest Release": "Dernière version",
     "Local Discovery": "Recherche locale",
     "Local State": "État local",
     "Maximum Age": "Ancienneté maximum",
     "Multi level wildcard (matches multiple directory levels)": "Astérisque à plusieurs niveaux (correspond aux répertoires et sous-répertoires)",
     "Never": "Jamais",
+    "New Device": "Nouvelle machine",
+    "New Folder": "Nouveau répertoire",
     "No": "Non",
     "No File Versioning": "Pas de version de fichier",
     "Notice": "Notification",
@@ -90,10 +100,13 @@
     "Save": "Sauver",
     "Scanning": "En cours de scan",
     "Select the devices to share this folder with.": "Sélectionner les machines avec qui partager ce répertoire.",
-    "Select the folders to share with this device.": "Sélectionner les dossiers à partager avec cette machine.",
+    "Select the folders to share with this device.": "Sélectionner les répertoires à partager avec cette machine.",
     "Settings": "Configuration",
-    "Share Folders With Device": "Partage du dossier avec les machines",
+    "Share": "Partager",
+    "Share Folder": "Partager le répertoire",
+    "Share Folders With Device": "Partager des répertoires avec des machines",
     "Share With Devices": "Partager avec les machines",
+    "Share this folder?": "Voulez-vous partager ce répertoire ?",
     "Shared With": "Partagé avec",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Court identifiant du répertoire. Il doit être le même sur l'ensemble des machines du groupe.",
     "Show ID": "Montrer l'ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Versions échelonnées de fichier",
     "Start Browser": "Démarrer le navigateur web",
     "Stopped": "Arrêté",
+    "Support": "Aide",
     "Support / Forum": "Aide / Forum",
     "Sync Protocol Listen Addresses": "Adresse du protocole de synchronisation",
     "Synchronization": "Synchronisation",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing est cours de redémarrage.",
     "Syncthing is upgrading.": "Syncthing est cours de mise à jour.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing semble être éteint, ou il y a un problème avec votre connexion Internet. Nouvelle tentative ...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing semble éprouver des difficultés à appliquer votre requête. Si le problème persiste, veuillez rafraîchir votre navigateur ou redémarrer Syncthing.",
     "The aggregated statistics are publicly available at {%url%}.": "Les statistiques agrégées sont disponibles publiquement à l'adresse {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "La configuration a été sauvée mais pas activée. Syncthing doit redémarrer afin d'activer la nouvelle configuration.",
     "The device ID cannot be blank.": "L'ID de l'appareil ne peut être vide.",
@@ -149,5 +164,6 @@
     "Yes": "Oui",
     "You must keep at least one version.": "Vous devez garder au minimum une version.",
     "full documentation": "documentation complète",
-    "items": "éléments"
+    "items": "éléments",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} veut partager le répertoire \"{{folder}}\"."
 }

gui/assets/lang/lang-hu.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API kulcs",
     "About": "Névjegy",
+    "Add": "Add",
     "Add Device": "Eszköz hozzáadása",
     "Add Folder": "Mappa hozzáadása",
+    "Add new folder?": "Add new folder?",
     "Address": "Cím",
     "Addresses": "Címek",
     "Allow Anonymous Usage Reporting?": "Engedélyezed a névtelen felhasználási adatok küldését?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatikus frissítés",
     "Bugs": "Hibák",
     "CPU Utilization": "Processzor használat",
+    "Changelog": "Changelog",
     "Close": "Bezárás",
     "Comment, when used at the start of a line": "Megjegyzés, a sor elején használva",
     "Compression is recommended in most setups.": "A tömörítés a a legtöbb esetben ajánlott",
@@ -22,6 +25,8 @@
     "Device ID": "Eszköz azonosító",
     "Device Identification": "Eszköz azonosító",
     "Device Name": "Eszköz neve",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Kapcsolat bontva",
     "Documentation": "Dokumentáció",
     "Download Rate": "Letöltési sebesség",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Globális felfedező szerver",
     "Global State": "Globális állapot",
     "Idle": "Tétlen",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Figyelmen kívül hagyás",
     "Ignore Permissions": "Jogosultságok figyelmen kívül hagyása",
     "Incoming Rate Limit (KiB/s)": "Bejövő sebesség korlát (KIB/mp)",
     "Introducer": "Bevezető",
     "Inversion of the given condition (i.e. do not exclude)": "A feltétel ellentéte (pl. ki nem hagyás)",
     "Keep Versions": "Megtartott verziók",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Utolsó szinkronizált fájl",
     "Last seen": "Utoljára látva",
+    "Later": "Later",
     "Latest Release": "Utolsó kiadás",
     "Local Discovery": "Helyi felfedezés",
     "Local State": "Helyi állapot",
     "Maximum Age": "Maximális kor",
     "Multi level wildcard (matches multiple directory levels)": "Több szintű helyettesítő karakter (több könyvtár szintre érvényesül)",
     "Never": "Soha",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Nem",
     "No File Versioning": "Nincs fájl verziózás",
     "Notice": "Megjegyzés",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Válaszd ki az eszközöket amelyekkel meg szeretnéd osztani a mappát",
     "Select the folders to share with this device.": "Válaszd ki a mappákat amiket meg szeretnél osztani ezzel az eszközzel",
     "Settings": "Beállítások",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Mappák megosztása az eszközzel",
     "Share With Devices": "Megosztás más eszközzel",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Megosztva ezekkel:",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Rövid azonosító. Minden megosztott eszközön azonosnak kell lennie.",
     "Show ID": "Azonosító mutatása",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Többszintű fájl verziókövetés",
     "Start Browser": "Böngésző indítása",
     "Stopped": "Leállítva",
+    "Support": "Support",
     "Support / Forum": "Támogatás / Fórum",
     "Sync Protocol Listen Addresses": "Szinkronizációs protokoll címe",
     "Synchronization": "Szinkronizálás",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing újraindul",
     "Syncthing is upgrading.": "Syncthing frissül",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Úgy tűnik, hogy a Syncthing nem működik, vagy valami probléma van az hálózati kapcsolattal. Újra próbálom...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Az összevont statisztikák nyilvánosan elérhetők a {{url}} címen.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "A beállítások elmentésre kerültek, de nem lettek aktiválva. Indítsd újra a Syncthing-et, hogy aktiváld őket.",
     "The device ID cannot be blank.": "Az eszköz azonosító nem lehet üres.",
@@ -149,5 +164,6 @@
     "Yes": "Igen",
     "You must keep at least one version.": "Legalább egy verziót meg kell tartanod",
     "full documentation": "teljes dokumentáció",
-    "items": "tételek"
+    "items": "tételek",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-it.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Chiave API",
     "About": "Informazioni",
+    "Add": "Aggiungi",
     "Add Device": "Aggiungi Dispositivo",
     "Add Folder": "Aggiungi Cartella",
+    "Add new folder?": "Aggiungere una nuova cartella?",
     "Address": "Indirizzo",
     "Addresses": "Indirizzi",
     "Allow Anonymous Usage Reporting?": "Abilitare Statistiche Anonime di Utilizzo?",
@@ -11,22 +13,25 @@
     "Automatic upgrades": "Aggiornamenti automatici",
     "Bugs": "Bug",
     "CPU Utilization": "Utilizzo CPU",
+    "Changelog": "Changelog",
     "Close": "Chiudi",
     "Comment, when used at the start of a line": "Per commentare, va inserito all'inizio di una riga",
     "Compression is recommended in most setups.": "La compressione è raccomandata nella maggior parte delle configurazioni.",
     "Connection Error": "Errore di Connessione",
-    "Copied from elsewhere": "Copied from elsewhere",
-    "Copied from original": "Copied from original",
+    "Copied from elsewhere": "Copiato da qualche altra parte",
+    "Copied from original": "Copiato dall'originale",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg e i seguenti Collaboratori:",
     "Delete": "Elimina",
     "Device ID": "ID Dispositivo",
     "Device Identification": "Identificazione Dispositivo",
     "Device Name": "Nome Dispositivo",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Il dispositivo {{device}} ({{address}}) chiede di connettersi. Aggiungere il nuovo dispositivo?",
+    "Devices": "Devices",
     "Disconnected": "Disconnesso",
     "Documentation": "Documentazione",
     "Download Rate": "Velocità Download",
-    "Downloaded": "Downloaded",
-    "Downloading": "Downloading",
+    "Downloaded": "Scaricato",
+    "Downloading": "Sto scaricando",
     "Edit": "Modifica",
     "Edit Device": "Modifica Dispositivo",
     "Edit Folder": "Modifica Cartella",
@@ -42,7 +47,7 @@
     "Folder ID": "ID Cartella",
     "Folder Master": "Cartella Principale",
     "Folder Path": "Percorso Cartella",
-    "Folders": "Folders",
+    "Folders": "Cartelle",
     "GUI Authentication Password": "Password di Autenticazione dell'Utente",
     "GUI Authentication User": "Utente dell'Interfaccia Grafica",
     "GUI Listen Addresses": "Indirizzi dell'Interfaccia Grafica",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Server di Ricerca Globale",
     "Global State": "Stato Globale",
     "Idle": "Inattivo",
+    "Ignore": "Ignora",
     "Ignore Patterns": "Schemi Esclusione File",
     "Ignore Permissions": "Ignora Permessi",
     "Incoming Rate Limit (KiB/s)": "Limite Velocità in Ingresso (KiB/s)",
     "Introducer": "Introduttore",
     "Inversion of the given condition (i.e. do not exclude)": "Inversione della condizione indicata (ad es. non escludere)",
     "Keep Versions": "Versioni Mantenute",
-    "Last File Synced": "Last File Synced",
+    "Last File Received": "Last File Received",
+    "Last File Synced": "Ultimo File Sincronizzato",
     "Last seen": "Ultima connessione",
+    "Later": "Più Tardi",
     "Latest Release": "Ultima Versione",
     "Local Discovery": "Individuazione Locale",
     "Local State": "Stato Locale",
     "Maximum Age": "Durata Massima",
     "Multi level wildcard (matches multiple directory levels)": "Metacarattere multi-livello (corrisponde alle cartelle e alle sotto-cartelle)",
     "Never": "Mai",
+    "New Device": "Nuovo Dispositivo",
+    "New Folder": "Nuova Cartella",
     "No": "No",
     "No File Versioning": "Nessun Controllo Versione",
     "Notice": "Avviso",
@@ -86,14 +96,17 @@
     "Restart": "Riavvia",
     "Restart Needed": "Riavvio Necessario",
     "Restarting": "Riavvio",
-    "Reused": "Reused",
+    "Reused": "Riutilizzato",
     "Save": "Salva",
     "Scanning": "Scansione in corso",
     "Select the devices to share this folder with.": "Seleziona i dispositivi con i quali condividere questa cartella.",
-    "Select the folders to share with this device.": "Select the folders to share with this device.",
+    "Select the folders to share with this device.": "Seleziona le cartelle da condividere con questo dispositivo.",
     "Settings": "Impostazioni",
-    "Share Folders With Device": "Share Folders With Device",
+    "Share": "Condividi",
+    "Share Folder": "Condividi la Cartella",
+    "Share Folders With Device": "Condividi Cartelle con il Dispositivo",
     "Share With Devices": "Condividi con i Dispositivi",
+    "Share this folder?": "Vuoi condividere questa cartella?",
     "Shared With": "Condiviso Con",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Breve identificatore della cartella. Deve essere lo stesso su tutti i dispositivi del cluster.",
     "Show ID": "Mostra ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Controllo Versione Cadenzato",
     "Start Browser": "Avvia Browser",
     "Stopped": "Fermato",
+    "Support": "Support",
     "Support / Forum": "Supporto / Forum",
     "Sync Protocol Listen Addresses": "Indirizzi del Protocollo di Sincronizzazione",
     "Synchronization": "Sincronizzazione",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Riavvio di Syncthing in corso.",
     "Syncthing is upgrading.": "Aggiornamento di Syncthing in corso.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing sembra inattivo, oppure c'è un problema con la tua connessione a Internet. Nuovo tentativo…",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Le statistiche aggregate sono disponibili pubblicamente su {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "La configurazione è stata salvata ma non attivata. Devi riavviare Syncthing per attivare la nuova configurazione.",
     "The device ID cannot be blank.": "L'ID del dispositivo non può essere vuoto.",
@@ -130,11 +145,11 @@
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "La durata massima di una versione (in giorni, imposta a 0 per mantenere le versioni per sempre).",
     "The number of old versions to keep, per file.": "Il numero di vecchie versioni da mantenere, per file.",
     "The number of versions must be a number and cannot be blank.": "Il numero di versioni dev'essere un numero e non può essere vuoto.",
-    "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
+    "The rescan interval must be a non-negative number of seconds.": "L'intervallo di scansione deve essere un numero superiore a zero secondi.",
     "The rescan interval must be at least 5 seconds.": "L'intervallo di scansione non può essere inferiore a 5 secondi.",
     "Unknown": "Sconosciuto",
-    "Unshared": "Unshared",
-    "Unused": "Unused",
+    "Unshared": "Non Condiviso",
+    "Unused": "Non Utilizzato",
     "Up to Date": "Sincronizzato",
     "Upgrade To {%version%}": "Aggiorna alla {{version}}",
     "Upgrading": "Aggiornamento",
@@ -149,5 +164,6 @@
     "Yes": "Sì",
     "You must keep at least one version.": "È necessario mantenere almeno una versione.",
     "full documentation": "documentazione completa",
-    "items": "elementi"
+    "items": "elementi",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} vuole condividere la cartella \"{{folder}}\"."
 }

gui/assets/lang/lang-lt.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API raktas",
     "About": "Apie programą",
+    "Add": "Pridėti",
     "Add Device": "Pridėti įrenginį",
     "Add Folder": "Pridėti aplanką",
+    "Add new folder?": "Pridėti naują aplanką?",
     "Address": "Adresas",
     "Addresses": "Adresai",
     "Allow Anonymous Usage Reporting?": "Siųsti anonimišką vartojimo ataskaitą?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatiniai atnaujinimai",
     "Bugs": "Klaidos",
     "CPU Utilization": "Procesoriaus panaudojimas",
+    "Changelog": "Pasikeitimai",
     "Close": "Uždaryti",
     "Comment, when used at the start of a line": "Komentaras naudojamas naujoje eilutėje",
     "Compression is recommended in most setups.": "Daugumoje atvejų spaudimas rekomenduojamas.",
@@ -22,6 +25,8 @@
     "Device ID": "Įrenginio ID",
     "Device Identification": "Įrenginio identifikacija",
     "Device Name": "Įrenginio pavadinimas",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Įrenginys {{device}} ({{address}}) nori prisijungti. Pridėti naują įrenginį?",
+    "Devices": "Įrenginiai",
     "Disconnected": "Atsijungęs",
     "Documentation": "Aprašymas",
     "Download Rate": "Parsisiuntimo greitis",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Visuotinio matomumo serveris",
     "Global State": "Visuotinė būsena",
     "Idle": "Laisvas",
+    "Ignore": "Ignoruoti",
     "Ignore Patterns": "Nepaisyti šablonų",
     "Ignore Permissions": "Nepaisyti failų prieigos leidimų",
     "Incoming Rate Limit (KiB/s)": "Įeinančio srauto maksimalus greitis (KiB/s)",
     "Introducer": "Supažindintojas",
     "Inversion of the given condition (i.e. do not exclude)": "Apversti sąlygas (pvz.: nenustoti naudoti)",
     "Keep Versions": "Saugojamų versijų kiekis",
-    "Last File Synced": "Paskutinis failas sinchronizuotas",
+    "Last File Received": "Paskutinis priimtas failas",
+    "Last File Synced": "Paskutinis gautas failas",
     "Last seen": "Paskutinį kartą matytas",
+    "Later": "Vėliau",
     "Latest Release": "Paskutinė versija",
     "Local Discovery": "Vietinis matomumas",
     "Local State": "Vietinė būsena",
     "Maximum Age": "Maksimalus amžius",
     "Multi level wildcard (matches multiple directory levels)": "Keletos lygių pakaitos (atitinka keletą direktorijų lygių)",
     "Never": "Niekada",
+    "New Device": "Naujas įrenginys",
+    "New Folder": "Naujas aplankas",
     "No": "Ne",
     "No File Versioning": "Nėra versijų valdymo",
     "Notice": "Įspėjimas",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Pasirinkite įrenginius, su kuriais dalinsitės šį aplanką.",
     "Select the folders to share with this device.": "Pasirinkite aplankus kuriais norite dalintis su šiuo įrenginiu.",
     "Settings": "Nustatymai",
+    "Share": "Dalintis",
+    "Share Folder": "Dalintis aplanku",
     "Share Folders With Device": "Dalintis aplankalais su šiuo įrenginiu",
     "Share With Devices": "Dalintis su įrenginiais",
+    "Share this folder?": "Dalintis šiuo aplanku?",
     "Shared With": "Dalinamasi su",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Trumpas aplanko identifikatorius. Privalo būti toks pat visuose įrenginiuose.",
     "Show ID": "Rodyti ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Pakopinis versijų valdymas",
     "Start Browser": "Paleisti naršyklę",
     "Stopped": "Sustabdyta",
+    "Support": "Pagalba",
     "Support / Forum": "Palaikymas / Diskusijos",
     "Sync Protocol Listen Addresses": "Sutapatinimo taisyklių adresas",
     "Synchronization": "Sutapatinimas",
@@ -115,11 +129,12 @@
     "Syncthing is restarting.": "Syncthing perleidžiamas",
     "Syncthing is upgrading.": "Syncthing atsinaujina.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing  išjungta arba problemos su Interneto ryšių. Bandoma iš naujo...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing turi problemų su jūsų užklausa. Perkraukite puslapį arba perkraukite Syncthing jei problema nedings.",
     "The aggregated statistics are publicly available at {%url%}.": "Naudojimosi ataskaitą galite peržiūrėti adresu: {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Nauji nustatymai išsaugoti, bet neaktyvuoti. Perleiskite Syncthing programą iš naujo norėdami įgalinti naujus nustatymus.",
     "The device ID cannot be blank.": "Įrenginio ID negali būti tuščias.",
-    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Įrenginio ID, kurį čia reikia įvesti, gali būti rastas „Keisti > Rodyti vardą“ dialoge kitame įrenginyje. Tarpai ir brūkšneliai nebūtini (ignoruojami).",
-    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Kas dieną siunčiama šifruota naudojimo ataskaita. Ji naudojama sekti, kokios platformos naudojamos, aplankų dydžius ir programų versijas. Jei siunčiamų duomenų tipas pasikeis, šis dialogas bus parodytas iš naujo.",
+    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Įrenginio ID, kurį čia reikia įvesti, gali būti rastas „Redaguoti > Rodyti ID“ dialoge kitame įrenginyje. Tarpai ir brūkšneliai nebūtini (ignoruojami).",
+    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Kas dieną siunčiama šifruota naudojimo ataskaita. Ji naudojama sekti, kokios platformos naudojamos, aplankų dydžius ir programų versijas. Jei siunčiamų duomenų turinys pasikeis, šis dialogas bus parodytas iš naujo.",
     "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "Įvestas neteisingas įrenginio ID. Turi būti 52 ar 56 simbolių eilutė su raidėmis ir skaičiais kuriuos galima atskirti tarpu arba brūkšneliu.",
     "The folder ID cannot be blank.": "Aplanko ID negali būti tuščias.",
     "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "Aplanko vardas negali būti ilgesnis nei 64 simboliai. Galima naudoti tik raides ir skaičius bet tašką (.), brūkšnelį (-) ir pabraukimą (_).",
@@ -149,5 +164,6 @@
     "Yes": "Taip",
     "You must keep at least one version.": "Būtina saugoti bent vieną versiją.",
     "full documentation": "pilna dokumentacija",
-    "items": "įrašai"
+    "items": "įrašai",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} nori dalintis aplanku \"{{folder}}\""
 }

gui/assets/lang/lang-nb.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API-nøkkel",
     "About": "Om",
+    "Add": "Add",
     "Add Device": "Legg Til Enhet",
     "Add Folder": "Legg Til Mappe",
+    "Add new folder?": "Add new folder?",
     "Address": "Adresse",
     "Addresses": "Adresser",
     "Allow Anonymous Usage Reporting?": "Tillat Anonym Innsamling Av Brukerdata?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatiske oppdateringer",
     "Bugs": "Programfeil",
     "CPU Utilization": "CPU-utnyttelse",
+    "Changelog": "Changelog",
     "Close": "Lukk",
     "Comment, when used at the start of a line": "Kommentar, når det blir brukt i starten av en linje.",
     "Compression is recommended in most setups.": "Komprimering er anbefalt i de fleste tilfeller.",
@@ -22,6 +25,8 @@
     "Device ID": "Enhet ID",
     "Device Identification": "Enhetskjennemerke",
     "Device Name": "Navn På Enhet",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Frakoblet",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsrate",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Global Søkemotor",
     "Global State": "Global Tilstand",
     "Idle": "Pause",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Utelatelsesmønster",
     "Ignore Permissions": "Ignorer Tilgangsbit",
     "Incoming Rate Limit (KiB/s)": "Innkommende Hastighetsbegrensning (KiB/s)",
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Invers av den gitte tilstanden (t.d. ikke ekskluder)",
     "Keep Versions": "Behold Versjoner",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Last File Synced",
     "Last seen": "Sist sett",
+    "Later": "Later",
     "Latest Release": "Nyeste Versjon",
     "Local Discovery": "Lokal Søking",
     "Local State": "Lokal Tilstand",
     "Maximum Age": "Maksimal Levetid",
     "Multi level wildcard (matches multiple directory levels)": "Multinivåsøk (søker på flere mappenivå)",
     "Never": "Aldri",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Nei",
     "No File Versioning": "Ingen Versjonskontroll",
     "Notice": "Merknad",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Velg enhetene du vil dele denne mappen med.",
     "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Innstillinger",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Del Med Enheter",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Del Med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort kjennemerke på mappen. Må være det samme på alle enheter i en gruppe.",
     "Show ID": "Vis ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Forskjøvet Versjonskontroll",
     "Start Browser": "Start Nettleser",
     "Stopped": "Stoppa",
+    "Support": "Support",
     "Support / Forum": "Brukerstøtte / Forum",
     "Sync Protocol Listen Addresses": "Lytteadresse For Synkroniseringsprotokoll",
     "Synchronization": "Synkronisering",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing starter på ny.",
     "Syncthing is upgrading.": "Syncthing oppgraderer.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing ser ut til å være nede, eller så er det et problem med nettforbindelsen din. Prøver på ny …",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Samlet statistikk er åpent tilgjengelig på {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Innstillingene har blitt lagret men ikke aktivert. Syncthing må starte på ny for å aktivere de nye innstillingene.",
     "The device ID cannot be blank.": "Enhets-ID kan ikke være tom.",
@@ -149,5 +164,6 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Du må beholde minst én versjon",
     "full documentation": "all dokumentasjon",
-    "items": "element"
+    "items": "element",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-nl.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API-sleutel",
     "About": "Over",
+    "Add": "Toevoegen",
     "Add Device": "Toestel toevoegen",
     "Add Folder": "Folder toevoegen",
+    "Add new folder?": "Nieuwe folder toevoegen?",
     "Address": "Adres",
     "Addresses": "Adressen",
     "Allow Anonymous Usage Reporting?": "Bijhouden van anonieme gebruikers statistieken toestaan?",
@@ -11,22 +13,25 @@
     "Automatic upgrades": "Automatisch bijwerken",
     "Bugs": "Fouten",
     "CPU Utilization": "CPU Gebruik",
+    "Changelog": "Changelog",
     "Close": "Sluiten",
     "Comment, when used at the start of a line": "Commentaar, indien gebruikt aan het begin van de lijn",
     "Compression is recommended in most setups.": "Gegevenscompressie is aan te raden in de meeste situaties.",
     "Connection Error": "Verbindingsfout",
-    "Copied from elsewhere": "Copied from elsewhere",
-    "Copied from original": "Copied from original",
+    "Copied from elsewhere": "Van elders gekopieerd",
+    "Copied from original": "Gekopieerd van het origineel",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg en de onderstaande bijdragers:",
     "Delete": "Verwijderen",
     "Device ID": "Toestel ID",
     "Device Identification": "Toestel identificatie",
     "Device Name": "Naam toestel",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Het toestel {{device}} ({{address}}) wenst te verbinden. Dit toestel toevoegen?",
+    "Devices": "Devices",
     "Disconnected": "Niet Verbonden",
     "Documentation": "Documentatie",
     "Download Rate": "Downloadsnelheid",
-    "Downloaded": "Downloaded",
-    "Downloading": "Downloading",
+    "Downloaded": "Gedownload",
+    "Downloading": "Bezig met downloaden",
     "Edit": "Bewerk",
     "Edit Device": "Toestel aanpassen",
     "Edit Folder": "Folder aanpassen",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Globale zoekserver",
     "Global State": "Globale status",
     "Idle": "Inactief",
+    "Ignore": "Negeren",
     "Ignore Patterns": "Te negeren patronen",
     "Ignore Permissions": "Rechten negeren",
     "Incoming Rate Limit (KiB/s)": "Download snelheidslimiet (KiB/s)",
     "Introducer": "Introductietoestel",
     "Inversion of the given condition (i.e. do not exclude)": "Inversie van de gegeven voorwaarde (bv. niet uitsluiten)",
     "Keep Versions": "Versies behouden",
-    "Last File Synced": "Last File Synced",
+    "Last File Received": "Last File Received",
+    "Last File Synced": "Laatste Gesynchroniseerde Bestand",
     "Last seen": "Laatst gezien op",
+    "Later": "Later",
     "Latest Release": "Laatste uitgave",
     "Local Discovery": "Lokaal zoeken",
     "Local State": "Lokale status",
     "Maximum Age": "Maximum leeftijd",
     "Multi level wildcard (matches multiple directory levels)": "Wildcard op meerder niveaus (toepasbaar op meerdere niveaus van folders)",
     "Never": "Nooit",
+    "New Device": "Nieuw Toestel",
+    "New Folder": "Nieuwe Folder",
     "No": "Nee",
     "No File Versioning": "Geen versiebeheer",
     "Notice": "Notificatie",
@@ -86,14 +96,17 @@
     "Restart": "Herstart",
     "Restart Needed": "Herstart nodig",
     "Restarting": "Herstarten",
-    "Reused": "Reused",
+    "Reused": "Hergebruikt",
     "Save": "Bewaar",
     "Scanning": "Aan het zoeken",
     "Select the devices to share this folder with.": "Selecteer de toestellen om deze folder mee te delen.",
-    "Select the folders to share with this device.": "Select the folders to share with this device.",
+    "Select the folders to share with this device.": "Selecteer de folders om met dit toestel te delen.",
     "Settings": "Instellingen",
-    "Share Folders With Device": "Share Folders With Device",
+    "Share": "Delen",
+    "Share Folder": "Folder Delen",
+    "Share Folders With Device": "Folders delen met toestellen",
     "Share With Devices": "Delen met toestellen",
+    "Share this folder?": "Deze folder delen?",
     "Shared With": "Gedeeld met",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Korte aanduiding voor deze folder. Moet dezelfde zijn op alle toestellen in de cluster.",
     "Show ID": "Toon ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Gelaagd versiebeheer",
     "Start Browser": "Start browser",
     "Stopped": "Gestopt",
+    "Support": "Support",
     "Support / Forum": "Support / Forum",
     "Sync Protocol Listen Addresses": "Synchronisatie protocol luister adres",
     "Synchronization": "Synchronisatie",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing is aan het herstarten.",
     "Syncthing is upgrading.": "Syncthing is aan het upgraden.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing lijkt afgesloten te zijn, of er is een verbindingsprobleem met het internet. Nieuwe poging....",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing heeft problemen bij het verwerken van je vraag. Gelieve de pagina opnieuw te laden of Syncthing te herstarten wanneer het probleem blijft opduiken.",
     "The aggregated statistics are publicly available at {%url%}.": "The verzamelde statistieken zijn publiek beschikbaar op {{url}}",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "De configuratie is opslagen maar nog niet actief. Syncthing moet opnieuw opgestart worden om de nieuwe configuratie te activeren.",
     "The device ID cannot be blank.": "Het toestel ID mag niet leeg zijn.",
@@ -133,8 +148,8 @@
     "The rescan interval must be a non-negative number of seconds.": "De scanfrequentie moet een positief getal in seconden zijn.",
     "The rescan interval must be at least 5 seconds.": "De scanfrequentie moet minimaal 5 seconden zijn.",
     "Unknown": "Onbekend",
-    "Unshared": "Unshared",
-    "Unused": "Unused",
+    "Unshared": "Niet gedeeld",
+    "Unused": "Ongebruikt",
     "Up to Date": "Gesynchroniseerd",
     "Upgrade To {%version%}": "Upgrade naar {{version}}",
     "Upgrading": "Bezig met upgrade",
@@ -149,5 +164,6 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Minstens 1 versie moet bewaard blijven.",
     "full documentation": "volledige documentatie",
-    "items": "objecten"
+    "items": "objecten",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wil de folder \"{{folder}}\" delen."
 }

gui/assets/lang/lang-nn.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API-nøkkel",
     "About": "Om",
+    "Add": "Add",
     "Add Device": "Legg Til Eining",
     "Add Folder": "Legg Til Mappe",
+    "Add new folder?": "Add new folder?",
     "Address": "Adresse",
     "Addresses": "Adresser",
     "Allow Anonymous Usage Reporting?": "Tillat Anonym Innsamling Av Brukardata?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatiske oppdateringar",
     "Bugs": "Programfeil",
     "CPU Utilization": "CPU-utnytting",
+    "Changelog": "Changelog",
     "Close": "Lukk",
     "Comment, when used at the start of a line": "Kommentar, når det vert brukt i starten av ei linje.",
     "Compression is recommended in most setups.": "Komprimering er tilrådd i dei fleste høve.",
@@ -22,6 +25,8 @@
     "Device ID": "Eining ID",
     "Device Identification": "Einingskjennemerke",
     "Device Name": "Namn På Eining",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Fråkopla",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsrate",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Global Søkjemotor",
     "Global State": "Global Tilstand",
     "Idle": "Pause",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Utelatingsmønster",
     "Ignore Permissions": "Ignorer Tilgangsbit",
     "Incoming Rate Limit (KiB/s)": "Innkomande Hastigheitsgrense (KiB/s)",
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Invers av den gitte tilstanden (t.d. ikkje ekskluder)",
     "Keep Versions": "Behald Versjonar",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Last File Synced",
     "Last seen": "Sist sett",
+    "Later": "Later",
     "Latest Release": "Nyaste Versjon",
     "Local Discovery": "Lokal Søking",
     "Local State": "Lokal Tilstand",
     "Maximum Age": "Maksimal Levetid",
     "Multi level wildcard (matches multiple directory levels)": "Multinivåsøk (søkjer på fleire mappenivå)",
     "Never": "Aldri",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Nei",
     "No File Versioning": "Ingen Versjonskontroll",
     "Notice": "Merknad",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Vel einingane du vil dela denne mappa med.",
     "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Innstillingar",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Del Med Einingar",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Delt Med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort kjennemerke på mappa. Må vera det same på alle einingar i ei gruppe.",
     "Show ID": "Vis ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Forskyvd Versjonskontroll",
     "Start Browser": "Start Nettlesar",
     "Stopped": "Stoppa",
+    "Support": "Support",
     "Support / Forum": "Brukarstøtte / Forum",
     "Sync Protocol Listen Addresses": "Lytteadresse For Synkroniseringsprotokoll",
     "Synchronization": "Synkronisering",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing startar på ny.",
     "Syncthing is upgrading.": "Syncthing oppgraderer.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing ser ut til å vera nede, eller så er det eit problem med nettilkoplinga di. Prøvar på ny …",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Samla statistikk er opent tilgjengeleg på {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Instillingane har blitt lagra men ikkje aktivert. Syncthing må starta på ny for å aktivera dei nye instillingane.",
     "The device ID cannot be blank.": "Eining ID kan ikkje vera tom.",
@@ -149,5 +164,6 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Du må behalda minst ein versjon.",
     "full documentation": "all dokumentasjon",
-    "items": "element"
+    "items": "element",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-pl.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Klucz API",
     "About": "O Syncthing",
+    "Add": "Add",
     "Add Device": "Dodaj urządzenie",
     "Add Folder": "Dodaj folder",
+    "Add new folder?": "Add new folder?",
     "Address": "Adres",
     "Addresses": "Adresy",
     "Allow Anonymous Usage Reporting?": "Zezwalaj na anonimowe statystyki użycia",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatyczne aktualizacje",
     "Bugs": "Błędy",
     "CPU Utilization": "Użycie CPU",
+    "Changelog": "Changelog",
     "Close": "Zamknij",
     "Comment, when used at the start of a line": "Komentarz, jeżeli użyty na początku linii",
     "Compression is recommended in most setups.": "Kompresja jest zalecana w większości przypadków",
@@ -22,6 +25,8 @@
     "Device ID": "ID urządzenia",
     "Device Identification": "Identyfikator urządzenia",
     "Device Name": "Nazwa urządzenia",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Rozłączony",
     "Documentation": "Dokumentacja",
     "Download Rate": "Prędkość pobierania",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Globalny serwer rozgłoszeniowy",
     "Global State": "Status globalny",
     "Idle": "Bezczynny",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Wzorce ignorowania",
     "Ignore Permissions": "Ignoruj uprawnienia",
     "Incoming Rate Limit (KiB/s)": "Ograniczenie prędkości odbierania (KiB/s)",
     "Introducer": "Wprowadzający",
     "Inversion of the given condition (i.e. do not exclude)": "Odwrócenie podanego wzorca (np. nie wykluczaj)",
     "Keep Versions": "Zachowuj wersje",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Last File Synced",
     "Last seen": "Ostatnio widziany",
+    "Later": "Later",
     "Latest Release": "Najnowsza wersja",
     "Local Discovery": "Lokalne odnajdywanie",
     "Local State": "Status lokalny",
     "Maximum Age": "Maksymalny wiek",
     "Multi level wildcard (matches multiple directory levels)": "Wieloznaczność na poziomie katalogów i plików (uwzględnia nazwy folderów i plików)",
     "Never": "Nigdy",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Nie",
     "No File Versioning": "Bez wersjonowania pliku",
     "Notice": "Wskazówka",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Wybierz urządzenie, któremu udostępnić folder.",
     "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Ustawienia",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Udostępnij dla urządzenia",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Współdzielony z",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Krótki identyfikator folderu. Musi być taki sam na wszystkich urządzeniach.",
     "Show ID": "Pokaż ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Rozbudowane wersjonowanie pliku",
     "Start Browser": "Uruchom przeglądarkę",
     "Stopped": "Zatrzymany",
+    "Support": "Wsparcie",
     "Support / Forum": "Wsparcie / Forum",
     "Sync Protocol Listen Addresses": "Adres nasłuchu protokołu synchronizacji",
     "Synchronization": "Synchronizacja",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Restart Syncthing",
     "Syncthing is upgrading.": "Aktualizowanie Syncthing",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing wydaje się być wyłączony lub jest problem z twoim połączeniem internetowym. Próbuje ponownie...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Zebrane statystyki są publicznie dostępna pod adresem {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Konfiguracja została zapisana lecz nie jest aktywna. Syncthing musi zostać zrestartowany aby aktywować nową konfiguracje.",
     "The device ID cannot be blank.": "ID urządzenia nie może być puste.",
@@ -149,5 +164,6 @@
     "Yes": "Tak",
     "You must keep at least one version.": "Musisz posiadać przynajmniej jedną wersję",
     "full documentation": "pełna dokumentacja",
-    "items": "pozycji"
+    "items": "pozycji",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-pt-PT.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Chave da API",
     "About": "Acerca da aplicação",
+    "Add": "Adicionar",
     "Add Device": "Adicionar dispositivo",
     "Add Folder": "Adicionar pasta",
+    "Add new folder?": "Adicionar nova pasta?",
     "Address": "Endereço",
     "Addresses": "Endereços",
     "Allow Anonymous Usage Reporting?": "Permitir envio de relatórios anónimos de utilização?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Actualizações automáticas",
     "Bugs": "Erros",
     "CPU Utilization": "Utilização da CPU",
+    "Changelog": "Registo de alterações",
     "Close": "Fechar",
     "Comment, when used at the start of a line": "Comentário, quando usado no início de uma linha",
     "Compression is recommended in most setups.": "A compressão é recomendada na maior parte dos casos.",
@@ -22,6 +25,8 @@
     "Device ID": "ID do dispositivo",
     "Device Identification": "Identificação do dispositivo",
     "Device Name": "Nome do dispositivo",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "O dispositivo {{device}} ({{address}}) quer conectar-se. Adiciono este novo dispositivo?",
+    "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
     "Documentation": "Documentação",
     "Download Rate": "Velocidade de recepção",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Servidor da busca global",
     "Global State": "Estado global",
     "Idle": "Em espera",
+    "Ignore": "Ignorar",
     "Ignore Patterns": "Padrões de exclusão",
     "Ignore Permissions": "Ignorar permissões",
     "Incoming Rate Limit (KiB/s)": "Limite de velocidade de recepção (KiB/s)",
     "Introducer": "Apresentador",
     "Inversion of the given condition (i.e. do not exclude)": "Inversão de uma dada condição (ou seja, não excluir)",
     "Keep Versions": "Manter versões",
+    "Last File Received": "Último ficheiro recebido",
     "Last File Synced": "Último ficheiro sincronizado",
     "Last seen": "Última vez que foi verificado",
+    "Later": "Mais tarde",
     "Latest Release": "Última versão",
     "Local Discovery": "Busca local",
     "Local State": "Estado local",
     "Maximum Age": "Idade máxima",
     "Multi level wildcard (matches multiple directory levels)": "Caractere polivalente multi-nível (faz corresponder a vários níveis de pastas)",
     "Never": "Nunca",
+    "New Device": "Novo dispositivo",
+    "New Folder": "Nova pasta",
     "No": "Não",
     "No File Versioning": "Sem gestão de versões de ficheiros",
     "Notice": "Avisos",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Seleccione os dispositivos com os quais vai partilhar esta pasta.",
     "Select the folders to share with this device.": "Seleccione as pastas a partilhar com este dispositivo.",
     "Settings": "Configurações",
+    "Share": "Partilhar",
+    "Share Folder": "Partilhar pasta",
     "Share Folders With Device": "Partilhar pastas com dispositivo",
     "Share With Devices": "Partilhar com os dispositivos",
+    "Share this folder?": "Partilhar esta pasta?",
     "Shared With": "Partilhado com",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Identificador curto para a pasta. Tem que ser igual em todos os dispositivos do grupo.",
     "Show ID": "Mostrar ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Gestão de versões de ficheiros escalonada",
     "Start Browser": "Iniciar navegador",
     "Stopped": "Parado",
+    "Support": "Suporte",
     "Support / Forum": "Suporte / Fórum",
     "Sync Protocol Listen Addresses": "Endereços de escuta do protocolo de sincronização",
     "Synchronization": "Sincronização",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "O Syncthing está a reiniciar.",
     "Syncthing is upgrading.": "O Syncthing está a actualizar-se.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "O Syncthing parece estar em baixo, ou então existe um problema com a sua ligação à Internet. Tentando novamente...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "O Syncthing parece estar com problemas em processar o seu pedido. Tente recarregar a página ou reiniciar o Syncthing, se o problema persistir.",
     "The aggregated statistics are publicly available at {%url%}.": "As estatísticas agrupadas estão disponíveis publicamente em {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "A configuração foi gravada mas não activada. O Syncthing tem que reiniciar para activar a nova configuração.",
     "The device ID cannot be blank.": "O ID do dispositivo não pode estar vazio.",
@@ -134,8 +149,8 @@
     "The rescan interval must be at least 5 seconds.": "O intervalo entre verificações tem que ser pelo menos de 5 segundos.",
     "Unknown": "Desconhecido",
     "Unshared": "Não partilhada",
-    "Unused": "Não utilizada",
-    "Up to Date": "Actualizada",
+    "Unused": "Não utilizado",
+    "Up to Date": "Sincronizado",
     "Upgrade To {%version%}": "Actualizar para {{version}}",
     "Upgrading": "Actualizando",
     "Upload Rate": "Velocidade de envio",
@@ -149,5 +164,6 @@
     "Yes": "Sim",
     "You must keep at least one version.": "Tem que manter pelo menos uma versão.",
     "full documentation": "documentação completa",
-    "items": "itens"
+    "items": "itens",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} quer partilhar a pasta \"{{folder}}\"."
 }

gui/assets/lang/lang-ru.json

@@ -1,8 +1,10 @@
 {
     "API Key": "Ключ API",
     "About": "О программе",
+    "Add": "Add",
     "Add Device": "Добавить устройство",
     "Add Folder": "Добавить папку",
+    "Add new folder?": "Add new folder?",
     "Address": "Адрес",
     "Addresses": "Адреса",
     "Allow Anonymous Usage Reporting?": "Разрешить сбор анонимной статистики использования?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Автообновление",
     "Bugs": "Ошибки",
     "CPU Utilization": "Загрузка ЦПУ",
+    "Changelog": "Changelog",
     "Close": "Закрыть",
     "Comment, when used at the start of a line": "Комментарий, если используется в начале строки",
     "Compression is recommended in most setups.": "Сжатие рекомендуется в большинстве случаев.",
@@ -22,6 +25,8 @@
     "Device ID": "ID устройства",
     "Device Identification": "Идентификация устройства",
     "Device Name": "Имя устройства",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Нет соединения",
     "Documentation": "Документация",
     "Download Rate": "Скорость загрузки",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Сервер глобального обнаружения",
     "Global State": "Глобальное состояние",
     "Idle": "Бездействует",
+    "Ignore": "Ignore",
     "Ignore Patterns": "Шаблоны игнорирования",
     "Ignore Permissions": "Игнорировать файловые права доступа",
     "Incoming Rate Limit (KiB/s)": "Ограничение входящего потока (Кбит/сек)",
     "Introducer": "Рекомендатель",
     "Inversion of the given condition (i.e. do not exclude)": "Инвертировать текущее условие (например, исключить)",
     "Keep Versions": "Количество хранимых версий",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Последний синхронизированный файл",
     "Last seen": "Был доступен",
+    "Later": "Later",
     "Latest Release": "Последняя версия",
     "Local Discovery": "Локальное обнаружение",
     "Local State": "Локальное состояние",
     "Maximum Age": "Максимальный срок",
     "Multi level wildcard (matches multiple directory levels)": "Многоуровневая маска (поиск совпадений во всех подпапках)",
     "Never": "Никогда",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "Нет",
     "No File Versioning": "Без управления версиями файлов",
     "Notice": "Внимание",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Выберите устройства, для которых будет доступна эта папка.",
     "Select the folders to share with this device.": "Выберите папку для предоставления доступа данному устройству",
     "Settings": "Настройки",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "Предоставить доступ устройству к папкам",
     "Share With Devices": "Предоставить доступ устройствам",
+    "Share this folder?": "Share this folder?",
     "Shared With": "Доступ предоставлен",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Короткий идентификатор папки. Должен быть одинаковым на всех устройствах кластера.",
     "Show ID": "Показать ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Ступенчатое управление версиями файлов",
     "Start Browser": "Открыть браузер",
     "Stopped": "Остановлено",
+    "Support": "Support",
     "Support / Forum": "Поддержка / Форум",
     "Sync Protocol Listen Addresses": "Адрес протокола синхронизации",
     "Synchronization": "Синхронизация",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Перезапуск Syncthing",
     "Syncthing is upgrading.": "Обновление Syncthing ",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Кажется, Syncthing не запущен или есть проблемы с подключением к Интернету. Переподключаюсь...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Суммарная статистика общедоступна на {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Конфигурация была сохранена но не активирована. Для активации новой конфигурации необходимо рестартовать Syncthing.",
     "The device ID cannot be blank.": "ID устройства не может быть пустым.",
@@ -149,5 +164,6 @@
     "Yes": "Да",
     "You must keep at least one version.": "Вы должны хранить как минимум одну версию.",
     "full documentation": "полная документация",
-    "items": "элементы"
+    "items": "элементы",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-sv.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API-nyckel",
     "About": "Om",
+    "Add": "Lägg till",
     "Add Device": "Lägg till enhet",
     "Add Folder": "Lägg till katalog",
+    "Add new folder?": "Lägg till katalog?",
     "Address": "Adress",
     "Addresses": "Adresser",
     "Allow Anonymous Usage Reporting?": "Tillåt anonym användarstatistik?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "Automatisk uppgradering",
     "Bugs": "Buggar",
     "CPU Utilization": "CPU-användning",
+    "Changelog": "Changelog",
     "Close": "Stäng",
     "Comment, when used at the start of a line": "Kommentar, vid början av en rad.",
     "Compression is recommended in most setups.": "Komprimering är rekommenderat för de flesta.",
@@ -22,6 +25,8 @@
     "Device ID": "Enhets-ID",
     "Device Identification": "Enhetsidentifikation",
     "Device Name": "Enhetsnamn",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "Ej ansluten",
     "Documentation": "Dokumentation",
     "Download Rate": "Nedladdningshastighet",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "Global uppslagningsserver",
     "Global State": "Global status",
     "Idle": "Vilande",
+    "Ignore": "Ignorera",
     "Ignore Patterns": "Filmönster",
     "Ignore Permissions": "Ignorera filrättigheter",
     "Incoming Rate Limit (KiB/s)": "Max nedladdningshastighet (KiB/s)",
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Vänder på villkoret, d.v.s. exkluderar inte.",
     "Keep Versions": "Behåll versioner",
+    "Last File Received": "Last File Received",
     "Last File Synced": "Senast uppdaterad fil",
     "Last seen": "Senast online",
+    "Later": "Senare",
     "Latest Release": "Senaste version",
     "Local Discovery": "Lokal uppslagning",
     "Local State": "Lokal status",
     "Maximum Age": "Högsta åldersgräns",
     "Multi level wildcard (matches multiple directory levels)": "Jokertecken som representerar noll eller fler godtyckliga tecken, även över kataloggränser.",
     "Never": "Aldrig",
+    "New Device": "Ny enhet",
+    "New Folder": "Ny katalog",
     "No": "Nej",
     "No File Versioning": "Ingen versionshantering",
     "Notice": "OBS",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "Ange enheterna att dela den här katalogen med.",
     "Select the folders to share with this device.": "Välja kataloger att dela med den här enheten",
     "Settings": "Inställningar",
+    "Share": "Dela",
+    "Share Folder": "Dela katalog",
     "Share Folders With Device": "Dela kataloger med enhet",
     "Share With Devices": "Dela med enheter",
+    "Share this folder?": "Dela den här katalogen?",
     "Shared With": "Delat med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort identifieringssträng för katalogen. Måste vara samma på alla enheter i klustern.",
     "Show ID": "Visa ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "Versionshantering i intervall",
     "Start Browser": "Starta browser",
     "Stopped": "Stoppad",
+    "Support": "Support",
     "Support / Forum": "Support / Forum",
     "Sync Protocol Listen Addresses": "Address för inkommande anslutningar",
     "Synchronization": "Synkronisering",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing startar om.",
     "Syncthing is upgrading.": "Syncthing uppgraderas.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing verkar avstängd, eller så är där ett problem med din Internetanslutning. Försöker igen...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "Aggregerad statistik finns publikt tillgänglig på {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Konfigurationen har sparats men inte aktiverats. Syncthing måste startas om för att aktivera den nya konfigurationen.",
     "The device ID cannot be blank.": "Enhets-ID kan inte vara blankt.",
@@ -149,5 +164,6 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Du måste behålla åtminstone en version.",
     "full documentation": "fullständig dokumentation",
-    "items": "poster"
+    "items": "poster",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-zh-CN.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API Key",
     "About": "关于",
+    "Add": "Add",
     "Add Device": "添加设备",
     "Add Folder": "添加文件夹",
+    "Add new folder?": "Add new folder?",
     "Address": "地址",
     "Addresses": "地址列表",
     "Allow Anonymous Usage Reporting?": "允许匿名使用报告?",
@@ -11,6 +13,7 @@
     "Automatic upgrades": "自动升级",
     "Bugs": "Bug汇报",
     "CPU Utilization": "CPU使用率",
+    "Changelog": "Changelog",
     "Close": "关闭",
     "Comment, when used at the start of a line": "注释，在行首使用",
     "Compression is recommended in most setups.": "在大多数场合，建议开启压缩",
@@ -22,6 +25,8 @@
     "Device ID": "设备ID",
     "Device Identification": "设备ID",
     "Device Name": "设备名",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
+    "Devices": "Devices",
     "Disconnected": "连接已断开",
     "Documentation": "文档",
     "Download Rate": "下载速度",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "用以在互联网上寻找节点的Announce服务器地址",
     "Global State": "全局状态",
     "Idle": "空闲",
+    "Ignore": "Ignore",
     "Ignore Patterns": "忽略列表",
     "Ignore Permissions": "忽略文件权限",
     "Incoming Rate Limit (KiB/s)": "下载速率限制(千字节/秒)",
     "Introducer": "介绍人节点",
     "Inversion of the given condition (i.e. do not exclude)": "对本条件取反（例如：不要排除某项）",
     "Keep Versions": "保留历史版本数量",
+    "Last File Received": "Last File Received",
     "Last File Synced": "最近同步的文件",
     "Last seen": "最后可见",
+    "Later": "Later",
     "Latest Release": "最新版本",
     "Local Discovery": "在局域网上寻找节点",
     "Local State": "本地状态",
     "Maximum Age": "历史版本最长保留时间",
     "Multi level wildcard (matches multiple directory levels)": "多级通配符（用以匹配多层文件夹）",
     "Never": "从未",
+    "New Device": "New Device",
+    "New Folder": "New Folder",
     "No": "否",
     "No File Versioning": "不启用版本控制",
     "Notice": "提示",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "选择将本文件夹共享给哪些设备",
     "Select the folders to share with this device.": "选择与该设备共享的文件夹。",
     "Settings": "设置",
+    "Share": "Share",
+    "Share Folder": "Share Folder",
     "Share Folders With Device": "将指定文件夹共享给设备",
     "Share With Devices": "共享给",
+    "Share this folder?": "Share this folder?",
     "Shared With": "共享给",
     "Short identifier for the folder. Must be the same on all cluster devices.": "文件夹的别名。必须在所有设备上保持一致。",
     "Show ID": "显示设备ID",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "阶段版本控制",
     "Start Browser": "启动浏览器",
     "Stopped": "已停止",
+    "Support": "Support",
     "Support / Forum": "支持/论坛",
     "Sync Protocol Listen Addresses": "协议监听地址",
     "Synchronization": "同步完成度",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing正在重启",
     "Syncthing is upgrading.": "Syncthing正在升级",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing似乎关闭了，或者您的网络连接存在故障。重试中...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "全局统计公布于 {{url}}",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "设置已经保存，但是还未生效。Syncthing需要重启以启用新的设置。",
     "The device ID cannot be blank.": "设备ID不能为空",
@@ -149,5 +164,6 @@
     "Yes": "是",
     "You must keep at least one version.": "您必须保留至少一个版本。",
     "full documentation": "完整文档",
-    "items": "条目"
+    "items": "条目",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-zh-TW.json

@@ -1,8 +1,10 @@
 {
     "API Key": "API 金鑰",
     "About": "關於",
+    "Add": "增加",
     "Add Device": "增加裝置",
     "Add Folder": "增加資料夾",
+    "Add new folder?": "新增資料夾?",
     "Address": "位址",
     "Addresses": "位址",
     "Allow Anonymous Usage Reporting?": "允許匿名的使用資訊回報？",
@@ -11,17 +13,20 @@
     "Automatic upgrades": "自動升級",
     "Bugs": "程式錯誤",
     "CPU Utilization": "CPU 使用率",
+    "Changelog": "Changelog",
     "Close": "關閉",
     "Comment, when used at the start of a line": "註解，當輸入在一行的開頭時",
     "Compression is recommended in most setups.": "建議在大多數的設置中使用壓縮。",
     "Connection Error": "連線錯誤",
-    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from elsewhere": "從別處複製",
     "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "版權所有 © 2014 Jakob Borg 及以下貢獻者：",
     "Delete": "刪除",
     "Device ID": "裝置識別碼",
     "Device Identification": "裝置識別",
     "Device Name": "裝置名稱",
+    "Device {%device%} ({%address%}) wants to connect. Add new device?": "裝置 {{device}} ({{address}}) 想要連線。要新增裝置嗎？",
+    "Devices": "Devices",
     "Disconnected": "斷線",
     "Documentation": "說明文件",
     "Download Rate": "下載速率",
@@ -51,20 +56,25 @@
     "Global Discovery Server": "全域探索伺服器",
     "Global State": "全域狀態",
     "Idle": "閒置",
+    "Ignore": "忽略",
     "Ignore Patterns": "忽略樣式",
     "Ignore Permissions": "忽略權限",
     "Incoming Rate Limit (KiB/s)": "連入速率限制 (KiB/s)",
     "Introducer": "引入者",
     "Inversion of the given condition (i.e. do not exclude)": "反轉給定條件 (即：不要排除)",
     "Keep Versions": "保留歷史版本數",
+    "Last File Received": "Last File Received",
     "Last File Synced": "最後同步檔案",
     "Last seen": "最後發現時間",
+    "Later": "稍後",
     "Latest Release": "最新發佈",
     "Local Discovery": "本地探索",
     "Local State": "本地狀態",
     "Maximum Age": "最長保留時間",
     "Multi level wildcard (matches multiple directory levels)": "多階層萬用字元 (可比對多層資料夾)",
     "Never": "從未",
+    "New Device": "新裝置",
+    "New Folder": "新資料夾",
     "No": "否",
     "No File Versioning": "無檔案版本控制",
     "Notice": "注意",
@@ -92,8 +102,11 @@
     "Select the devices to share this folder with.": "選擇要共享這個資料夾的裝置。",
     "Select the folders to share with this device.": "選擇要共享這個資料夾的裝置。",
     "Settings": "設定",
+    "Share": "分享",
+    "Share Folder": "分享資料夾",
     "Share Folders With Device": "與裝置共享資料夾",
     "Share With Devices": "與這些裝置共享",
+    "Share this folder?": "分享此資料夾？",
     "Shared With": "與誰共享",
     "Short identifier for the folder. Must be the same on all cluster devices.": "資料夾的簡短識別字。必須在叢集內所有的裝置上皆相同。",
     "Show ID": "顯示識別碼",
@@ -106,6 +119,7 @@
     "Staggered File Versioning": "變動式檔案版本控制",
     "Start Browser": "啟動瀏覽器",
     "Stopped": "已停止",
+    "Support": "Support",
     "Support / Forum": "支援 / 論壇",
     "Sync Protocol Listen Addresses": "同步通訊協定監聽位址",
     "Synchronization": "同步作業",
@@ -115,6 +129,7 @@
     "Syncthing is restarting.": "Syncthing 正在重新啟動。",
     "Syncthing is upgrading.": "Syncthing 正在進行升級。",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing 似乎下線了，或者您的網際網路連線出現問題。正在重試...",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing seems to be experiencing a problem processing your request. Please reload your browser or restart Syncthing if the problem persists.",
     "The aggregated statistics are publicly available at {%url%}.": "匯總統計資訊公佈於 {{url}}。",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "組態已經儲存但尚未啟用。Syncthing 必須重新啟動以便啟用新的組態。",
     "The device ID cannot be blank.": "裝置識別碼不能為空白。",
@@ -149,5 +164,6 @@
     "Yes": "是",
     "You must keep at least one version.": "您必須保留至少一個版本。",
     "full documentation": "完整說明文件",
-    "items": "個項目"
+    "items": "個項目",
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} 想要分享資料夾 \"{{folder}}\"。"
 }

gui/index.html

@@ -89,19 +89,20 @@
 
       <div class="col-md-6">
         <div class="panel-group" id="folders">
+        <div class="visible-xs"><h3><span translate>Folders</span></h3><hr></div>
           <div class="panel panel-default" ng-repeat="folder in folderList()">
             <div class="panel-heading" data-toggle="collapse" data-parent="#folders" href="#folder-{{$index}}" style="cursor: pointer">
               <div class="panel-progress" ng-show="folderStatus(folder) == 'syncing'" ng-attr-style="width: {{syncPercentage(folder.ID)}}%"></div>
               <h3 class="panel-title">
-                <span class="glyphicon glyphicon-hdd"></span>&emsp;{{folder.ID}}
-                <span class="pull-right hidden-xs text-{{folderClass(folder)}}" ng-switch="folderStatus(folder)">
-                  <span translate ng-switch-when="unknown">Unknown</span>
-                  <span translate ng-switch-when="unshared">Unshared</span>
-                  <span translate ng-switch-when="stopped">Stopped</span>
-                  <span translate ng-switch-when="scanning">Scanning</span>
-                  <span translate ng-switch-when="idle">Up to Date</span>
+                <span class="glyphicon glyphicon-hdd hidden-xs"></span>{{folder.ID}}
+                <span class="pull-right text-{{folderClass(folder)}}" ng-switch="folderStatus(folder)">
+                  <span ng-switch-when="unknown"><span class="hidden-xs" translate>Unknown</span><span class="visible-xs">&#9724;</span></span>
+                  <span ng-switch-when="unshared"><span class="hidden-xs" translate>Unshared</span><span class="visible-xs">&#9724;</span></span>
+                  <span ng-switch-when="stopped"><span class="hidden-xs" translate>Stopped</span><span class="visible-xs">&#9724;</span></span>
+                  <span ng-switch-when="scanning"><span class="hidden-xs" translate>Scanning</span><span class="visible-xs">&#9724;</span></span>
+                  <span ng-switch-when="idle"><span class="hidden-xs" translate>Up to Date</span><span class="visible-xs">&#9724;</span></span>
                   <span ng-switch-when="syncing">
-                    <span translate>Syncing</span>
+                    <span class="hidden-xs" translate>Syncing</span>
                     ({{syncPercentage(folder.ID)}}%)
                   </span>
                 </span>
@@ -154,7 +155,7 @@
                       <td class="text-right">{{sharesFolder(folder)}}</td>
                     </tr>
                     <tr ng-if="folderStats[folder.ID].LastFile">
-                      <th><span class="glyphicon glyphicon-transfer"></span>&emsp;<span translate>Last File Synced</span></th>
+                      <th><span class="glyphicon glyphicon-transfer"></span>&emsp;<span translate>Last File Received</span></th>
                       <td class="text-right">
                         <span title="{{folderStats[folder.ID].LastFile.Filename}} @ {{folderStats[folder.ID].LastFile.At | date:'yyyy-MM-dd HH:mm'}}">
                           {{folderStats[folder.ID].LastFile.Filename | basename}}
@@ -187,6 +188,7 @@
       <!-- This device -->
 
       <div class="col-md-6">
+      <div class="visible-xs"><h3><span translate>Devices</span></h3><hr></div>
         <div class="panel panel-default" ng-repeat="deviceCfg in [thisDevice()]">
           <div class="panel-heading" data-toggle="collapse" href="#device-this" style="cursor: pointer">
             <h3 class="panel-title">
@@ -244,13 +246,13 @@
               <div class="panel-progress" ng-show="deviceStatus(deviceCfg) == 'syncing'" ng-attr-style="width: {{completion[deviceCfg.DeviceID]._total | number:0}}%"></div>
               <h3 class="panel-title">
                 <identicon data-value="deviceCfg.DeviceID"></identicon>&emsp;{{deviceName(deviceCfg)}}
-                <span ng-switch="deviceStatus(deviceCfg)" class="pull-right hidden-xs text-{{deviceClass(deviceCfg)}}">
-                  <span translate ng-switch-when="insync">Up to Date</span>
+                <span ng-switch="deviceStatus(deviceCfg)" class="pull-right text-{{deviceClass(deviceCfg)}}">
+                  <span ng-switch-when="insync"><span class="hidden-xs" translate>Up to Date</span><span class="visible-xs">&#9724;</span></span>
                   <span ng-switch-when="syncing">
-                    <span translate>Syncing</span> ({{completion[deviceCfg.DeviceID]._total | number:0}}%)
+                    <span class="hidden-xs" translate>Syncing</span> ({{completion[deviceCfg.DeviceID]._total | number:0}}%)
                   </span>
-                  <span translate ng-switch-when="disconnected">Disconnected</span>
-                  <span translate ng-switch-when="unused">Unused</span>
+                  <span ng-switch-when="disconnected"><span class="hidden-xs" translate>Disconnected</span><span class="visible-xs">&#9724;</span></span>
+                  <span ng-switch-when="unused"><span class="hidden-xs" translate>Unused</span><span class="visible-xs">&#9724;</span></span>
                 </span>
               </h3>
             </div>
@@ -308,6 +310,73 @@
       </div>
     </div> <!-- /row -->
 
+    <!-- Device Rejections -->
+
+    <div ng-repeat="(device, event) in deviceRejections" class="row">
+      <div class="col-md-12">
+        <div class="panel panel-warning">
+          <div class="panel-heading">
+            <h3 class="panel-title">
+              <identicon data-value="device"></identicon>&emsp;<span translate>New Device</span>
+            </h3>
+          </div>
+          <div class="panel-body">
+            <p>
+              <small>{{ event.time | date:"H:mm:ss" }}:</small>
+              <span translate translate-value-device="{{ device }}" translate-value-address="{{ event.data.address }}">
+                Device {%device%} ({%address%}) wants to connect. Add new device?
+              <span>
+            </p>
+          </div>
+          <div class="panel-footer clearfix">
+            <div class="pull-right">
+              <button class="btn btn-sm btn-success" ng-click="addNewDeviceID(device)"><span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Add</span></button>
+              <button class="btn btn-sm btn-danger" ng-click="ignoreRejectedDevice(device)"><span class="glyphicon glyphicon-remove"></span>&emsp;<span translate>Ignore</span></button>
+              <button class="btn btn-sm btn-default" ng-click="dismissDeviceRejection(device)"><span class="glyphicon glyphicon-time"></span>&emsp;<span translate>Later</span></button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Folder Rejections -->
+
+    <div ng-repeat="(key, event) in folderRejections" class="row reject">
+      <div class="col-md-12">
+        <div class="panel panel-warning">
+          <div class="panel-heading">
+            <h3 class="panel-title">
+              <span translate ng-if="!folders[event.data.folder]">New Folder</span>
+              <span translate ng-if="folders[event.data.folder]">Share Folder</span>
+            </h3>
+          </div>
+          <div class="panel-body">
+            <p>
+              <small>{{ event.time | date:"H:mm:ss" }}:</small>
+              <span translate translate-value-device="{{ deviceName(findDevice(event.data.device)) }}" translate-value-folder="{{ event.data.folder }}">
+                {%device%} wants to share folder "{%folder%}".
+              </span>
+              <span translate ng-if="folders[event.data.folder]">Share this folder?</span>
+              <span translate ng-if="!folders[event.data.folder]">Add new folder?</span>
+            </p>
+          </div>
+          <div class="panel-footer clearfix">
+            <div class="pull-right">
+              <button class="btn btn-sm btn-success" ng-click="addFolderAndShare(event.data.folder, event.data.device)" ng-if="!folders[event.data.folder]">
+                <span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Add</span>
+              </button>
+              <button class="btn btn-sm btn-success" ng-click="shareFolderWithDevice(event.data.folder, event.data.device)" ng-if="folders[event.data.folder]">
+                <span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Share</span>
+              </button>
+              <button class="btn btn-sm btn-default" ng-click="dismissFolderRejection(event.data.folder, event.data.device)">
+                <span class="glyphicon glyphicon-time"></span>&emsp;<span translate>Later</span>
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
     <!-- Errors -->
 
     <div ng-if="errorList().length > 0" class="row">
@@ -329,14 +398,14 @@
 
   <!-- Bottom bar -->
 
-  <nav class="navbar navbar-default navbar-fixed-bottom hidden-xs">
+  <nav class="navbar navbar-default navbar-fixed-bottom">
     <div class="container">
       <ul class="nav navbar-nav">
-        <li><a class="navbar-link" href="http://discourse.syncthing.net/"><span translate>Support / Forum</span></a></li>
-        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing/releases"><span translate>Latest Release</span></a></li>
-        <li><a class="navbar-link" href="http://discourse.syncthing.net/category/documentation"><span translate>Documentation</span></a></li>
-        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing/issues"><span translate>Bugs</span></a></li>
-        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing"><span translate>Source Code</span></a></li>
+        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing/wiki"><span class="glyphicon glyphicon-book"></span>&ensp;<span translate>Documentation</span></a></li>
+        <li><a class="navbar-link" href="https://discourse.syncthing.net"><span class="glyphicon glyphicon-question-sign"></span>&ensp;<span translate>Support</span></a></li>
+        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing/releases"><span class="glyphicon glyphicon-info-sign"></span>&ensp;<span translate>Changelog</span></a></li>
+        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing/issues"><span class="glyphicon glyphicon-warning-sign"></span>&ensp;<span translate>Bugs</span></a></li>
+        <li><a class="navbar-link" href="https://github.com/syncthing/syncthing"><span class="glyphicon glyphicon-wrench"></span>&ensp;<span translate>Source Code</span></a></li>
       </ul>
     </div>
   </nav>
@@ -349,6 +418,14 @@
     </p>
   </modal>
 
+  <!-- HTTP error modal -->
+
+  <modal id="httpError" status="danger" icon="exclamation-sign" title="{{'Connection Error' | translate}}">
+    <p translate>
+      Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.
+    </p>
+  </modal>
+
   <!-- Restarting modal -->
 
   <modal id="restarting" icon="refresh" title="{{'Restarting' | translate}}" status="info">
@@ -363,7 +440,7 @@
 
   <!-- Shutdown modal -->
 
-  <modal id="shutdown" icon="off" status="success" title="Shutdown Complete">
+  <modal id="shutdown" icon="off" status="success" title="{{'Shutdown Complete' | translate}}">
     <p translate>Syncthing has been shut down.</p>
   </modal>
 
@@ -606,7 +683,7 @@
 
           <hr/>
 
-          <p class="small"><span translate>Quick guide to supported patterns</span> (<a href="https://discourse.syncthing.net/t/80" translate>full documentation</a>):</p>
+          <p class="small"><span translate>Quick guide to supported patterns</span> (<a href="https://github.com/syncthing/syncthing/wiki/Ignoring-Files" target="_blank" translate>full documentation</a>):</p>
           <dl class="dl-horizontal dl-narrow small">
             <dt><code>!</code></dt> <dd><span translate>Inversion of the given condition (i.e. do not exclude)</span></dd>
             <dt><code>*</code></dt> <dd><span translate>Single level wildcard (matches within a directory only)</span></dd>
@@ -615,7 +692,7 @@
           </dl>
         </div>
         <div class="modal-footer">
-          <div class="pull-left"><span translate>Editing</span> <code>{{currentFolder.Path}}/.stignore</code></div>
+          <div class="pull-left"><span translate>Editing</span> <code>{{currentFolder.Path}}{{system.pathSeparator}}.stignore</code></div>
           <button type="button" class="btn btn-primary btn-sm" data-dismiss="modal" ng-click="saveIgnores()"><span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Save</span></button>
           <button type="button" class="btn btn-default btn-sm" data-dismiss="modal"><span class="glyphicon glyphicon-remove"></span>&emsp;<span translate>Close</span></button>
         </div>
@@ -789,7 +866,7 @@
 
   <!-- Needed files modal -->
 
-  <modal id="needed" large="yes" status="info" icon="cloud-download" close="yes" title="Out of Sync Items">
+  <modal id="needed" large="yes" status="info" icon="cloud-download" close="yes" title="{{'Out of Sync Items' | translate}}">
     <div class="progress">
       <div class="progress-bar progress-bar-success" style="width: 20%"><span translate class="show">Reused</span></div>
       <div class="progress-bar" style="width: 20%"><span translate class="show">Copied from original</span></div>
@@ -801,21 +878,37 @@
     <hr/>
 
     <table class="table table-striped table-condensed">
-      <tr ng-repeat="f in needed" ng-init="a = needAction(f)">
+      <tr ng-repeat="f in needed.progress" ng-init="a = needAction(f)">
         <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
         <td title="{{f.Name}}">{{f.Name | basename}}</td>
-        <td>
-          <span ng-if="a == 'sync' && progress[neededFolder] && progress[neededFolder][f.Name]">
-            <div class="progress">
-              <div class="progress-bar progress-bar-success" style="width: {{progress[neededFolder][f.Name].Reused}}%"></div>
-              <div class="progress-bar" style="width: {{progress[neededFolder][f.Name].CopiedFromOrigin}}%"></div>
-              <div class="progress-bar progress-bar-info" style="width: {{progress[neededFolder][f.Name].CopiedFromElsewhere}}%"></div>
-              <div class="progress-bar progress-bar-warning" style="width: {{progress[neededFolder][f.Name].Pulled}}%"></div>
-              <div class="progress-bar progress-bar-danger progress-bar-striped active" style="width: {{progress[neededFolder][f.Name].Pulling}}%"></div>
-              <span class="show frontal">{{progress[neededFolder][f.Name].BytesDone | binary}}B / {{progress[neededFolder][f.Name].BytesTotal | binary}}B</span>
-            </div>
-          </span>
+        <td ng-if="a == 'sync' && progress[neededFolder] && progress[neededFolder][f.Name]">
+          <div class="progress">
+            <div class="progress-bar progress-bar-success" style="width: {{progress[neededFolder][f.Name].Reused}}%"></div>
+            <div class="progress-bar" style="width: {{progress[neededFolder][f.Name].CopiedFromOrigin}}%"></div>
+            <div class="progress-bar progress-bar-info" style="width: {{progress[neededFolder][f.Name].CopiedFromElsewhere}}%"></div>
+            <div class="progress-bar progress-bar-warning" style="width: {{progress[neededFolder][f.Name].Pulled}}%"></div>
+            <div class="progress-bar progress-bar-danger progress-bar-striped active" style="width: {{progress[neededFolder][f.Name].Pulling}}%"></div>
+            <span class="show frontal">
+              {{progress[neededFolder][f.Name].BytesDone | binary}}B / {{progress[neededFolder][f.Name].BytesTotal | binary}}B
+            </span>
+          </div>
         </td>
+        <td class="text-right small-data" ng-if="a != 'sync' || !progress[neededFolder] || !progress[neededFolder][f.Name]">
+          <span ng-if="f.Size > 0">{{f.Size | binary}}B</span>
+        </td>
+      </tr>
+      <tr ng-repeat="f in needed.queued" ng-init="a = needAction(f)">
+        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
+        <td title="{{f.Name}}">{{f.Name | basename}}</td>
+        <td class="text-right small-data">
+          <span ng-if="$index != 0" class="glyphicon glyphicon-chevron-up" ng-click="bumpFile(neededFolder, f.Name)"></span>
+          <span ng-if="f.Size > 0">{{f.Size | binary}}B</span>
+         </td>
+      </tr>
+      <tr ng-repeat="f in needed.rest" ng-init="a = needAction(f)">
+        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
+        <td title="{{f.Name}}">{{f.Name | basename}}</td>
+        <td class="text-right small-data"><span ng-if="f.Size > 0">{{f.Size | binary}}B</span></td>
       </tr>
     </table>
 
@@ -823,7 +916,7 @@
 
   <!-- About modal -->
 
-  <modal id="about" large="yes" close="yes" status="info" title="About">
+  <modal id="about" large="yes" close="yes" status="info" title="{{'About' | translate}}">
     <h1 class="text-center"><img alt="Syncthing" title="Syncthing" src="assets/img/logo-text-256.png" style="vertical-align: -16px" height="100" width="366"/><br/><small>{{version}}</small></h1>
     <hr/>
 
@@ -839,6 +932,7 @@
           <li>Ben Schulz</li>
           <li>Ben Sidhom</li>
           <li>Brandon Philips</li>
+          <li>Brendan Long</li>
           <li>Caleb Callaway</li>
           <li>Cathryne Linenweaver</li>
           <li>Chris Joel</li>
@@ -846,6 +940,7 @@
           <li>Dennis Wilson</li>
           <li>Dominik Heidler</li>
           <li>Emil Hessman</li>
+          <li>Federico Castagnini</li>
           <li>Felix Ableitner</li>
           <li>Felix Unterpaintner</li>
           <li>Gilli Sigurdsson</li>
@@ -855,10 +950,12 @@
           <li>Lode Hoste</li>
           <li>Marcin Dziadus</li>
           <li>Michael Tilli</li>
+          <li>Peter Hoeg</li>
           <li>Philippe Schommers</li>
           <li>Phill Luby</li>
           <li>Piotr Bejda</li>
           <li>Ryan Sullivan</li>
+          <li>Tim Abell</li>
           <li>Tomas Cerveny</li>
           <li>Tully Robinson</li>
           <li>Veeti Paananen</li>

gui/scripts/syncthing/app.js

@@ -104,15 +104,12 @@ function decimals(val, num) {
     return decs;
 }
 
-function randomString(len, bits) {
-    bits = bits || 36;
-    var outStr = "",
-        newStr;
-    while (outStr.length < len) {
-        newStr = Math.random().toString(bits).slice(2);
-        outStr += newStr.slice(0, Math.min(newStr.length, (len - outStr.length)));
+function randomString(len) {
+    var i, result = '', chars = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-';
+    for (i = 0; i < len; i++) {
+        result += chars[Math.round(Math.random() * (chars.length - 1))];
     }
-    return outStr.toLowerCase();
+    return result;
 }
 
 function isEmptyObject(obj) {

gui/scripts/syncthing/core/controllers/syncthingController.js

@@ -10,7 +10,6 @@ angular.module('syncthing.core')
         var restarting = false;
 
         function initController() {
-
             LocaleService.autoConfigLocale();
 
             refreshSystem();
@@ -21,11 +20,11 @@ angular.module('syncthing.core')
 
             $http.get(urlbase + '/version').success(function (data) {
                 $scope.version = data.version;
-            });
+            }).error($scope.emitHTTPError);
 
             $http.get(urlbase + '/report').success(function (data) {
                 $scope.reportData = data;
-            });
+            }).error($scope.emitHTTPError);
 
             $http.get(urlbase + '/upgrade').success(function (data) {
                 $scope.upgradeInfo = data;
@@ -47,6 +46,8 @@ angular.module('syncthing.core')
         $scope.model = {};
         $scope.myID = '';
         $scope.devices = [];
+        $scope.deviceRejections = {};
+        $scope.folderRejections = {};
         $scope.protocolChanged = false;
         $scope.reportData = {};
         $scope.reportPreview = false;
@@ -104,6 +105,30 @@ angular.module('syncthing.core')
             }
         });
 
+        $scope.$on('HTTPError', function (event, arg) {
+            // Emitted when a HTTP call fails. We use the status code to try
+            // to figure out what's wrong.
+
+            if (navigatingAway || !online) {
+                return;
+            }
+
+            console.log('HTTPError', arg);
+            online = false;
+            if (!restarting) {
+                if (arg.status === 0) {
+                    // A network error, not an HTTP error
+                    $scope.$emit('UIOffline');
+                } else if (arg.status >= 400 && arg.status <= 599) {
+                    // A genuine HTTP error
+                    $('#networkError').modal('hide');
+                    $('#restarting').modal('hide');
+                    $('#shutdown').modal('hide');
+                    $('#httpError').modal();
+                }
+            }
+        });
+
         $scope.$on('StateChanged', function (event, arg) {
             var data = arg.data;
             if ($scope.model[data.folder]) {
@@ -168,12 +193,20 @@ angular.module('syncthing.core')
             }
         });
 
+        $scope.$on('DeviceRejected', function (event, arg) {
+            $scope.deviceRejections[arg.data.device] = arg;
+        });
+
+        $scope.$on('FolderRejected', function (event, arg) {
+            $scope.folderRejections[arg.data.folder + "-" + arg.data.device] = arg;
+        });
+
         $scope.$on('ConfigSaved', function (event, arg) {
             updateLocalConfig(arg.data);
 
             $http.get(urlbase + '/config/sync').success(function (data) {
                 $scope.configInSync = data.configInSync;
-            });
+            }).error($scope.emitHTTPError);
         });
 
         $scope.$on('DownloadProgress', function (event, arg) {
@@ -223,6 +256,10 @@ angular.module('syncthing.core')
             console.log("DownloadProgress", $scope.progress);
         });
 
+        $scope.emitHTTPError = function (data, status, headers, config) {
+            $scope.$emit('HTTPError', {data: data, status: status, headers: headers, config: config});
+        };
+
         var debouncedFuncs = {};
 
         function refreshFolder(folder) {
@@ -232,7 +269,7 @@ angular.module('syncthing.core')
                     $http.get(urlbase + '/model?folder=' + encodeURIComponent(folder)).success(function (data) {
                         $scope.model[folder] = data;
                         console.log("refreshFolder", folder, data);
-                    });
+                    }).error($scope.emitHTTPError);
                 }, 1000, true);
             }
             debouncedFuncs[key]();
@@ -279,7 +316,7 @@ angular.module('syncthing.core')
                 }
                 $scope.announceServersFailed = failed;
                 console.log("refreshSystem", data);
-            });
+            }).error($scope.emitHTTPError);
         }
 
         function refreshCompletion(device, folder) {
@@ -308,7 +345,7 @@ angular.module('syncthing.core')
                         $scope.completion[device]._total = tot / cnt;
 
                         console.log("refreshCompletion", device, folder, $scope.completion[device]);
-                    });
+                    }).error($scope.emitHTTPError);
                 }, 1000, true);
             }
             debouncedFuncs[key]();
@@ -335,25 +372,25 @@ angular.module('syncthing.core')
                 }
                 $scope.connections = data;
                 console.log("refreshConnections", data);
-            });
+            }).error($scope.emitHTTPError);
         }
 
         function refreshErrors() {
             $http.get(urlbase + '/errors').success(function (data) {
                 $scope.errors = data.errors;
                 console.log("refreshErrors", data);
-            });
+            }).error($scope.emitHTTPError);
         }
 
         function refreshConfig() {
             $http.get(urlbase + '/config').success(function (data) {
                 updateLocalConfig(data);
                 console.log("refreshConfig", data);
-            });
+            }).error($scope.emitHTTPError);
 
             $http.get(urlbase + '/config/sync').success(function (data) {
                 $scope.configInSync = data.configInSync;
-            });
+            }).error($scope.emitHTTPError);
         }
 
         function refreshNeed(folder) {
@@ -362,7 +399,7 @@ angular.module('syncthing.core')
                     console.log("refreshNeed", folder, data);
                     $scope.needed = data;
                 }
-            });
+            }).error($scope.emitHTTPError);
         }
 
         var refreshDeviceStats = debounce(function () {
@@ -373,7 +410,7 @@ angular.module('syncthing.core')
                     $scope.deviceStats[device].LastSeenDays = (new Date() - $scope.deviceStats[device].LastSeen) / 1000 / 86400;
                 }
                 console.log("refreshDeviceStats", data);
-            });
+            }).error($scope.emitHTTPError);
         }, 500);
 
         var refreshFolderStats = debounce(function () {
@@ -385,7 +422,7 @@ angular.module('syncthing.core')
                     }
                 }
                 console.log("refreshfolderStats", data);
-            });
+            }).error($scope.emitHTTPError);
         }, 500);
 
         $scope.refresh = function () {
@@ -566,7 +603,7 @@ angular.module('syncthing.core')
                 $http.get(urlbase + '/config/sync').success(function (data) {
                     $scope.configInSync = data.configInSync;
                 });
-            });
+            }).error($scope.emitHTTPError);
         };
 
         $scope.saveSettings = function () {
@@ -646,7 +683,7 @@ angular.module('syncthing.core')
             restarting = true;
             $http.post(urlbase + '/shutdown').success(function () {
                 $('#shutdown').modal();
-            });
+            }).error($scope.emitHTTPError);
             $scope.configInSync = true;
         };
 
@@ -698,6 +735,11 @@ angular.module('syncthing.core')
                 return n.DeviceID !== $scope.currentDevice.DeviceID;
             });
             $scope.config.Devices = $scope.devices;
+            // In case we later added the device manually, remove the ignoral
+            // record.
+            $scope.config.IgnoredDevices = $scope.config.IgnoredDevices.filter(function (id) {
+                return id !== $scope.currentDevice.DeviceID;
+            });
 
             for (var id in $scope.folders) {
                 $scope.folders[id].Devices = $scope.folders[id].Devices.filter(function (n) {
@@ -709,10 +751,24 @@ angular.module('syncthing.core')
         };
 
         $scope.saveDevice = function () {
-            var deviceCfg, done, i;
-
             $('#editDevice').modal('hide');
-            deviceCfg = $scope.currentDevice;
+            $scope.saveDeviceConfig($scope.currentDevice);
+        };
+
+        $scope.addNewDeviceID = function (device) {
+            var deviceCfg = {
+                DeviceID: device,
+                AddressesStr: 'dynamic',
+                Compression: true,
+                Introducer: false,
+                selectedFolders: {}
+            };
+            $scope.saveDeviceConfig(deviceCfg);
+            $scope.dismissDeviceRejection(device);
+        };
+
+        $scope.saveDeviceConfig = function (deviceCfg) {
+            var done, i;
             deviceCfg.Addresses = deviceCfg.AddressesStr.split(',').map(function (x) {
                 return x.trim();
             });
@@ -732,6 +788,11 @@ angular.module('syncthing.core')
 
             $scope.devices.sort(deviceCompare);
             $scope.config.Devices = $scope.devices;
+            // In case we are adding the device manually, remove the ignoral
+            // record.
+            $scope.config.IgnoredDevices = $scope.config.IgnoredDevices.filter(function (id) {
+                return id !== deviceCfg.DeviceID;
+            });
 
             if (!$scope.editingSelf) {
                 for (var id in deviceCfg.selectedFolders) {
@@ -749,7 +810,6 @@ angular.module('syncthing.core')
                                 DeviceID: deviceCfg.DeviceID
                             });
                         }
-                        continue
                     } else {
                         $scope.folders[id].Devices = $scope.folders[id].Devices.filter(function (n) {
                             return n.DeviceID != deviceCfg.DeviceID;
@@ -761,6 +821,16 @@ angular.module('syncthing.core')
             $scope.saveConfig();
         };
 
+        $scope.dismissDeviceRejection = function (device) {
+            delete $scope.deviceRejections[device];
+        };
+
+        $scope.ignoreRejectedDevice = function (device) {
+            $scope.config.IgnoredDevices.push(device);
+            $scope.saveConfig();
+            $scope.dismissDeviceRejection(device);
+        };
+
         $scope.otherDevices = function () {
             return $scope.devices.filter(function (n) {
                 return n.DeviceID !== $scope.myID;
@@ -814,11 +884,14 @@ angular.module('syncthing.core')
                 params: { current: newvalue }
             }).success(function (data) {
                 $scope.directoryList = data;
-            });
+            }).error($scope.emitHTTPError);
         });
 
-        $scope.editFolder = function (deviceCfg) {
-            $scope.currentFolder = angular.copy(deviceCfg);
+        $scope.editFolder = function (folderCfg) {
+            $scope.currentFolder = angular.copy(folderCfg);
+            if ($scope.currentFolder.Path.slice(-1) == $scope.system.pathSeparator) {
+                $scope.currentFolder.Path = $scope.currentFolder.Path.slice(0, -1);
+            }
             $scope.currentFolder.selectedDevices = {};
             $scope.currentFolder.Devices.forEach(function (n) {
                 $scope.currentFolder.selectedDevices[n.DeviceID] = true;
@@ -867,6 +940,34 @@ angular.module('syncthing.core')
             $('#editFolder').modal();
         };
 
+        $scope.addFolderAndShare = function (folder, device) {
+            $scope.dismissFolderRejection(folder, device);
+            $scope.currentFolder = {
+                ID: folder,
+                selectedDevices: {}
+            };
+            $scope.currentFolder.selectedDevices[device] = true;
+
+            $scope.currentFolder.RescanIntervalS = 60;
+            $scope.currentFolder.FileVersioningSelector = "none";
+            $scope.currentFolder.simpleKeep = 5;
+            $scope.currentFolder.staggeredMaxAge = 365;
+            $scope.currentFolder.staggeredCleanInterval = 3600;
+            $scope.currentFolder.staggeredVersionsPath = "";
+            $scope.editingExisting = false;
+            $scope.folderEditor.$setPristine();
+            $('#editFolder').modal();
+        };
+
+        $scope.shareFolderWithDevice = function (folder, device) {
+            $scope.folders[folder].Devices.push({
+                DeviceID: device
+            });
+            $scope.config.Folders = folderList($scope.folders);
+            $scope.saveConfig();
+            $scope.dismissFolderRejection(folder, device);
+        };
+
         $scope.saveFolder = function () {
             var folderCfg, done, i;
 
@@ -916,6 +1017,10 @@ angular.module('syncthing.core')
             $scope.saveConfig();
         };
 
+        $scope.dismissFolderRejection = function (folder, device) {
+            delete $scope.folderRejections[folder + "-" + device];
+        };
+
         $scope.sharesFolder = function (folderCfg) {
             var names = [];
             folderCfg.Devices.forEach(function (device) {
@@ -994,7 +1099,7 @@ angular.module('syncthing.core')
         };
 
         $scope.setAPIKey = function (cfg) {
-            cfg.APIKey = randomString(30, 32);
+            cfg.APIKey = randomString(32);
         };
 
         $scope.showURPreview = function () {
@@ -1056,6 +1161,15 @@ angular.module('syncthing.core')
             $http.post(urlbase + "/scan?folder=" + encodeURIComponent(folder));
         };
 
+        $scope.bumpFile = function (folder, file) {
+            $http.post(urlbase + "/bump?folder=" + encodeURIComponent(folder) + "&file=" + encodeURIComponent(file)).success(function (data) {
+                if ($scope.neededFolder == folder) {
+                    console.log("bumpFile", folder, data);
+                    $scope.needed = data;
+                }
+            }).error($scope.emitHTTPError);
+        };
+
         // pseudo main. called on all definitions assigned
         initController();
     });

internal/config/config.go

@@ -20,6 +20,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -37,12 +38,13 @@ var l = logger.DefaultLogger
 const CurrentVersion = 7
 
 type Configuration struct {
-	Version int                   `xml:"version,attr"`
-	Folders []FolderConfiguration `xml:"folder"`
-	Devices []DeviceConfiguration `xml:"device"`
-	GUI     GUIConfiguration      `xml:"gui"`
-	Options OptionsConfiguration  `xml:"options"`
-	XMLName xml.Name              `xml:"configuration" json:"-"`
+	Version        int                   `xml:"version,attr"`
+	Folders        []FolderConfiguration `xml:"folder"`
+	Devices        []DeviceConfiguration `xml:"device"`
+	GUI            GUIConfiguration      `xml:"gui"`
+	Options        OptionsConfiguration  `xml:"options"`
+	IgnoredDevices []protocol.DeviceID   `xml:"ignoredDevice"`
+	XMLName        xml.Name              `xml:"configuration" json:"-"`
 
 	OriginalVersion         int                   `xml:"-" json:"-"` // The version we read from disk, before any conversion
 	Deprecated_Repositories []FolderConfiguration `xml:"repository" json:"-"`
@@ -58,9 +60,9 @@ type FolderConfiguration struct {
 	IgnorePerms     bool                        `xml:"ignorePerms,attr"`
 	Versioning      VersioningConfiguration     `xml:"versioning"`
 	LenientMtimes   bool                        `xml:"lenientMtimes"`
-	Copiers         int                         `xml:"copiers" default:"1"`   // This defines how many files are handled concurrently.
-	Pullers         int                         `xml:"pullers" default:"16"`  // Defines how many blocks are fetched at the same time, possibly between separate copier routines.
-	Finishers       int                         `xml:"finishers" default:"1"` // Most of the time, should be equal to the number of copiers. These are CPU bound due to hashing.
+	Copiers         int                         `xml:"copiers" default:"1"`  // This defines how many files are handled concurrently.
+	Pullers         int                         `xml:"pullers" default:"16"` // Defines how many blocks are fetched at the same time, possibly between separate copier routines.
+	Hashers         int                         `xml:"hashers" default:"0"`  // Less than one sets the value to the number of cores. These are CPU bound due to hashing.
 
 	Invalid string `xml:"-"` // Set at runtime when there is an error, not saved
 
@@ -240,10 +242,13 @@ func (cfg *Configuration) WriteXML(w io.Writer) error {
 func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 	fillNilSlices(&cfg.Options)
 
-	// Initialize an empty slice for folders if the config has none
+	// Initialize an empty slices
 	if cfg.Folders == nil {
 		cfg.Folders = []FolderConfiguration{}
 	}
+	if cfg.IgnoredDevices == nil {
+		cfg.IgnoredDevices = []protocol.DeviceID{}
+	}
 
 	// Check for missing, bad or duplicate folder ID:s
 	var seenFolders = map[string]*FolderConfiguration{}
@@ -353,9 +358,6 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 		if cfg.Folders[i].Pullers == 0 {
 			cfg.Folders[i].Pullers = 16
 		}
-		if cfg.Folders[i].Finishers == 0 {
-			cfg.Folders[i].Finishers = 1
-		}
 		sort.Sort(FolderDeviceConfigurationList(cfg.Folders[i].Devices))
 	}
 
@@ -369,6 +371,10 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 
 	cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress)
 	cfg.Options.GlobalAnnServers = uniqueStrings(cfg.Options.GlobalAnnServers)
+
+	if cfg.GUI.APIKey == "" {
+		cfg.GUI.APIKey = randomString(32)
+	}
 }
 
 // ChangeRequiresRestart returns true if updating the configuration requires a
@@ -674,3 +680,16 @@ func (l FolderDeviceConfigurationList) Swap(a, b int) {
 func (l FolderDeviceConfigurationList) Len() int {
 	return len(l)
 }
+
+// randomCharset contains the characters that can make up a randomString().
+const randomCharset = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
+
+// randomString returns a string of random characters (taken from
+// randomCharset) of the specified length.
+func randomString(l int) string {
+	bs := make([]byte, l)
+	for i := range bs {
+		bs[i] = randomCharset[rand.Intn(len(randomCharset))]
+	}
+	return string(bs)
+}

internal/config/config_test.go

@@ -89,7 +89,7 @@ func TestDeviceConfig(t *testing.T) {
 				RescanIntervalS: 600,
 				Copiers:         1,
 				Pullers:         16,
-				Finishers:       1,
+				Hashers:         0,
 			},
 		}
 		expectedDevices := []DeviceConfiguration{

internal/config/wrapper.go

@@ -245,6 +245,19 @@ func (w *Wrapper) InvalidateFolder(id string, err string) {
 	}
 }
 
+// Returns whether or not connection attempts from the given device should be
+// silently ignored.
+func (w *Wrapper) IgnoredDevice(id protocol.DeviceID) bool {
+	w.mut.Lock()
+	defer w.mut.Unlock()
+	for _, device := range w.cfg.IgnoredDevices {
+		if device == id {
+			return true
+		}
+	}
+	return false
+}
+
 // Save writes the configuration to disk, and generates a ConfigSaved event.
 func (w *Wrapper) Save() error {
 	fd, err := ioutil.TempFile(filepath.Dir(w.path), "cfg")

internal/discover/client_udp.go

@@ -94,7 +94,7 @@ func (d *UDPClient) broadcast(pkt []byte) {
 
 	conn, err := net.ListenUDP(d.url.Scheme, d.listenAddress)
 	for err != nil {
-		l.Warnf("Global UDP discovery (%s): %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		l.Warnf("discover %s: broadcast: %v; trying again in %v", d.url, err, d.errorRetryInterval)
 		select {
 		case <-d.stop:
 			return
@@ -106,7 +106,7 @@ func (d *UDPClient) broadcast(pkt []byte) {
 
 	remote, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
 	for err != nil {
-		l.Warnf("Global UDP discovery (%s): %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		l.Warnf("discover %s: broadcast: %v; trying again in %v", d.url, err, d.errorRetryInterval)
 		select {
 		case <-d.stop:
 			return
@@ -125,13 +125,13 @@ func (d *UDPClient) broadcast(pkt []byte) {
 			var ok bool
 
 			if debug {
-				l.Debugf("Global UDP discovery (%s): send announcement -> %v\n%s", d.url, remote, hex.Dump(pkt))
+				l.Debugf("discover %s: broadcast: Sending self announcement to %v", d.url, remote)
 			}
 
 			_, err := conn.WriteTo(pkt, remote)
 			if err != nil {
 				if debug {
-					l.Debugf("discover %s: warning: %s", d.url, err)
+					l.Debugf("discover %s: broadcast: Failed to send self announcement: %s", d.url, err)
 				}
 				ok = false
 			} else {
@@ -141,7 +141,7 @@ func (d *UDPClient) broadcast(pkt []byte) {
 
 				res := d.Lookup(d.id)
 				if debug {
-					l.Debugf("discover %s: external lookup check: %v", d.url, res)
+					l.Debugf("discover %s: broadcast: Self-lookup returned: %v", d.url, res)
 				}
 				ok = len(res) > 0
 			}
@@ -163,7 +163,7 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 	extIP, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
 	if err != nil {
 		if debug {
-			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
 		}
 		return nil
 	}
@@ -171,7 +171,7 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 	conn, err := net.DialUDP(d.url.Scheme, d.listenAddress, extIP)
 	if err != nil {
 		if debug {
-			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
 		}
 		return nil
 	}
@@ -180,7 +180,7 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 	err = conn.SetDeadline(time.Now().Add(5 * time.Second))
 	if err != nil {
 		if debug {
-			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
 		}
 		return nil
 	}
@@ -189,7 +189,7 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 	_, err = conn.Write(buf)
 	if err != nil {
 		if debug {
-			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
 		}
 		return nil
 	}
@@ -202,20 +202,16 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 			return nil
 		}
 		if debug {
-			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s", d.url, device, err)
 		}
 		return nil
 	}
 
-	if debug {
-		l.Debugf("discover %s: read external:\n%s", d.url, hex.Dump(buf[:n]))
-	}
-
 	var pkt Announce
 	err = pkt.UnmarshalXDR(buf[:n])
 	if err != nil && err != io.EOF {
 		if debug {
-			l.Debugln("discover %s:", d.url, err)
+			l.Debugf("discover %s: Lookup(%s): %s\n%s", d.url, device, err, hex.Dump(buf[:n]))
 		}
 		return nil
 	}
@@ -225,6 +221,9 @@ func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
 		deviceAddr := net.JoinHostPort(net.IP(a.IP).String(), strconv.Itoa(int(a.Port)))
 		addrs = append(addrs, deviceAddr)
 	}
+	if debug {
+		l.Debugf("discover %s: Lookup(%s) result: %v", d.url, device, addrs)
+	}
 	return addrs
 }
 

internal/discover/discover.go

@@ -72,7 +72,7 @@ func (d *Discoverer) StartLocal(localPort int, localMCAddr string) {
 		bb, err := beacon.NewBroadcast(localPort)
 		if err != nil {
 			if debug {
-				l.Debugln(err)
+				l.Debugln("discover: Start local v4:", err)
 			}
 			l.Infoln("Local discovery over IPv4 unavailable")
 		} else {
@@ -85,7 +85,7 @@ func (d *Discoverer) StartLocal(localPort int, localMCAddr string) {
 		mb, err := beacon.NewMulticast(localMCAddr)
 		if err != nil {
 			if debug {
-				l.Debugln(err)
+				l.Debugln("discover: Start local v6:", err)
 			}
 			l.Infoln("Local discovery over IPv6 unavailable")
 		} else {
@@ -247,10 +247,10 @@ func (d *Discoverer) announcementPkt() *Announce {
 		for _, astr := range d.listenAddrs {
 			addr, err := net.ResolveTCPAddr("tcp", astr)
 			if err != nil {
-				l.Warnln("%v: not announcing %s", err, astr)
+				l.Warnln("discover: %v: not announcing %s", err, astr)
 				continue
 			} else if debug {
-				l.Debugf("discover: announcing %s: %#v", astr, addr)
+				l.Debugf("discover: resolved %s as %#v", astr, addr)
 			}
 			if len(addr.IP) == 0 || addr.IP.IsUnspecified() {
 				addrs = append(addrs, Address{Port: uint16(addr.Port)})
@@ -295,16 +295,19 @@ func (d *Discoverer) recvAnnouncements(b beacon.Interface) {
 	for {
 		buf, addr := b.Recv()
 
-		if debug {
-			l.Debugf("discover: read announcement from %s:\n%s", addr, hex.Dump(buf))
-		}
-
 		var pkt Announce
 		err := pkt.UnmarshalXDR(buf)
 		if err != nil && err != io.EOF {
+			if debug {
+				l.Debugf("discover: Failed to unmarshal local announcement from %s:\n%s", addr, hex.Dump(buf))
+			}
 			continue
 		}
 
+		if debug {
+			l.Debugf("discover: Received local announcement from %s for %s", addr, protocol.DeviceIDFromBytes(pkt.This.ID))
+		}
+
 		var newDevice bool
 		if bytes.Compare(pkt.This.ID, d.myID[:]) != 0 {
 			newDevice = d.registerDevice(addr, pkt.This)
@@ -352,7 +355,7 @@ func (d *Discoverer) registerDevice(addr net.Addr, device Device) bool {
 	}
 
 	if debug {
-		l.Debugf("discover: register: %v -> %v", id, current)
+		l.Debugf("discover: Caching %s addresses: %v", id, current)
 	}
 
 	d.registry[id] = current
@@ -375,7 +378,7 @@ func (d *Discoverer) filterCached(c []CacheEntry) []CacheEntry {
 	for i := 0; i < len(c); {
 		if ago := time.Since(c[i].Seen); ago > d.cacheLifetime {
 			if debug {
-				l.Debugf("removing cached address %s: seen %v ago", c[i].Address, ago)
+				l.Debugf("discover: Removing cached address %s - seen %v ago", c[i].Address, ago)
 			}
 			c[i] = c[len(c)-1]
 			c = c[:len(c)-1]

internal/events/events.go

@@ -187,6 +187,10 @@ func (s *Subscription) Poll(timeout time.Duration) (Event, error) {
 	}
 }
 
+func (s *Subscription) C() <-chan Event {
+	return s.events
+}
+
 type BufferedSubscription struct {
 	sub  *Subscription
 	buf  []Event

internal/files/concurrency_test.go

@@ -144,7 +144,7 @@ func TestConcurrentSetClear(t *testing.T) {
 	var wg sync.WaitGroup
 
 	os.RemoveAll("testdata/concurrent-set-clear.db")
-	db, err := leveldb.OpenFile("testdata/concurrent-set-clear.db", &opt.Options{CachedOpenFiles: 10})
+	db, err := leveldb.OpenFile("testdata/concurrent-set-clear.db", &opt.Options{OpenFilesCacheCapacity: 10})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -200,7 +200,7 @@ func TestConcurrentSetOnly(t *testing.T) {
 	var wg sync.WaitGroup
 
 	os.RemoveAll("testdata/concurrent-set-only.db")
-	db, err := leveldb.OpenFile("testdata/concurrent-set-only.db", &opt.Options{CachedOpenFiles: 10})
+	db, err := leveldb.OpenFile("testdata/concurrent-set-only.db", &opt.Options{OpenFilesCacheCapacity: 10})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/files/leveldb.go

@@ -166,8 +166,6 @@ func globalKeyFolder(key []byte) []byte {
 
 type deletionHandler func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) uint64
 
-type fileIterator func(f protocol.FileIntf) bool
-
 func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, deleteFn deletionHandler) uint64 {
 	runtime.GC()
 
@@ -246,7 +244,7 @@ func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.File
 			if debugDB {
 				l.Debugln("generic replace; exists - compare")
 			}
-			var ef protocol.FileInfoTruncated
+			var ef FileInfoTruncated
 			ef.UnmarshalXDR(dbi.Value())
 			if fs[fsi].Version > ef.Version ||
 				(fs[fsi].Version == ef.Version && fs[fsi].Flags != ef.Flags) {
@@ -308,7 +306,7 @@ func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) u
 
 func ldbReplaceWithDelete(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) uint64 {
 	return ldbGenericReplace(db, folder, device, fs, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) uint64 {
-		var tf protocol.FileInfoTruncated
+		var tf FileInfoTruncated
 		err := tf.UnmarshalXDR(dbi.Value())
 		if err != nil {
 			panic(err)
@@ -378,7 +376,7 @@ func ldbUpdate(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) ui
 			continue
 		}
 
-		var ef protocol.FileInfoTruncated
+		var ef FileInfoTruncated
 		err = ef.UnmarshalXDR(bs)
 		if err != nil {
 			panic(err)
@@ -528,7 +526,7 @@ func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byt
 	}
 }
 
-func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn fileIterator) {
+func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) {
 	start := deviceKey(folder, device, nil)                            // before all folder/device files
 	limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
 	snap, err := db.GetSnapshot()
@@ -559,7 +557,7 @@ func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn fileIt
 	}
 }
 
-func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []byte, f protocol.FileInfoTruncated) bool) {
+func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []byte, f FileInfoTruncated) bool) {
 	runtime.GC()
 
 	start := deviceKey(folder, nil, nil)                                                  // before all folder/device files
@@ -583,7 +581,7 @@ func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []b
 
 	for dbi.Next() {
 		device := deviceKeyDevice(dbi.Key())
-		var f protocol.FileInfoTruncated
+		var f FileInfoTruncated
 		err := f.UnmarshalXDR(dbi.Value())
 		if err != nil {
 			panic(err)
@@ -594,11 +592,11 @@ func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []b
 	}
 }
 
-func ldbGet(db *leveldb.DB, folder, device, file []byte) protocol.FileInfo {
+func ldbGet(db *leveldb.DB, folder, device, file []byte) (protocol.FileInfo, bool) {
 	nk := deviceKey(folder, device, file)
 	bs, err := db.Get(nk, nil)
 	if err == leveldb.ErrNotFound {
-		return protocol.FileInfo{}
+		return protocol.FileInfo{}, false
 	}
 	if err != nil {
 		panic(err)
@@ -609,10 +607,10 @@ func ldbGet(db *leveldb.DB, folder, device, file []byte) protocol.FileInfo {
 	if err != nil {
 		panic(err)
 	}
-	return f
+	return f, true
 }
 
-func ldbGetGlobal(db *leveldb.DB, folder, file []byte) protocol.FileInfo {
+func ldbGetGlobal(db *leveldb.DB, folder, file []byte, truncate bool) (FileIntf, bool) {
 	k := globalKey(folder, file)
 	snap, err := db.GetSnapshot()
 	if err != nil {
@@ -633,7 +631,7 @@ func ldbGetGlobal(db *leveldb.DB, folder, file []byte) protocol.FileInfo {
 	}
 	bs, err := snap.Get(k, nil)
 	if err == leveldb.ErrNotFound {
-		return protocol.FileInfo{}
+		return nil, false
 	}
 	if err != nil {
 		panic(err)
@@ -658,15 +656,14 @@ func ldbGetGlobal(db *leveldb.DB, folder, file []byte) protocol.FileInfo {
 		panic(err)
 	}
 
-	var f protocol.FileInfo
-	err = f.UnmarshalXDR(bs)
+	fi, err := unmarshalTrunc(bs, truncate)
 	if err != nil {
 		panic(err)
 	}
-	return f
+	return fi, true
 }
 
-func ldbWithGlobal(db *leveldb.DB, folder []byte, truncate bool, fn fileIterator) {
+func ldbWithGlobal(db *leveldb.DB, folder []byte, truncate bool, fn Iterator) {
 	runtime.GC()
 
 	start := globalKey(folder, nil)
@@ -754,7 +751,7 @@ func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID {
 	return devices
 }
 
-func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn fileIterator) {
+func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) {
 	runtime.GC()
 
 	start := globalKey(folder, nil)
@@ -938,9 +935,9 @@ func ldbDropFolder(db *leveldb.DB, folder []byte) {
 	dbi.Release()
 }
 
-func unmarshalTrunc(bs []byte, truncate bool) (protocol.FileIntf, error) {
+func unmarshalTrunc(bs []byte, truncate bool) (FileIntf, error) {
 	if truncate {
-		var tf protocol.FileInfoTruncated
+		var tf FileInfoTruncated
 		err := tf.UnmarshalXDR(bs)
 		return tf, err
 	} else {

internal/files/set.go

@@ -30,14 +30,6 @@ import (
 	"github.com/syndtr/goleveldb/leveldb"
 )
 
-type fileRecord struct {
-	File   protocol.FileInfo
-	Usage  int
-	Global bool
-}
-
-type bitset uint64
-
 type Set struct {
 	localVersion map[protocol.DeviceID]uint64
 	mutex        sync.Mutex
@@ -46,6 +38,22 @@ type Set struct {
 	blockmap     *BlockMap
 }
 
+// FileIntf is the set of methods implemented by both protocol.FileInfo and
+// protocol.FileInfoTruncated.
+type FileIntf interface {
+	Size() int64
+	IsDeleted() bool
+	IsInvalid() bool
+	IsDirectory() bool
+	IsSymlink() bool
+	HasPermissionBits() bool
+}
+
+// The Iterator is called with either a protocol.FileInfo or a
+// protocol.FileInfoTruncated (depending on the method) and returns true to
+// continue iteration, false to stop.
+type Iterator func(f FileIntf) bool
+
 func NewSet(folder string, db *leveldb.DB) *Set {
 	var s = Set{
 		localVersion: make(map[protocol.DeviceID]uint64),
@@ -57,7 +65,7 @@ func NewSet(folder string, db *leveldb.DB) *Set {
 	ldbCheckGlobals(db, []byte(folder))
 
 	var deviceID protocol.DeviceID
-	ldbWithAllFolderTruncated(db, []byte(folder), func(device []byte, f protocol.FileInfoTruncated) bool {
+	ldbWithAllFolderTruncated(db, []byte(folder), func(device []byte, f FileInfoTruncated) bool {
 		copy(deviceID[:], device)
 		if f.LocalVersion > s.localVersion[deviceID] {
 			s.localVersion[deviceID] = f.LocalVersion
@@ -118,8 +126,8 @@ func (s *Set) Update(device protocol.DeviceID, fs []protocol.FileInfo) {
 		discards := make([]protocol.FileInfo, 0, len(fs))
 		updates := make([]protocol.FileInfo, 0, len(fs))
 		for _, newFile := range fs {
-			existingFile := ldbGet(s.db, []byte(s.folder), device[:], []byte(newFile.Name))
-			if existingFile.Version <= newFile.Version {
+			existingFile, ok := ldbGet(s.db, []byte(s.folder), device[:], []byte(newFile.Name))
+			if !ok || existingFile.Version <= newFile.Version {
 				discards = append(discards, existingFile)
 				updates = append(updates, newFile)
 			}
@@ -132,58 +140,72 @@ func (s *Set) Update(device protocol.DeviceID, fs []protocol.FileInfo) {
 	}
 }
 
-func (s *Set) WithNeed(device protocol.DeviceID, fn fileIterator) {
+func (s *Set) WithNeed(device protocol.DeviceID, fn Iterator) {
 	if debug {
 		l.Debugf("%s WithNeed(%v)", s.folder, device)
 	}
 	ldbWithNeed(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
-func (s *Set) WithNeedTruncated(device protocol.DeviceID, fn fileIterator) {
+func (s *Set) WithNeedTruncated(device protocol.DeviceID, fn Iterator) {
 	if debug {
 		l.Debugf("%s WithNeedTruncated(%v)", s.folder, device)
 	}
 	ldbWithNeed(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
-func (s *Set) WithHave(device protocol.DeviceID, fn fileIterator) {
+func (s *Set) WithHave(device protocol.DeviceID, fn Iterator) {
 	if debug {
 		l.Debugf("%s WithHave(%v)", s.folder, device)
 	}
 	ldbWithHave(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
-func (s *Set) WithHaveTruncated(device protocol.DeviceID, fn fileIterator) {
+func (s *Set) WithHaveTruncated(device protocol.DeviceID, fn Iterator) {
 	if debug {
 		l.Debugf("%s WithHaveTruncated(%v)", s.folder, device)
 	}
 	ldbWithHave(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
-func (s *Set) WithGlobal(fn fileIterator) {
+func (s *Set) WithGlobal(fn Iterator) {
 	if debug {
 		l.Debugf("%s WithGlobal()", s.folder)
 	}
 	ldbWithGlobal(s.db, []byte(s.folder), false, nativeFileIterator(fn))
 }
 
-func (s *Set) WithGlobalTruncated(fn fileIterator) {
+func (s *Set) WithGlobalTruncated(fn Iterator) {
 	if debug {
 		l.Debugf("%s WithGlobalTruncated()", s.folder)
 	}
 	ldbWithGlobal(s.db, []byte(s.folder), true, nativeFileIterator(fn))
 }
 
-func (s *Set) Get(device protocol.DeviceID, file string) protocol.FileInfo {
-	f := ldbGet(s.db, []byte(s.folder), device[:], []byte(osutil.NormalizedFilename(file)))
+func (s *Set) Get(device protocol.DeviceID, file string) (protocol.FileInfo, bool) {
+	f, ok := ldbGet(s.db, []byte(s.folder), device[:], []byte(osutil.NormalizedFilename(file)))
 	f.Name = osutil.NativeFilename(f.Name)
-	return f
+	return f, ok
 }
 
-func (s *Set) GetGlobal(file string) protocol.FileInfo {
-	f := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)))
+func (s *Set) GetGlobal(file string) (protocol.FileInfo, bool) {
+	fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), false)
+	if !ok {
+		return protocol.FileInfo{}, false
+	}
+	f := fi.(protocol.FileInfo)
 	f.Name = osutil.NativeFilename(f.Name)
-	return f
+	return f, true
+}
+
+func (s *Set) GetGlobalTruncated(file string) (FileInfoTruncated, bool) {
+	fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), true)
+	if !ok {
+		return FileInfoTruncated{}, false
+	}
+	f := fi.(FileInfoTruncated)
+	f.Name = osutil.NativeFilename(f.Name)
+	return f, true
 }
 
 func (s *Set) Availability(file string) []protocol.DeviceID {
@@ -218,13 +240,13 @@ func normalizeFilenames(fs []protocol.FileInfo) {
 	}
 }
 
-func nativeFileIterator(fn fileIterator) fileIterator {
-	return func(fi protocol.FileIntf) bool {
+func nativeFileIterator(fn Iterator) Iterator {
+	return func(fi FileIntf) bool {
 		switch f := fi.(type) {
 		case protocol.FileInfo:
 			f.Name = osutil.NativeFilename(f.Name)
 			return fn(f)
-		case protocol.FileInfoTruncated:
+		case FileInfoTruncated:
 			f.Name = osutil.NativeFilename(f.Name)
 			return fn(f)
 		default:

internal/files/set_test.go

@@ -51,7 +51,7 @@ func genBlocks(n int) []protocol.BlockInfo {
 
 func globalList(s *files.Set) []protocol.FileInfo {
 	var fs []protocol.FileInfo
-	s.WithGlobal(func(fi protocol.FileIntf) bool {
+	s.WithGlobal(func(fi files.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
 		fs = append(fs, f)
 		return true
@@ -61,7 +61,7 @@ func globalList(s *files.Set) []protocol.FileInfo {
 
 func haveList(s *files.Set, n protocol.DeviceID) []protocol.FileInfo {
 	var fs []protocol.FileInfo
-	s.WithHave(n, func(fi protocol.FileIntf) bool {
+	s.WithHave(n, func(fi files.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
 		fs = append(fs, f)
 		return true
@@ -71,7 +71,7 @@ func haveList(s *files.Set, n protocol.DeviceID) []protocol.FileInfo {
 
 func needList(s *files.Set, n protocol.DeviceID) []protocol.FileInfo {
 	var fs []protocol.FileInfo
-	s.WithNeed(n, func(fi protocol.FileIntf) bool {
+	s.WithNeed(n, func(fi files.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
 		fs = append(fs, f)
 		return true
@@ -209,27 +209,42 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("Need incorrect;\n A: %v !=\n E: %v", n, expectedRemoteNeed)
 	}
 
-	f := m.Get(protocol.LocalDeviceID, "b")
+	f, ok := m.Get(protocol.LocalDeviceID, "b")
+	if !ok {
+		t.Error("Unexpectedly not OK")
+	}
 	if fmt.Sprint(f) != fmt.Sprint(localTot[1]) {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, localTot[1])
 	}
 
-	f = m.Get(remoteDevice0, "b")
+	f, ok = m.Get(remoteDevice0, "b")
+	if !ok {
+		t.Error("Unexpectedly not OK")
+	}
 	if fmt.Sprint(f) != fmt.Sprint(remote1[0]) {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, remote1[0])
 	}
 
-	f = m.GetGlobal("b")
+	f, ok = m.GetGlobal("b")
+	if !ok {
+		t.Error("Unexpectedly not OK")
+	}
 	if fmt.Sprint(f) != fmt.Sprint(remote1[0]) {
 		t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, remote1[0])
 	}
 
-	f = m.Get(protocol.LocalDeviceID, "zz")
+	f, ok = m.Get(protocol.LocalDeviceID, "zz")
+	if ok {
+		t.Error("Unexpectedly OK")
+	}
 	if f.Name != "" {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
 	}
 
-	f = m.GetGlobal("zz")
+	f, ok = m.GetGlobal("zz")
+	if ok {
+		t.Error("Unexpectedly OK")
+	}
 	if f.Name != "" {
 		t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
 	}

internal/files/truncated.go

@@ -0,0 +1,75 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+//go:generate -command genxdr go run ../../Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go
+//go:generate genxdr -o truncated_xdr.go truncated.go
+
+package files
+
+import (
+	"fmt"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+// Used for unmarshalling a FileInfo structure but skipping the block list.
+type FileInfoTruncated struct {
+	Name         string // max:8192
+	Flags        uint32
+	Modified     int64
+	Version      uint64
+	LocalVersion uint64
+	NumBlocks    uint32
+}
+
+func (f FileInfoTruncated) String() string {
+	return fmt.Sprintf("File{Name:%q, Flags:0%o, Modified:%d, Version:%d, Size:%d, NumBlocks:%d}",
+		f.Name, f.Flags, f.Modified, f.Version, f.Size(), f.NumBlocks)
+}
+
+// Returns a statistical guess on the size, not the exact figure
+func (f FileInfoTruncated) Size() int64 {
+	if f.IsDeleted() || f.IsDirectory() {
+		return 128
+	}
+	return BlocksToSize(f.NumBlocks)
+}
+
+func (f FileInfoTruncated) IsDeleted() bool {
+	return f.Flags&protocol.FlagDeleted != 0
+}
+
+func (f FileInfoTruncated) IsInvalid() bool {
+	return f.Flags&protocol.FlagInvalid != 0
+}
+
+func (f FileInfoTruncated) IsDirectory() bool {
+	return f.Flags&protocol.FlagDirectory != 0
+}
+
+func (f FileInfoTruncated) IsSymlink() bool {
+	return f.Flags&protocol.FlagSymlink != 0
+}
+
+func (f FileInfoTruncated) HasPermissionBits() bool {
+	return f.Flags&protocol.FlagNoPermBits == 0
+}
+
+func BlocksToSize(num uint32) int64 {
+	if num < 2 {
+		return protocol.BlockSize / 2
+	}
+	return int64(num-1)*protocol.BlockSize + protocol.BlockSize/2
+}

internal/files/truncated_xdr.go

@@ -0,0 +1,112 @@
+// ************************************************************
+// This file is automatically generated by genxdr. Do not edit.
+// ************************************************************
+
+package files
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/calmh/xdr"
+)
+
+/*
+
+FileInfoTruncated Structure:
+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                        Length of Name                         |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                    Name (variable length)                     \
+/                                                               /
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Flags                             |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
++                      Modified (64 bits)                       +
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
++                       Version (64 bits)                       +
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
++                    Local Version (64 bits)                    +
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                          Num Blocks                           |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+struct FileInfoTruncated {
+	string Name<8192>;
+	unsigned int Flags;
+	hyper Modified;
+	unsigned hyper Version;
+	unsigned hyper LocalVersion;
+	unsigned int NumBlocks;
+}
+
+*/
+
+func (o FileInfoTruncated) EncodeXDR(w io.Writer) (int, error) {
+	var xw = xdr.NewWriter(w)
+	return o.encodeXDR(xw)
+}
+
+func (o FileInfoTruncated) MarshalXDR() ([]byte, error) {
+	return o.AppendXDR(make([]byte, 0, 128))
+}
+
+func (o FileInfoTruncated) MustMarshalXDR() []byte {
+	bs, err := o.MarshalXDR()
+	if err != nil {
+		panic(err)
+	}
+	return bs
+}
+
+func (o FileInfoTruncated) AppendXDR(bs []byte) ([]byte, error) {
+	var aw = xdr.AppendWriter(bs)
+	var xw = xdr.NewWriter(&aw)
+	_, err := o.encodeXDR(xw)
+	return []byte(aw), err
+}
+
+func (o FileInfoTruncated) encodeXDR(xw *xdr.Writer) (int, error) {
+	if l := len(o.Name); l > 8192 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Name", l, 8192)
+	}
+	xw.WriteString(o.Name)
+	xw.WriteUint32(o.Flags)
+	xw.WriteUint64(uint64(o.Modified))
+	xw.WriteUint64(o.Version)
+	xw.WriteUint64(o.LocalVersion)
+	xw.WriteUint32(o.NumBlocks)
+	return xw.Tot(), xw.Error()
+}
+
+func (o *FileInfoTruncated) DecodeXDR(r io.Reader) error {
+	xr := xdr.NewReader(r)
+	return o.decodeXDR(xr)
+}
+
+func (o *FileInfoTruncated) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.decodeXDR(xr)
+}
+
+func (o *FileInfoTruncated) decodeXDR(xr *xdr.Reader) error {
+	o.Name = xr.ReadStringMax(8192)
+	o.Flags = xr.ReadUint32()
+	o.Modified = int64(xr.ReadUint64())
+	o.Version = xr.ReadUint64()
+	o.LocalVersion = xr.ReadUint64()
+	o.NumBlocks = xr.ReadUint32()
+	return xr.Error()
+}

internal/model/model.go

@@ -79,6 +79,8 @@ const (
 type service interface {
 	Serve()
 	Stop()
+	Jobs() ([]string, []string) // In progress, Queued
+	BringToFront(string)
 }
 
 type Model struct {
@@ -188,7 +190,7 @@ func (m *Model) StartFolderRW(folder string) {
 		progressEmitter: m.progressEmitter,
 		copiers:         cfg.Copiers,
 		pullers:         cfg.Pullers,
-		finishers:       cfg.Finishers,
+		queue:           newJobQueue(),
 	}
 	m.folderRunners[folder] = p
 	m.fmut.Unlock()
@@ -307,7 +309,7 @@ func (m *Model) Completion(device protocol.DeviceID, folder string) float64 {
 		return 0 // Folder doesn't exist, so we hardly have any of it
 	}
 
-	rf.WithGlobalTruncated(func(f protocol.FileIntf) bool {
+	rf.WithGlobalTruncated(func(f files.FileIntf) bool {
 		if !f.IsDeleted() {
 			tot += f.Size()
 		}
@@ -319,7 +321,7 @@ func (m *Model) Completion(device protocol.DeviceID, folder string) float64 {
 	}
 
 	var need int64
-	rf.WithNeedTruncated(device, func(f protocol.FileIntf) bool {
+	rf.WithNeedTruncated(device, func(f files.FileIntf) bool {
 		if !f.IsDeleted() {
 			need += f.Size()
 		}
@@ -344,7 +346,7 @@ func sizeOf(fs []protocol.FileInfo) (files, deleted int, bytes int64) {
 	return
 }
 
-func sizeOfFile(f protocol.FileIntf) (files, deleted int, bytes int64) {
+func sizeOfFile(f files.FileIntf) (files, deleted int, bytes int64) {
 	if !f.IsDeleted() {
 		files++
 	} else {
@@ -356,15 +358,15 @@ func sizeOfFile(f protocol.FileIntf) (files, deleted int, bytes int64) {
 
 // GlobalSize returns the number of files, deleted files and total bytes for all
 // files in the global model.
-func (m *Model) GlobalSize(folder string) (files, deleted int, bytes int64) {
+func (m *Model) GlobalSize(folder string) (nfiles, deleted int, bytes int64) {
 	defer m.leveldbPanicWorkaround()
 
 	m.fmut.RLock()
 	defer m.fmut.RUnlock()
 	if rf, ok := m.folderFiles[folder]; ok {
-		rf.WithGlobalTruncated(func(f protocol.FileIntf) bool {
+		rf.WithGlobalTruncated(func(f files.FileIntf) bool {
 			fs, de, by := sizeOfFile(f)
-			files += fs
+			nfiles += fs
 			deleted += de
 			bytes += by
 			return true
@@ -375,18 +377,18 @@ func (m *Model) GlobalSize(folder string) (files, deleted int, bytes int64) {
 
 // LocalSize returns the number of files, deleted files and total bytes for all
 // files in the local folder.
-func (m *Model) LocalSize(folder string) (files, deleted int, bytes int64) {
+func (m *Model) LocalSize(folder string) (nfiles, deleted int, bytes int64) {
 	defer m.leveldbPanicWorkaround()
 
 	m.fmut.RLock()
 	defer m.fmut.RUnlock()
 	if rf, ok := m.folderFiles[folder]; ok {
-		rf.WithHaveTruncated(protocol.LocalDeviceID, func(f protocol.FileIntf) bool {
+		rf.WithHaveTruncated(protocol.LocalDeviceID, func(f files.FileIntf) bool {
 			if f.IsInvalid() {
 				return true
 			}
 			fs, de, by := sizeOfFile(f)
-			files += fs
+			nfiles += fs
 			deleted += de
 			bytes += by
 			return true
@@ -396,42 +398,74 @@ func (m *Model) LocalSize(folder string) (files, deleted int, bytes int64) {
 }
 
 // NeedSize returns the number and total size of currently needed files.
-func (m *Model) NeedSize(folder string) (files int, bytes int64) {
+func (m *Model) NeedSize(folder string) (nfiles int, bytes int64) {
 	defer m.leveldbPanicWorkaround()
 
 	m.fmut.RLock()
 	defer m.fmut.RUnlock()
 	if rf, ok := m.folderFiles[folder]; ok {
-		rf.WithNeedTruncated(protocol.LocalDeviceID, func(f protocol.FileIntf) bool {
+		rf.WithNeedTruncated(protocol.LocalDeviceID, func(f files.FileIntf) bool {
 			fs, de, by := sizeOfFile(f)
-			files += fs + de
+			nfiles += fs + de
 			bytes += by
 			return true
 		})
 	}
 	bytes -= m.progressEmitter.BytesCompleted(folder)
 	if debug {
-		l.Debugf("%v NeedSize(%q): %d %d", m, folder, files, bytes)
+		l.Debugf("%v NeedSize(%q): %d %d", m, folder, nfiles, bytes)
 	}
 	return
 }
 
-// NeedFiles returns the list of currently needed files, stopping at maxFiles
-// files. Limit <= 0 is ignored.
-func (m *Model) NeedFolderFilesLimited(folder string, maxFiles int) []protocol.FileInfoTruncated {
+// NeedFiles returns the list of currently needed files in progress, queued,
+// and to be queued on next puller iteration. Also takes a soft cap which is
+// only respected when adding files from the model rather than the runner queue.
+func (m *Model) NeedFolderFiles(folder string, max int) ([]files.FileInfoTruncated, []files.FileInfoTruncated, []files.FileInfoTruncated) {
 	defer m.leveldbPanicWorkaround()
 
 	m.fmut.RLock()
 	defer m.fmut.RUnlock()
 	if rf, ok := m.folderFiles[folder]; ok {
-		fs := make([]protocol.FileInfoTruncated, 0, maxFiles)
-		rf.WithNeedTruncated(protocol.LocalDeviceID, func(f protocol.FileIntf) bool {
-			fs = append(fs, f.(protocol.FileInfoTruncated))
-			return maxFiles <= 0 || len(fs) < maxFiles
-		})
-		return fs
+		var progress, queued, rest []files.FileInfoTruncated
+		var seen map[string]bool
+
+		runner, ok := m.folderRunners[folder]
+		if ok {
+			progressNames, queuedNames := runner.Jobs()
+
+			progress = make([]files.FileInfoTruncated, len(progressNames))
+			queued = make([]files.FileInfoTruncated, len(queuedNames))
+			seen = make(map[string]bool, len(progressNames)+len(queuedNames))
+
+			for i, name := range progressNames {
+				if f, ok := rf.GetGlobalTruncated(name); ok {
+					progress[i] = f
+					seen[name] = true
+				}
+			}
+
+			for i, name := range queuedNames {
+				if f, ok := rf.GetGlobalTruncated(name); ok {
+					queued[i] = f
+					seen[name] = true
+				}
+			}
+		}
+		left := max - len(progress) - len(queued)
+		if max < 1 || left > 0 {
+			rf.WithNeedTruncated(protocol.LocalDeviceID, func(f files.FileIntf) bool {
+				left--
+				ft := f.(files.FileInfoTruncated)
+				if !seen[ft.Name] {
+					rest = append(rest, ft)
+				}
+				return max < 1 || left > 0
+			})
+		}
+		return progress, queued, rest
 	}
-	return nil
+	return nil, nil, nil
 }
 
 // Index is called when a new device is connected and we receive their full index.
@@ -446,7 +480,7 @@ func (m *Model) Index(deviceID protocol.DeviceID, folder string, fs []protocol.F
 			"folder": folder,
 			"device": deviceID.String(),
 		})
-		l.Warnf("Unexpected folder ID %q sent from device %q; ensure that the folder exists and that this device is selected under \"Share With\" in the folder configuration.", folder, deviceID)
+		l.Infof("Unexpected folder ID %q sent from device %q; ensure that the folder exists and that this device is selected under \"Share With\" in the folder configuration.", folder, deviceID)
 		return
 	}
 
@@ -542,8 +576,21 @@ func (m *Model) ClusterConfig(deviceID protocol.DeviceID, cm protocol.ClusterCon
 	} else {
 		m.deviceVer[deviceID] = cm.ClientName + " " + cm.ClientVersion
 	}
+
+	event := map[string]string{
+		"id":            deviceID.String(),
+		"clientName":    cm.ClientName,
+		"clientVersion": cm.ClientVersion,
+	}
+
+	if conn, ok := m.rawConn[deviceID].(*tls.Conn); ok {
+		event["addr"] = conn.RemoteAddr().String()
+	}
+
 	m.pmut.Unlock()
 
+	events.Default.Log(events.DeviceConnected, event)
+
 	l.Infof(`Device %s client is "%s %s"`, deviceID, cm.ClientName, cm.ClientVersion)
 
 	var changed bool
@@ -673,7 +720,11 @@ func (m *Model) Request(deviceID protocol.DeviceID, folder, name string, offset
 		return nil, ErrNoSuchFile
 	}
 
-	lf := r.Get(protocol.LocalDeviceID, name)
+	lf, ok := r.Get(protocol.LocalDeviceID, name)
+	if !ok {
+		return nil, ErrNoSuchFile
+	}
+
 	if lf.IsInvalid() || lf.IsDeleted() {
 		if debug {
 			l.Debugf("%v REQ(in): %s: %q / %q o=%d s=%d; invalid: %v", m, deviceID, folder, name, offset, size, lf)
@@ -728,18 +779,18 @@ func (m *Model) ReplaceLocal(folder string, fs []protocol.FileInfo) {
 	m.fmut.RUnlock()
 }
 
-func (m *Model) CurrentFolderFile(folder string, file string) protocol.FileInfo {
+func (m *Model) CurrentFolderFile(folder string, file string) (protocol.FileInfo, bool) {
 	m.fmut.RLock()
-	f := m.folderFiles[folder].Get(protocol.LocalDeviceID, file)
+	f, ok := m.folderFiles[folder].Get(protocol.LocalDeviceID, file)
 	m.fmut.RUnlock()
-	return f
+	return f, ok
 }
 
-func (m *Model) CurrentGlobalFile(folder string, file string) protocol.FileInfo {
+func (m *Model) CurrentGlobalFile(folder string, file string) (protocol.FileInfo, bool) {
 	m.fmut.RLock()
-	f := m.folderFiles[folder].GetGlobal(file)
+	f, ok := m.folderFiles[folder].GetGlobal(file)
 	m.fmut.RUnlock()
-	return f
+	return f, ok
 }
 
 type cFiler struct {
@@ -748,7 +799,7 @@ type cFiler struct {
 }
 
 // Implements scanner.CurrentFiler
-func (cf cFiler) CurrentFile(file string) protocol.FileInfo {
+func (cf cFiler) CurrentFile(file string) (protocol.FileInfo, bool) {
 	return cf.m.CurrentFolderFile(cf.r, file)
 }
 
@@ -931,7 +982,7 @@ func sendIndexTo(initial bool, minLocalVer uint64, conn protocol.Connection, fol
 	maxLocalVer := uint64(0)
 	var err error
 
-	fs.WithHave(protocol.LocalDeviceID, func(fi protocol.FileIntf) bool {
+	fs.WithHave(protocol.LocalDeviceID, func(fi files.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
 		if f.LocalVersion <= minLocalVer {
 			return true
@@ -1099,6 +1150,7 @@ func (m *Model) ScanFolderSub(folder, sub string) error {
 		TempLifetime: time.Duration(m.cfg.Options().KeepTemporariesH) * time.Hour,
 		CurrentFiler: cFiler{m, folder},
 		IgnorePerms:  folderCfg.IgnorePerms,
+		Hashers:      folderCfg.Hashers,
 	}
 
 	m.setState(folder, FolderScanning)
@@ -1130,8 +1182,8 @@ func (m *Model) ScanFolderSub(folder, sub string) error {
 	batch = batch[:0]
 	// TODO: We should limit the Have scanning to start at sub
 	seenPrefix := false
-	fs.WithHaveTruncated(protocol.LocalDeviceID, func(fi protocol.FileIntf) bool {
-		f := fi.(protocol.FileInfoTruncated)
+	fs.WithHaveTruncated(protocol.LocalDeviceID, func(fi files.FileIntf) bool {
+		f := fi.(files.FileInfoTruncated)
 		if !strings.HasPrefix(f.Name, sub) {
 			// Return true so that we keep iterating, until we get to the part
 			// of the tree we are interested in. Then return false so we stop
@@ -1271,15 +1323,15 @@ func (m *Model) Override(folder string) {
 
 	m.setState(folder, FolderScanning)
 	batch := make([]protocol.FileInfo, 0, indexBatchSize)
-	fs.WithNeed(protocol.LocalDeviceID, func(fi protocol.FileIntf) bool {
+	fs.WithNeed(protocol.LocalDeviceID, func(fi files.FileIntf) bool {
 		need := fi.(protocol.FileInfo)
 		if len(batch) == indexBatchSize {
 			fs.Update(protocol.LocalDeviceID, batch)
 			batch = batch[:0]
 		}
 
-		have := fs.Get(protocol.LocalDeviceID, need.Name)
-		if have.Name != need.Name {
+		have, ok := fs.Get(protocol.LocalDeviceID, need.Name)
+		if !ok || have.Name != need.Name {
 			// We are missing the file
 			need.Flags |= protocol.FlagDeleted
 			need.Blocks = nil
@@ -1336,9 +1388,9 @@ func (m *Model) RemoteLocalVersion(folder string) uint64 {
 	return ver
 }
 
-func (m *Model) availability(folder string, file string) []protocol.DeviceID {
+func (m *Model) availability(folder, file string) []protocol.DeviceID {
 	// Acquire this lock first, as the value returned from foldersFiles can
-	// gen heavily modified on Close()
+	// get heavily modified on Close()
 	m.pmut.RLock()
 	defer m.pmut.RUnlock()
 
@@ -1359,6 +1411,17 @@ func (m *Model) availability(folder string, file string) []protocol.DeviceID {
 	return availableDevices
 }
 
+// Bump the given files priority in the job queue
+func (m *Model) BringToFront(folder, file string) {
+	m.pmut.RLock()
+	defer m.pmut.RUnlock()
+
+	runner, ok := m.folderRunners[folder]
+	if ok {
+		runner.BringToFront(file)
+	}
+}
+
 func (m *Model) String() string {
 	return fmt.Sprintf("model@%p", m)
 }

internal/model/progressemitter_test.go

@@ -47,8 +47,6 @@ func expectTimeout(w *events.Subscription, t *testing.T) {
 }
 
 func TestProgressEmitter(t *testing.T) {
-	l.Debugln("test progress emitter")
-
 	w := events.Default.Subscribe(events.DownloadProgress)
 
 	c := config.Wrap("/tmp/test", config.Configuration{})

internal/model/puller.go

@@ -16,11 +16,10 @@
 package model
 
 import (
-	"bytes"
-	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io/ioutil"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"sync"
@@ -30,6 +29,7 @@ import (
 
 	"github.com/syncthing/syncthing/internal/config"
 	"github.com/syncthing/syncthing/internal/events"
+	"github.com/syncthing/syncthing/internal/files"
 	"github.com/syncthing/syncthing/internal/ignore"
 	"github.com/syncthing/syncthing/internal/osutil"
 	"github.com/syncthing/syncthing/internal/protocol"
@@ -77,7 +77,7 @@ type Puller struct {
 	progressEmitter *ProgressEmitter
 	copiers         int
 	pullers         int
-	finishers       int
+	queue           *jobQueue
 }
 
 // Serve will run scans and pulls. It will return when Stop()ed or on a
@@ -156,16 +156,10 @@ loop:
 			}
 			p.model.setState(p.folder, FolderSyncing)
 			tries := 0
-			checksum := false
 			for {
 				tries++
-				// Last resort mode, to get around corrupt/invalid block maps.
-				if tries == 10 {
-					l.Infoln("Desperation mode ON")
-					checksum = true
-				}
 
-				changed := p.pullerIteration(checksum, curIgnores)
+				changed := p.pullerIteration(curIgnores)
 				if debug {
 					l.Debugln(p, "changed", changed)
 				}
@@ -224,10 +218,14 @@ loop:
 			}
 			p.model.setState(p.folder, FolderIdle)
 			if p.scanIntv > 0 {
+				// Sleep a random time between 3/4 and 5/4 of the configured interval.
+				sleepNanos := (p.scanIntv.Nanoseconds()*3 + rand.Int63n(2*p.scanIntv.Nanoseconds())) / 4
+				intv := time.Duration(sleepNanos) * time.Nanosecond
+
 				if debug {
-					l.Debugln(p, "next rescan in", p.scanIntv)
+					l.Debugln(p, "next rescan in", intv)
 				}
-				scanTimer.Reset(p.scanIntv)
+				scanTimer.Reset(intv)
 			}
 			if !initialScanCompleted {
 				l.Infoln("Completed initial scan (rw) of folder", p.folder)
@@ -249,7 +247,7 @@ func (p *Puller) String() string {
 // returns the number items that should have been synced (even those that
 // might have failed). One puller iteration handles all files currently
 // flagged as needed in the folder.
-func (p *Puller) pullerIteration(checksum bool, ignores *ignore.Matcher) int {
+func (p *Puller) pullerIteration(ignores *ignore.Matcher) int {
 	pullChan := make(chan pullBlockState)
 	copyChan := make(chan copyBlocksState)
 	finisherChan := make(chan *sharedPullerState)
@@ -259,14 +257,14 @@ func (p *Puller) pullerIteration(checksum bool, ignores *ignore.Matcher) int {
 	var doneWg sync.WaitGroup
 
 	if debug {
-		l.Debugln(p, "c", p.copiers, "p", p.pullers, "f", p.finishers)
+		l.Debugln(p, "c", p.copiers, "p", p.pullers)
 	}
 
 	for i := 0; i < p.copiers; i++ {
 		copyWg.Add(1)
 		go func() {
 			// copierRoutine finishes when copyChan is closed
-			p.copierRoutine(copyChan, pullChan, finisherChan, checksum)
+			p.copierRoutine(copyChan, pullChan, finisherChan)
 			copyWg.Done()
 		}()
 	}
@@ -280,17 +278,15 @@ func (p *Puller) pullerIteration(checksum bool, ignores *ignore.Matcher) int {
 		}()
 	}
 
-	for i := 0; i < p.finishers; i++ {
-		doneWg.Add(1)
-		// finisherRoutine finishes when finisherChan is closed
-		go func() {
-			p.finisherRoutine(finisherChan)
-			doneWg.Done()
-		}()
-	}
+	doneWg.Add(1)
+	// finisherRoutine finishes when finisherChan is closed
+	go func() {
+		p.finisherRoutine(finisherChan)
+		doneWg.Done()
+	}()
 
 	p.model.fmut.RLock()
-	files := p.model.folderFiles[p.folder]
+	folderFiles := p.model.folderFiles[p.folder]
 	p.model.fmut.RUnlock()
 
 	// !!!
@@ -303,7 +299,7 @@ func (p *Puller) pullerIteration(checksum bool, ignores *ignore.Matcher) int {
 
 	var deletions []protocol.FileInfo
 
-	files.WithNeed(protocol.LocalDeviceID, func(intf protocol.FileIntf) bool {
+	folderFiles.WithNeed(protocol.LocalDeviceID, func(intf files.FileIntf) bool {
 
 		// Needed items are delivered sorted lexicographically. This isn't
 		// really optimal from a performance point of view - it would be
@@ -337,15 +333,27 @@ func (p *Puller) pullerIteration(checksum bool, ignores *ignore.Matcher) int {
 			p.handleDir(file)
 		default:
 			// A new or changed file or symlink. This is the only case where we
-			// do stuff in the background; the other three are done
-			// synchronously.
-			p.handleFile(file, copyChan, finisherChan)
+			// do stuff concurrently in the background
+			p.queue.Push(file.Name)
 		}
 
 		changed++
 		return true
 	})
 
+	for {
+		fileName, ok := p.queue.Pop()
+		if !ok {
+			break
+		}
+		if f, ok := p.model.CurrentGlobalFile(p.folder, fileName); ok {
+			p.handleFile(f, copyChan, finisherChan)
+		} else {
+			// File is no longer in the index. Mark it as done and drop it.
+			p.queue.Done(fileName)
+		}
+	}
+
 	// Signal copy and puller routines that we are done with the in data for
 	// this iteration. Wait for them to finish.
 	close(copyChan)
@@ -380,7 +388,7 @@ func (p *Puller) handleDir(file protocol.FileInfo) {
 	}
 
 	if debug {
-		curFile := p.model.CurrentFolderFile(p.folder, file.Name)
+		curFile, _ := p.model.CurrentFolderFile(p.folder, file.Name)
 		l.Debugf("need dir\n\t%v\n\t%v", file, curFile)
 	}
 
@@ -474,15 +482,16 @@ func (p *Puller) deleteFile(file protocol.FileInfo) {
 // handleFile queues the copies and pulls as necessary for a single new or
 // changed file.
 func (p *Puller) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocksState, finisherChan chan<- *sharedPullerState) {
-	curFile := p.model.CurrentFolderFile(p.folder, file.Name)
+	curFile, ok := p.model.CurrentFolderFile(p.folder, file.Name)
 
-	if len(curFile.Blocks) == len(file.Blocks) && scanner.BlocksEqual(curFile.Blocks, file.Blocks) {
+	if ok && len(curFile.Blocks) == len(file.Blocks) && scanner.BlocksEqual(curFile.Blocks, file.Blocks) {
 		// We are supposed to copy the entire file, and then fetch nothing. We
 		// are only updating metadata, so we don't actually *need* to make the
 		// copy.
 		if debug {
 			l.Debugln(p, "taking shortcut on", file.Name)
 		}
+		p.queue.Done(file.Name)
 		if file.IsSymlink() {
 			p.shortcutSymlink(curFile, file)
 		} else {
@@ -598,20 +607,20 @@ func (p *Puller) shortcutSymlink(curFile, file protocol.FileInfo) {
 
 // copierRoutine reads copierStates until the in channel closes and performs
 // the relevant copies when possible, or passes it to the puller routine.
-func (p *Puller) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState, checksum bool) {
+func (p *Puller) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState) {
 	buf := make([]byte, protocol.BlockSize)
 
-nextFile:
 	for state := range in {
+		if p.progressEmitter != nil {
+			p.progressEmitter.Register(state.sharedPullerState)
+		}
+
 		dstFd, err := state.tempFile()
 		if err != nil {
 			// Nothing more to do for this failed file (the error was logged
 			// when it happened)
-			continue nextFile
-		}
-
-		if p.progressEmitter != nil {
-			p.progressEmitter.Register(state.sharedPullerState)
+			out <- state.sharedPullerState
+			continue
 		}
 
 		evictionChan := make(chan lfu.Eviction)
@@ -634,7 +643,6 @@ nextFile:
 		}
 		p.model.fmut.RUnlock()
 
-		hasher := sha256.New()
 		for _, block := range state.blocks {
 			buf = buf[:int(block.Size)]
 			found := p.model.finder.Iterate(block.Hash, func(folder, file string, index uint32) bool {
@@ -658,12 +666,9 @@ nextFile:
 					return false
 				}
 
-				// Only done on second to last puller attempt
-				if checksum {
-					hasher.Write(buf)
-					hash := hasher.Sum(nil)
-					hasher.Reset()
-					if !bytes.Equal(hash, block.Hash) {
+				hash, err := scanner.VerifyBuffer(buf, block)
+				if err != nil {
+					if hash != nil {
 						if debug {
 							l.Debugf("Finder block mismatch in %s:%s:%d expected %q got %q", folder, file, index, block.Hash, hash)
 						}
@@ -671,13 +676,15 @@ nextFile:
 						if err != nil {
 							l.Warnln("finder fix:", err)
 						}
-						return false
+					} else if debug {
+						l.Debugln("Finder failed to verify buffer", err)
 					}
+					return false
 				}
 
 				_, err = dstFd.WriteAt(buf, block.Offset)
 				if err != nil {
-					state.earlyClose("dst write", err)
+					state.fail("dst write", err)
 				}
 				if file == state.file.Name {
 					state.copiedFromOrigin()
@@ -707,20 +714,9 @@ nextFile:
 }
 
 func (p *Puller) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPullerState) {
-nextBlock:
 	for state := range in {
 		if state.failed() != nil {
-			continue nextBlock
-		}
-
-		// Select the least busy device to pull the block from. If we found no
-		// feasible device at all, fail the block (and in the long run, the
-		// file).
-		potentialDevices := p.model.availability(p.folder, state.file.Name)
-		selected := activity.leastBusy(potentialDevices)
-		if selected == (protocol.DeviceID{}) {
-			state.earlyClose("pull", errNoDevice)
-			continue nextBlock
+			continue
 		}
 
 		// Get an fd to the temporary file. Tehcnically we don't need it until
@@ -728,45 +724,58 @@ nextBlock:
 		// no point in issuing the request to the network.
 		fd, err := state.tempFile()
 		if err != nil {
-			continue nextBlock
+			continue
 		}
 
-		// Fetch the block, while marking the selected device as in use so that
-		// leastBusy can select another device when someone else asks.
-		activity.using(selected)
-		buf, err := p.model.requestGlobal(selected, p.folder, state.file.Name, state.block.Offset, int(state.block.Size), state.block.Hash)
-		activity.done(selected)
-		if err != nil {
-			state.earlyClose("pull", err)
-			continue nextBlock
-		}
+		var lastError error
+		potentialDevices := p.model.availability(p.folder, state.file.Name)
+		for {
+			// Select the least busy device to pull the block from. If we found no
+			// feasible device at all, fail the block (and in the long run, the
+			// file).
+			selected := activity.leastBusy(potentialDevices)
+			if selected == (protocol.DeviceID{}) {
+				if lastError != nil {
+					state.fail("pull", lastError)
+				} else {
+					state.fail("pull", errNoDevice)
+				}
+				break
+			}
 
-		// Save the block data we got from the cluster
-		_, err = fd.WriteAt(buf, state.block.Offset)
-		if err != nil {
-			state.earlyClose("save", err)
-			continue nextBlock
-		}
+			potentialDevices = removeDevice(potentialDevices, selected)
 
-		state.pullDone()
+			// Fetch the block, while marking the selected device as in use so that
+			// leastBusy can select another device when someone else asks.
+			activity.using(selected)
+			buf, lastError := p.model.requestGlobal(selected, p.folder, state.file.Name, state.block.Offset, int(state.block.Size), state.block.Hash)
+			activity.done(selected)
+			if lastError != nil {
+				continue
+			}
+
+			// Verify that the received block matches the desired hash, if not
+			// try pulling it from another device.
+			_, lastError = scanner.VerifyBuffer(buf, state.block)
+			if lastError != nil {
+				continue
+			}
+
+			// Save the block data we got from the cluster
+			_, err = fd.WriteAt(buf, state.block.Offset)
+			if err != nil {
+				state.fail("save", err)
+			} else {
+				state.pullDone()
+			}
+			break
+		}
 		out <- state.sharedPullerState
 	}
 }
 
 func (p *Puller) performFinish(state *sharedPullerState) {
-	// Verify the file against expected hashes
-	fd, err := os.Open(state.tempName)
-	if err != nil {
-		l.Warnln("puller: final:", err)
-		return
-	}
-	err = scanner.Verify(fd, protocol.BlockSize, state.file.Blocks)
-	fd.Close()
-	if err != nil {
-		l.Infoln("puller:", state.file.Name, err, "(file changed during pull?)")
-		return
-	}
-
+	var err error
 	// Set the correct permission bits on the new file
 	if !p.ignorePerms {
 		err = os.Chmod(state.tempName, os.FileMode(state.file.Flags&0777))
@@ -850,7 +859,10 @@ func (p *Puller) finisherRoutine(in <-chan *sharedPullerState) {
 				continue
 			}
 
-			p.performFinish(state)
+			p.queue.Done(state.file.Name)
+			if state.failed() == nil {
+				p.performFinish(state)
+			}
 			p.model.receivedFile(p.folder, state.file.Name)
 			if p.progressEmitter != nil {
 				p.progressEmitter.Deregister(state)
@@ -859,6 +871,15 @@ func (p *Puller) finisherRoutine(in <-chan *sharedPullerState) {
 	}
 }
 
+// Moves the given filename to the front of the job queue
+func (p *Puller) BringToFront(filename string) {
+	p.queue.BringToFront(filename)
+}
+
+func (p *Puller) Jobs() ([]string, []string) {
+	return p.queue.Jobs()
+}
+
 func invalidateFolder(cfg *config.Configuration, folderID string, err error) {
 	for i := range cfg.Folders {
 		folder := &cfg.Folders[i]
@@ -868,3 +889,13 @@ func invalidateFolder(cfg *config.Configuration, folderID string, err error) {
 		}
 	}
 }
+
+func removeDevice(devices []protocol.DeviceID, device protocol.DeviceID) []protocol.DeviceID {
+	for i := range devices {
+		if devices[i] == device {
+			devices[i] = devices[len(devices)-1]
+			return devices[:len(devices)-1]
+		}
+	}
+	return devices
+}

internal/model/puller_test.go

@@ -221,7 +221,7 @@ func TestCopierFinder(t *testing.T) {
 	finisherChan := make(chan *sharedPullerState, 1)
 
 	// Run a single fetcher routine
-	go p.copierRoutine(copyChan, pullChan, finisherChan, false)
+	go p.copierRoutine(copyChan, pullChan, finisherChan)
 
 	p.handleFile(requiredFile, copyChan, finisherChan)
 
@@ -317,9 +317,8 @@ func TestCopierCleanup(t *testing.T) {
 	}
 }
 
-// On the 10th iteration, we start hashing the content which we receive by
-// following blockfinder's instructions. Make sure that the copier routine
-// hashes the content when asked, and pulls if it fails to find the block.
+// Make sure that the copier routine hashes the content when asked, and pulls
+// if it fails to find the block.
 func TestLastResortPulling(t *testing.T) {
 	fcfg := config.FolderConfiguration{ID: "default", Path: "testdata"}
 	cfg := config.Configuration{Folders: []config.FolderConfiguration{fcfg}}
@@ -361,8 +360,8 @@ func TestLastResortPulling(t *testing.T) {
 	pullChan := make(chan pullBlockState, 1)
 	finisherChan := make(chan *sharedPullerState, 1)
 
-	// Run a single copier routine with checksumming enabled
-	go p.copierRoutine(copyChan, pullChan, finisherChan, true)
+	// Run a single copier routine
+	go p.copierRoutine(copyChan, pullChan, finisherChan)
 
 	p.handleFile(file, copyChan, finisherChan)
 
@@ -383,3 +382,172 @@ func TestLastResortPulling(t *testing.T) {
 	(<-finisherChan).fd.Close()
 	os.Remove(filepath.Join("testdata", defTempNamer.TempName("newfile")))
 }
+
+func TestDeregisterOnFailInCopy(t *testing.T) {
+	file := protocol.FileInfo{
+		Name:     "filex",
+		Flags:    0,
+		Modified: 0,
+		Blocks: []protocol.BlockInfo{
+			blocks[0], blocks[2], blocks[0], blocks[0],
+			blocks[5], blocks[0], blocks[0], blocks[8],
+		},
+	}
+	defer os.Remove(defTempNamer.TempName("filex"))
+
+	db, _ := leveldb.Open(storage.NewMemStorage(), nil)
+	cw := config.Wrap("/tmp/test", config.Configuration{})
+	m := NewModel(cw, "device", "syncthing", "dev", db)
+	m.AddFolder(config.FolderConfiguration{ID: "default", Path: "testdata"})
+
+	emitter := NewProgressEmitter(cw)
+	go emitter.Serve()
+
+	p := Puller{
+		folder:          "default",
+		dir:             "testdata",
+		model:           m,
+		queue:           newJobQueue(),
+		progressEmitter: emitter,
+	}
+
+	// queue.Done should be called by the finisher routine
+	p.queue.Push("filex")
+	p.queue.Pop()
+
+	if len(p.queue.progress) != 1 {
+		t.Fatal("Expected file in progress")
+	}
+
+	copyChan := make(chan copyBlocksState)
+	pullChan := make(chan pullBlockState)
+	finisherBufferChan := make(chan *sharedPullerState)
+	finisherChan := make(chan *sharedPullerState)
+
+	go p.copierRoutine(copyChan, pullChan, finisherBufferChan)
+	go p.finisherRoutine(finisherChan)
+
+	p.handleFile(file, copyChan, finisherChan)
+
+	// Receive a block at puller, to indicate that atleast a single copier
+	// loop has been performed.
+	toPull := <-pullChan
+	// Wait until copier is trying to pass something down to the puller again
+	time.Sleep(100 * time.Millisecond)
+	// Close the file
+	toPull.sharedPullerState.fail("test", os.ErrNotExist)
+	// Unblock copier
+	<-pullChan
+
+	select {
+	case state := <-finisherBufferChan:
+		// At this point the file should still be registered with both the job
+		// queue, and the progress emitter. Verify this.
+		if len(p.progressEmitter.registry) != 1 || len(p.queue.progress) != 1 || len(p.queue.queued) != 0 {
+			t.Fatal("Could not find file")
+		}
+
+		// Pass the file down the real finisher, and give it time to consume
+		finisherChan <- state
+		time.Sleep(100 * time.Millisecond)
+
+		if state.fd != nil {
+			t.Fatal("File not closed?")
+		}
+
+		if len(p.progressEmitter.registry) != 0 || len(p.queue.progress) != 0 || len(p.queue.queued) != 0 {
+			t.Fatal("Still registered", len(p.progressEmitter.registry), len(p.queue.progress), len(p.queue.queued))
+		}
+
+		// Doing it again should have no effect
+		finisherChan <- state
+		time.Sleep(100 * time.Millisecond)
+
+		if len(p.progressEmitter.registry) != 0 || len(p.queue.progress) != 0 || len(p.queue.queued) != 0 {
+			t.Fatal("Still registered")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Didn't get anything to the finisher")
+	}
+}
+
+func TestDeregisterOnFailInPull(t *testing.T) {
+	file := protocol.FileInfo{
+		Name:     "filex",
+		Flags:    0,
+		Modified: 0,
+		Blocks: []protocol.BlockInfo{
+			blocks[0], blocks[2], blocks[0], blocks[0],
+			blocks[5], blocks[0], blocks[0], blocks[8],
+		},
+	}
+	defer os.Remove(defTempNamer.TempName("filex"))
+
+	db, _ := leveldb.Open(storage.NewMemStorage(), nil)
+	cw := config.Wrap("/tmp/test", config.Configuration{})
+	m := NewModel(cw, "device", "syncthing", "dev", db)
+	m.AddFolder(config.FolderConfiguration{ID: "default", Path: "testdata"})
+
+	emitter := NewProgressEmitter(cw)
+	go emitter.Serve()
+
+	p := Puller{
+		folder:          "default",
+		dir:             "testdata",
+		model:           m,
+		queue:           newJobQueue(),
+		progressEmitter: emitter,
+	}
+
+	// queue.Done should be called by the finisher routine
+	p.queue.Push("filex")
+	p.queue.Pop()
+
+	if len(p.queue.progress) != 1 {
+		t.Fatal("Expected file in progress")
+	}
+
+	copyChan := make(chan copyBlocksState)
+	pullChan := make(chan pullBlockState)
+	finisherBufferChan := make(chan *sharedPullerState)
+	finisherChan := make(chan *sharedPullerState)
+
+	go p.copierRoutine(copyChan, pullChan, finisherBufferChan)
+	go p.pullerRoutine(pullChan, finisherBufferChan)
+	go p.finisherRoutine(finisherChan)
+
+	p.handleFile(file, copyChan, finisherChan)
+
+	// Receove at finisher, we shoud error out as puller has nowhere to pull
+	// from.
+	select {
+	case state := <-finisherBufferChan:
+		// At this point the file should still be registered with both the job
+		// queue, and the progress emitter. Verify this.
+		if len(p.progressEmitter.registry) != 1 || len(p.queue.progress) != 1 || len(p.queue.queued) != 0 {
+			t.Fatal("Could not find file")
+		}
+
+		// Pass the file down the real finisher, and give it time to consume
+		finisherChan <- state
+		time.Sleep(100 * time.Millisecond)
+
+		if state.fd != nil {
+			t.Fatal("File not closed?")
+		}
+
+		if len(p.progressEmitter.registry) != 0 || len(p.queue.progress) != 0 || len(p.queue.queued) != 0 {
+			t.Fatal("Still registered", len(p.progressEmitter.registry), len(p.queue.progress), len(p.queue.queued))
+		}
+
+		// Doing it again should have no effect
+		finisherChan <- state
+		time.Sleep(100 * time.Millisecond)
+
+		if len(p.progressEmitter.registry) != 0 || len(p.queue.progress) != 0 || len(p.queue.queued) != 0 {
+			t.Fatal("Still registered")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("Didn't get anything to the finisher")
+	}
+}

internal/model/queue.go

@@ -0,0 +1,94 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package model
+
+import "sync"
+
+type jobQueue struct {
+	progress []string
+	queued   []string
+	mut      sync.Mutex
+}
+
+func newJobQueue() *jobQueue {
+	return &jobQueue{}
+}
+
+func (q *jobQueue) Push(file string) {
+	q.mut.Lock()
+	q.queued = append(q.queued, file)
+	q.mut.Unlock()
+}
+
+func (q *jobQueue) Pop() (string, bool) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	if len(q.queued) == 0 {
+		return "", false
+	}
+
+	var f string
+	f = q.queued[0]
+	q.queued = q.queued[1:]
+	q.progress = append(q.progress, f)
+
+	return f, true
+}
+
+func (q *jobQueue) BringToFront(filename string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	for i, cur := range q.queued {
+		if cur == filename {
+			if i > 0 {
+				// Shift the elements before the selected element one step to
+				// the right, overwriting the selected element
+				copy(q.queued[1:i+1], q.queued[0:])
+				// Put the selected element at the front
+				q.queued[0] = cur
+			}
+			return
+		}
+	}
+}
+
+func (q *jobQueue) Done(file string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	for i := range q.progress {
+		if q.progress[i] == file {
+			copy(q.progress[i:], q.progress[i+1:])
+			q.progress = q.progress[:len(q.progress)-1]
+			return
+		}
+	}
+}
+
+func (q *jobQueue) Jobs() ([]string, []string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	progress := make([]string, len(q.progress))
+	copy(progress, q.progress)
+
+	queued := make([]string, len(q.queued))
+	copy(queued, q.queued)
+
+	return progress, queued
+}

internal/model/queue_test.go

@@ -0,0 +1,200 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program 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 General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package model
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestJobQueue(t *testing.T) {
+	// Some random actions
+	q := newJobQueue()
+	q.Push("f1")
+	q.Push("f2")
+	q.Push("f3")
+	q.Push("f4")
+
+	progress, queued := q.Jobs()
+	if len(progress) != 0 || len(queued) != 4 {
+		t.Fatal("Wrong length")
+	}
+
+	for i := 1; i < 5; i++ {
+		n, ok := q.Pop()
+		if !ok || n != fmt.Sprintf("f%d", i) {
+			t.Fatal("Wrong element")
+		}
+		progress, queued = q.Jobs()
+		if len(progress) != 1 || len(queued) != 3 {
+			t.Log(progress)
+			t.Log(queued)
+			t.Fatal("Wrong length")
+		}
+
+		q.Done(n)
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 3 {
+			t.Fatal("Wrong length", len(progress), len(queued))
+		}
+
+		q.Push(n)
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 4 {
+			t.Fatal("Wrong length")
+		}
+
+		q.Done("f5") // Does not exist
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 4 {
+			t.Fatal("Wrong length")
+		}
+	}
+
+	if len(q.progress) > 0 || len(q.queued) != 4 {
+		t.Fatal("Wrong length")
+	}
+
+	for i := 4; i > 0; i-- {
+		progress, queued = q.Jobs()
+		if len(progress) != 4-i || len(queued) != i {
+			t.Fatal("Wrong length")
+		}
+
+		s := fmt.Sprintf("f%d", i)
+
+		q.BringToFront(s)
+		progress, queued = q.Jobs()
+		if len(progress) != 4-i || len(queued) != i {
+			t.Fatal("Wrong length")
+		}
+
+		n, ok := q.Pop()
+		if !ok || n != s {
+			t.Fatal("Wrong element")
+		}
+		progress, queued = q.Jobs()
+		if len(progress) != 5-i || len(queued) != i-1 {
+			t.Fatal("Wrong length")
+		}
+
+		q.Done("f5") // Does not exist
+		progress, queued = q.Jobs()
+		if len(progress) != 5-i || len(queued) != i-1 {
+			t.Fatal("Wrong length")
+		}
+	}
+
+	_, ok := q.Pop()
+	if len(q.progress) != 4 || ok {
+		t.Fatal("Wrong length")
+	}
+
+	q.Done("f1")
+	q.Done("f2")
+	q.Done("f3")
+	q.Done("f4")
+	q.Done("f5") // Does not exist
+
+	_, ok = q.Pop()
+	if len(q.progress) != 0 || ok {
+		t.Fatal("Wrong length")
+	}
+
+	progress, queued = q.Jobs()
+	if len(progress) != 0 || len(queued) != 0 {
+		t.Fatal("Wrong length")
+	}
+	q.BringToFront("")
+	q.Done("f5") // Does not exist
+	progress, queued = q.Jobs()
+	if len(progress) != 0 || len(queued) != 0 {
+		t.Fatal("Wrong length")
+	}
+}
+
+func TestBringToFront(t *testing.T) {
+	q := newJobQueue()
+	q.Push("f1")
+	q.Push("f2")
+	q.Push("f3")
+	q.Push("f4")
+
+	_, queued := q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f1", "f2", "f3", "f4"}) {
+		t.Errorf("Incorrect order %v at start", queued)
+	}
+
+	q.BringToFront("f1") // corner case: does nothing
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f1", "f2", "f3", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f3")
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f3", "f1", "f2", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f2")
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f2", "f3", "f1", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f4") // corner case: last element
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f4", "f2", "f3", "f1"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+}
+
+func BenchmarkJobQueueBump(b *testing.B) {
+	files := genFiles(b.N)
+
+	q := newJobQueue()
+	for _, f := range files {
+		q.Push(f.Name)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		q.BringToFront(files[i].Name)
+	}
+}
+
+func BenchmarkJobQueuePushPopDone10k(b *testing.B) {
+	files := genFiles(10000)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		q := newJobQueue()
+		for _, f := range files {
+			q.Push(f.Name)
+		}
+		for _ = range files {
+			n, _ := q.Pop()
+			q.Done(n)
+		}
+	}
+
+}

internal/model/scanner.go

@@ -17,6 +17,7 @@ package model
 
 import (
 	"fmt"
+	"math/rand"
 	"time"
 )
 
@@ -63,7 +64,9 @@ func (s *Scanner) Serve() {
 				return
 			}
 
-			timer.Reset(s.intv)
+			// Sleep a random time between 3/4 and 5/4 of the configured interval.
+			sleepNanos := (s.intv.Nanoseconds()*3 + rand.Int63n(2*s.intv.Nanoseconds())) / 4
+			timer.Reset(time.Duration(sleepNanos) * time.Nanosecond)
 		}
 	}
 }
@@ -75,3 +78,9 @@ func (s *Scanner) Stop() {
 func (s *Scanner) String() string {
 	return fmt.Sprintf("scanner/%s@%p", s.folder, s)
 }
+
+func (s *Scanner) BringToFront(string) {}
+
+func (s *Scanner) Jobs() ([]string, []string) {
+	return nil, nil
+}

internal/model/sharedpullerstate.go

@@ -21,6 +21,7 @@ import (
 	"path/filepath"
 	"sync"
 
+	"github.com/syncthing/syncthing/internal/files"
 	"github.com/syncthing/syncthing/internal/protocol"
 )
 
@@ -42,7 +43,6 @@ type sharedPullerState struct {
 	copyOrigin uint32     // Number of blocks copied from the original file
 	copyNeeded uint32     // Number of copy actions still pending
 	pullNeeded uint32     // Number of block pulls still pending
-	closed     bool       // Set when the file has been closed
 	mut        sync.Mutex // Protects the above
 }
 
@@ -92,7 +92,7 @@ func (s *sharedPullerState) tempFile() (io.WriterAt, error) {
 	// here.
 	dir := filepath.Dir(s.tempName)
 	if info, err := os.Stat(dir); err != nil {
-		s.earlyCloseLocked("dst stat dir", err)
+		s.failLocked("dst stat dir", err)
 		return nil, err
 	} else if info.Mode()&0200 == 0 {
 		err := os.Chmod(dir, 0755)
@@ -110,10 +110,21 @@ func (s *sharedPullerState) tempFile() (io.WriterAt, error) {
 	flags := os.O_WRONLY
 	if s.reused == 0 {
 		flags |= os.O_CREATE | os.O_EXCL
+	} else {
+		// With sufficiently bad luck when exiting or crashing, we may have
+		// had time to chmod the temp file to read only state but not yet
+		// moved it to it's final name. This leaves us with a read only temp
+		// file that we're going to try to reuse. To handle that, we need to
+		// make sure we have write permissions on the file before opening it.
+		err := os.Chmod(s.tempName, 0644)
+		if err != nil {
+			s.failLocked("dst create chmod", err)
+			return nil, err
+		}
 	}
 	fd, err := os.OpenFile(s.tempName, flags, 0644)
 	if err != nil {
-		s.earlyCloseLocked("dst create", err)
+		s.failLocked("dst create", err)
 		return nil, err
 	}
 
@@ -136,7 +147,7 @@ func (s *sharedPullerState) sourceFile() (*os.File, error) {
 	// Attempt to open the existing file
 	fd, err := os.Open(s.realName)
 	if err != nil {
-		s.earlyCloseLocked("src open", err)
+		s.failLocked("src open", err)
 		return nil, err
 	}
 
@@ -146,24 +157,20 @@ func (s *sharedPullerState) sourceFile() (*os.File, error) {
 // earlyClose prints a warning message composed of the context and
 // error, and marks the sharedPullerState as failed. Is a no-op when called on
 // an already failed state.
-func (s *sharedPullerState) earlyClose(context string, err error) {
+func (s *sharedPullerState) fail(context string, err error) {
 	s.mut.Lock()
 	defer s.mut.Unlock()
 
-	s.earlyCloseLocked(context, err)
+	s.failLocked(context, err)
 }
 
-func (s *sharedPullerState) earlyCloseLocked(context string, err error) {
+func (s *sharedPullerState) failLocked(context string, err error) {
 	if s.err != nil {
 		return
 	}
 
 	l.Infof("Puller (folder %q, file %q): %s: %v", s.folder, s.file.Name, context, err)
 	s.err = err
-	if s.fd != nil {
-		s.fd.Close()
-	}
-	s.closed = true
 }
 
 func (s *sharedPullerState) failed() error {
@@ -218,21 +225,16 @@ func (s *sharedPullerState) finalClose() (bool, error) {
 	s.mut.Lock()
 	defer s.mut.Unlock()
 
-	if s.pullNeeded+s.copyNeeded != 0 {
+	if s.pullNeeded+s.copyNeeded != 0 && s.err == nil {
 		// Not done yet.
 		return false, nil
 	}
-	if s.closed {
-		// Already handled.
-		return false, nil
-	}
 
-	s.closed = true
 	if fd := s.fd; fd != nil {
 		s.fd = nil
 		return true, fd.Close()
 	}
-	return true, nil
+	return false, nil
 }
 
 // Returns the momentarily progress for the puller
@@ -248,7 +250,7 @@ func (s *sharedPullerState) Progress() *pullerProgress {
 		CopiedFromElsewhere: s.copyTotal - s.copyNeeded - s.copyOrigin,
 		Pulled:              s.pullTotal - s.pullNeeded,
 		Pulling:             s.pullNeeded,
-		BytesTotal:          protocol.BlocksToSize(total),
-		BytesDone:           protocol.BlocksToSize(done),
+		BytesTotal:          files.BlocksToSize(total),
+		BytesDone:           files.BlocksToSize(done),
 	}
 }

internal/model/sharedpullerstate_test.go

@@ -86,5 +86,5 @@ func TestReadOnlyDir(t *testing.T) {
 		t.Fatal("Unexpected nil fd")
 	}
 
-	s.earlyClose("Test done", nil)
+	s.fail("Test done", nil)
 }

internal/osutil/osutil.go

@@ -43,8 +43,8 @@ func Rename(from, to string) error {
 
 	// Make sure the destination directory is writeable
 	toDir := filepath.Dir(to)
-	if info, err := os.Stat(toDir); err == nil {
-		os.Chmod(toDir, 0777)
+	if info, err := os.Stat(toDir); err == nil && info.IsDir() && info.Mode()&0200 == 0 {
+		os.Chmod(toDir, 0755)
 		defer os.Chmod(toDir, info.Mode())
 	}
 

internal/protocol/message.go

@@ -21,8 +21,10 @@ package protocol
 import "fmt"
 
 type IndexMessage struct {
-	Folder string // max:64
-	Files  []FileInfo
+	Folder  string // max:64
+	Files   []FileInfo
+	Flags   uint32
+	Options []Option // max:64
 }
 
 type FileInfo struct {
@@ -69,65 +71,6 @@ func (f FileInfo) HasPermissionBits() bool {
 	return f.Flags&FlagNoPermBits == 0
 }
 
-// Used for unmarshalling a FileInfo structure but skipping the actual block list
-type FileInfoTruncated struct {
-	Name         string // max:8192
-	Flags        uint32
-	Modified     int64
-	Version      uint64
-	LocalVersion uint64
-	NumBlocks    uint32
-}
-
-func (f FileInfoTruncated) String() string {
-	return fmt.Sprintf("File{Name:%q, Flags:0%o, Modified:%d, Version:%d, Size:%d, NumBlocks:%d}",
-		f.Name, f.Flags, f.Modified, f.Version, f.Size(), f.NumBlocks)
-}
-
-func BlocksToSize(num uint32) int64 {
-	if num < 2 {
-		return BlockSize / 2
-	}
-	return int64(num-1)*BlockSize + BlockSize/2
-}
-
-// Returns a statistical guess on the size, not the exact figure
-func (f FileInfoTruncated) Size() int64 {
-	if f.IsDeleted() || f.IsDirectory() {
-		return 128
-	}
-	return BlocksToSize(f.NumBlocks)
-}
-
-func (f FileInfoTruncated) IsDeleted() bool {
-	return f.Flags&FlagDeleted != 0
-}
-
-func (f FileInfoTruncated) IsInvalid() bool {
-	return f.Flags&FlagInvalid != 0
-}
-
-func (f FileInfoTruncated) IsDirectory() bool {
-	return f.Flags&FlagDirectory != 0
-}
-
-func (f FileInfoTruncated) IsSymlink() bool {
-	return f.Flags&FlagSymlink != 0
-}
-
-func (f FileInfoTruncated) HasPermissionBits() bool {
-	return f.Flags&FlagNoPermBits == 0
-}
-
-type FileIntf interface {
-	Size() int64
-	IsDeleted() bool
-	IsInvalid() bool
-	IsDirectory() bool
-	IsSymlink() bool
-	HasPermissionBits() bool
-}
-
 type BlockInfo struct {
 	Offset int64 // noencode (cache only)
 	Size   uint32
@@ -139,14 +82,18 @@ func (b BlockInfo) String() string {
 }
 
 type RequestMessage struct {
-	Folder string // max:64
-	Name   string // max:8192
-	Offset uint64
-	Size   uint32
+	Folder  string // max:64
+	Name    string // max:8192
+	Offset  uint64
+	Size    uint32
+	Hash    []byte // max:64
+	Flags   uint32
+	Options []Option // max:64
 }
 
 type ResponseMessage struct {
-	Data []byte
+	Data  []byte
+	Error uint32
 }
 
 type ClusterConfigMessage struct {
@@ -183,6 +130,7 @@ type Option struct {
 
 type CloseMessage struct {
 	Reason string // max:1024
+	Code   uint32
 }
 
 type EmptyMessage struct{}

internal/protocol/message_xdr.go

@@ -30,11 +30,21 @@ IndexMessage Structure:
 \               Zero or more FileInfo Structures                \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Flags                             |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                       Number of Options                       |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                Zero or more Option Structures                 \
+/                                                               /
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct IndexMessage {
 	string Folder<64>;
 	FileInfo Files<>;
+	unsigned int Flags;
+	Option Options<64>;
 }
 
 */
@@ -75,6 +85,17 @@ func (o IndexMessage) encodeXDR(xw *xdr.Writer) (int, error) {
 			return xw.Tot(), err
 		}
 	}
+	xw.WriteUint32(o.Flags)
+	if l := len(o.Options); l > 64 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Options", l, 64)
+	}
+	xw.WriteUint32(uint32(len(o.Options)))
+	for i := range o.Options {
+		_, err := o.Options[i].encodeXDR(xw)
+		if err != nil {
+			return xw.Tot(), err
+		}
+	}
 	return xw.Tot(), xw.Error()
 }
 
@@ -96,6 +117,15 @@ func (o *IndexMessage) decodeXDR(xr *xdr.Reader) error {
 	for i := range o.Files {
 		(&o.Files[i]).decodeXDR(xr)
 	}
+	o.Flags = xr.ReadUint32()
+	_OptionsSize := int(xr.ReadUint32())
+	if _OptionsSize > 64 {
+		return xdr.ElementSizeExceeded("Options", _OptionsSize, 64)
+	}
+	o.Options = make([]Option, _OptionsSize)
+	for i := range o.Options {
+		(&o.Options[i]).decodeXDR(xr)
+	}
 	return xr.Error()
 }
 
@@ -215,106 +245,6 @@ func (o *FileInfo) decodeXDR(xr *xdr.Reader) error {
 
 /*
 
-FileInfoTruncated Structure:
-
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                        Length of Name                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                    Name (variable length)                     \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                             Flags                             |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                      Modified (64 bits)                       +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                       Version (64 bits)                       +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                    Local Version (64 bits)                    +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                          Num Blocks                           |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-
-
-struct FileInfoTruncated {
-	string Name<8192>;
-	unsigned int Flags;
-	hyper Modified;
-	unsigned hyper Version;
-	unsigned hyper LocalVersion;
-	unsigned int NumBlocks;
-}
-
-*/
-
-func (o FileInfoTruncated) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.encodeXDR(xw)
-}
-
-func (o FileInfoTruncated) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
-}
-
-func (o FileInfoTruncated) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o FileInfoTruncated) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.encodeXDR(xw)
-	return []byte(aw), err
-}
-
-func (o FileInfoTruncated) encodeXDR(xw *xdr.Writer) (int, error) {
-	if l := len(o.Name); l > 8192 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Name", l, 8192)
-	}
-	xw.WriteString(o.Name)
-	xw.WriteUint32(o.Flags)
-	xw.WriteUint64(uint64(o.Modified))
-	xw.WriteUint64(o.Version)
-	xw.WriteUint64(o.LocalVersion)
-	xw.WriteUint32(o.NumBlocks)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *FileInfoTruncated) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.decodeXDR(xr)
-}
-
-func (o *FileInfoTruncated) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.decodeXDR(xr)
-}
-
-func (o *FileInfoTruncated) decodeXDR(xr *xdr.Reader) error {
-	o.Name = xr.ReadStringMax(8192)
-	o.Flags = xr.ReadUint32()
-	o.Modified = int64(xr.ReadUint64())
-	o.Version = xr.ReadUint64()
-	o.LocalVersion = xr.ReadUint64()
-	o.NumBlocks = xr.ReadUint32()
-	return xr.Error()
-}
-
-/*
-
 BlockInfo Structure:
 
  0                   1                   2                   3
@@ -412,6 +342,20 @@ RequestMessage Structure:
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                             Size                              |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                        Length of Hash                         |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                    Hash (variable length)                     \
+/                                                               /
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Flags                             |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                       Number of Options                       |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+/                                                               /
+\                Zero or more Option Structures                 \
+/                                                               /
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct RequestMessage {
@@ -419,6 +363,9 @@ struct RequestMessage {
 	string Name<8192>;
 	unsigned hyper Offset;
 	unsigned int Size;
+	opaque Hash<64>;
+	unsigned int Flags;
+	Option Options<64>;
 }
 
 */
@@ -458,6 +405,21 @@ func (o RequestMessage) encodeXDR(xw *xdr.Writer) (int, error) {
 	xw.WriteString(o.Name)
 	xw.WriteUint64(o.Offset)
 	xw.WriteUint32(o.Size)
+	if l := len(o.Hash); l > 64 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Hash", l, 64)
+	}
+	xw.WriteBytes(o.Hash)
+	xw.WriteUint32(o.Flags)
+	if l := len(o.Options); l > 64 {
+		return xw.Tot(), xdr.ElementSizeExceeded("Options", l, 64)
+	}
+	xw.WriteUint32(uint32(len(o.Options)))
+	for i := range o.Options {
+		_, err := o.Options[i].encodeXDR(xw)
+		if err != nil {
+			return xw.Tot(), err
+		}
+	}
 	return xw.Tot(), xw.Error()
 }
 
@@ -477,6 +439,16 @@ func (o *RequestMessage) decodeXDR(xr *xdr.Reader) error {
 	o.Name = xr.ReadStringMax(8192)
 	o.Offset = xr.ReadUint64()
 	o.Size = xr.ReadUint32()
+	o.Hash = xr.ReadBytesMax(64)
+	o.Flags = xr.ReadUint32()
+	_OptionsSize := int(xr.ReadUint32())
+	if _OptionsSize > 64 {
+		return xdr.ElementSizeExceeded("Options", _OptionsSize, 64)
+	}
+	o.Options = make([]Option, _OptionsSize)
+	for i := range o.Options {
+		(&o.Options[i]).decodeXDR(xr)
+	}
 	return xr.Error()
 }
 
@@ -493,10 +465,13 @@ ResponseMessage Structure:
 \                    Data (variable length)                     \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Error                             |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct ResponseMessage {
 	opaque Data<>;
+	unsigned int Error;
 }
 
 */
@@ -527,6 +502,7 @@ func (o ResponseMessage) AppendXDR(bs []byte) ([]byte, error) {
 
 func (o ResponseMessage) encodeXDR(xw *xdr.Writer) (int, error) {
 	xw.WriteBytes(o.Data)
+	xw.WriteUint32(o.Error)
 	return xw.Tot(), xw.Error()
 }
 
@@ -543,6 +519,7 @@ func (o *ResponseMessage) UnmarshalXDR(bs []byte) error {
 
 func (o *ResponseMessage) decodeXDR(xr *xdr.Reader) error {
 	o.Data = xr.ReadBytes()
+	o.Error = xr.ReadUint32()
 	return xr.Error()
 }
 
@@ -940,10 +917,13 @@ CloseMessage Structure:
 \                   Reason (variable length)                    \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                             Code                              |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct CloseMessage {
 	string Reason<1024>;
+	unsigned int Code;
 }
 
 */
@@ -977,6 +957,7 @@ func (o CloseMessage) encodeXDR(xw *xdr.Writer) (int, error) {
 		return xw.Tot(), xdr.ElementSizeExceeded("Reason", l, 1024)
 	}
 	xw.WriteString(o.Reason)
+	xw.WriteUint32(o.Code)
 	return xw.Tot(), xw.Error()
 }
 
@@ -993,6 +974,7 @@ func (o *CloseMessage) UnmarshalXDR(bs []byte) error {
 
 func (o *CloseMessage) decodeXDR(xr *xdr.Reader) error {
 	o.Reason = xr.ReadStringMax(1024)
+	o.Code = xr.ReadUint32()
 	return xr.Error()
 }
 

internal/protocol/protocol.go

@@ -71,6 +71,10 @@ var (
 	ErrClosed      = errors.New("connection closed")
 )
 
+// Specific variants of empty messages...
+type pingMessage struct{ EmptyMessage }
+type pongMessage struct{ EmptyMessage }
+
 type Model interface {
 	// An index was received from the peer device
 	Index(deviceID DeviceID, folder string, files []FileInfo)
@@ -133,6 +137,10 @@ type encodable interface {
 	AppendXDR([]byte) ([]byte, error)
 }
 
+type isEofer interface {
+	IsEOF() bool
+}
+
 const (
 	pingTimeout  = 30 * time.Second
 	pingIdleTime = 60 * time.Second
@@ -183,7 +191,10 @@ func (c *rawConnection) Index(folder string, idx []FileInfo) error {
 	default:
 	}
 	c.idxMut.Lock()
-	c.send(-1, messageTypeIndex, IndexMessage{folder, idx})
+	c.send(-1, messageTypeIndex, IndexMessage{
+		Folder: folder,
+		Files:  idx,
+	})
 	c.idxMut.Unlock()
 	return nil
 }
@@ -196,7 +207,10 @@ func (c *rawConnection) IndexUpdate(folder string, idx []FileInfo) error {
 	default:
 	}
 	c.idxMut.Lock()
-	c.send(-1, messageTypeIndexUpdate, IndexMessage{folder, idx})
+	c.send(-1, messageTypeIndexUpdate, IndexMessage{
+		Folder: folder,
+		Files:  idx,
+	})
 	c.idxMut.Unlock()
 	return nil
 }
@@ -218,7 +232,12 @@ func (c *rawConnection) Request(folder string, name string, offset int64, size i
 	c.awaiting[id] = rc
 	c.awaitingMut.Unlock()
 
-	ok := c.send(id, messageTypeRequest, RequestMessage{folder, name, uint64(offset), uint32(size)})
+	ok := c.send(id, messageTypeRequest, RequestMessage{
+		Folder: folder,
+		Name:   name,
+		Offset: uint64(offset),
+		Size:   uint32(size),
+	})
 	if !ok {
 		return nil, ErrClosed
 	}
@@ -274,48 +293,60 @@ func (c *rawConnection) readerLoop() (err error) {
 			return err
 		}
 
-		switch hdr.msgType {
-		case messageTypeIndex:
-			if c.state < stateCCRcvd {
-				return fmt.Errorf("protocol error: index message in state %d", c.state)
+		switch msg := msg.(type) {
+		case IndexMessage:
+			if msg.Flags != 0 {
+				// We don't currently support or expect any flags.
+				return fmt.Errorf("protocol error: unknown flags 0x%x in Index(Update) message", msg.Flags)
 			}
-			c.handleIndex(msg.(IndexMessage))
-			c.state = stateIdxRcvd
 
-		case messageTypeIndexUpdate:
-			if c.state < stateIdxRcvd {
-				return fmt.Errorf("protocol error: index update message in state %d", c.state)
+			switch hdr.msgType {
+			case messageTypeIndex:
+				if c.state < stateCCRcvd {
+					return fmt.Errorf("protocol error: index message in state %d", c.state)
+				}
+				c.handleIndex(msg)
+				c.state = stateIdxRcvd
+
+			case messageTypeIndexUpdate:
+				if c.state < stateIdxRcvd {
+					return fmt.Errorf("protocol error: index update message in state %d", c.state)
+				}
+				c.handleIndexUpdate(msg)
 			}
-			c.handleIndexUpdate(msg.(IndexMessage))
 
-		case messageTypeRequest:
+		case RequestMessage:
+			if msg.Flags != 0 {
+				// We don't currently support or expect any flags.
+				return fmt.Errorf("protocol error: unknown flags 0x%x in Request message", msg.Flags)
+			}
 			if c.state < stateIdxRcvd {
 				return fmt.Errorf("protocol error: request message in state %d", c.state)
 			}
 			// Requests are handled asynchronously
-			go c.handleRequest(hdr.msgID, msg.(RequestMessage))
+			go c.handleRequest(hdr.msgID, msg)
 
-		case messageTypeResponse:
+		case ResponseMessage:
 			if c.state < stateIdxRcvd {
 				return fmt.Errorf("protocol error: response message in state %d", c.state)
 			}
-			c.handleResponse(hdr.msgID, msg.(ResponseMessage))
+			c.handleResponse(hdr.msgID, msg)
 
-		case messageTypePing:
-			c.send(hdr.msgID, messageTypePong, EmptyMessage{})
+		case pingMessage:
+			c.send(hdr.msgID, messageTypePong, pongMessage{})
 
-		case messageTypePong:
+		case pongMessage:
 			c.handlePong(hdr.msgID)
 
-		case messageTypeClusterConfig:
+		case ClusterConfigMessage:
 			if c.state != stateInitial {
 				return fmt.Errorf("protocol error: cluster config message in state %d", c.state)
 			}
-			go c.receiver.ClusterConfig(c.id, msg.(ClusterConfigMessage))
+			go c.receiver.ClusterConfig(c.id, msg)
 			c.state = stateCCRcvd
 
-		case messageTypeClose:
-			return errors.New(msg.(CloseMessage).Reason)
+		case CloseMessage:
+			return errors.New(msg.Reason)
 
 		default:
 			return fmt.Errorf("protocol error: %s: unknown message type %#x", c.id, hdr.msgType)
@@ -341,6 +372,11 @@ func (c *rawConnection) readMessage() (hdr header, msg encodable, err error) {
 		l.Debugf("read header %v (msglen=%d)", hdr, msglen)
 	}
 
+	if hdr.version != 0 {
+		err = fmt.Errorf("unknown protocol version 0x%x", hdr.version)
+		return
+	}
+
 	if cap(c.rdbuf0) < msglen {
 		c.rdbuf0 = make([]byte, msglen)
 	} else {
@@ -376,33 +412,58 @@ func (c *rawConnection) readMessage() (hdr header, msg encodable, err error) {
 		}
 	}
 
+	// We check each returned error for the XDRError.IsEOF() method.
+	// IsEOF()==true here means that the message contained fewer fields than
+	// expected. It does not signify an EOF on the socket, because we've
+	// successfully read a size value and that many bytes already. New fields
+	// we expected but the other peer didn't send should be interpreted as
+	// zero/nil, and if that's not valid we'll verify it somewhere else.
+
 	switch hdr.msgType {
 	case messageTypeIndex, messageTypeIndexUpdate:
 		var idx IndexMessage
 		err = idx.UnmarshalXDR(msgBuf)
+		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
+			err = nil
+		}
 		msg = idx
 
 	case messageTypeRequest:
 		var req RequestMessage
 		err = req.UnmarshalXDR(msgBuf)
+		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
+			err = nil
+		}
 		msg = req
 
 	case messageTypeResponse:
 		var resp ResponseMessage
 		err = resp.UnmarshalXDR(msgBuf)
+		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
+			err = nil
+		}
 		msg = resp
 
-	case messageTypePing, messageTypePong:
-		msg = EmptyMessage{}
+	case messageTypePing:
+		msg = pingMessage{}
+
+	case messageTypePong:
+		msg = pongMessage{}
 
 	case messageTypeClusterConfig:
 		var cc ClusterConfigMessage
 		err = cc.UnmarshalXDR(msgBuf)
+		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
+			err = nil
+		}
 		msg = cc
 
 	case messageTypeClose:
 		var cm CloseMessage
 		err = cm.UnmarshalXDR(msgBuf)
+		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
+			err = nil
+		}
 		msg = cm
 
 	default:
@@ -429,7 +490,9 @@ func (c *rawConnection) handleIndexUpdate(im IndexMessage) {
 func (c *rawConnection) handleRequest(msgID int, req RequestMessage) {
 	data, _ := c.receiver.Request(c.id, req.Folder, req.Name, int64(req.Offset), int(req.Size))
 
-	c.send(msgID, messageTypeResponse, ResponseMessage{data})
+	c.send(msgID, messageTypeResponse, ResponseMessage{
+		Data: data,
+	})
 }
 
 func (c *rawConnection) handleResponse(msgID int, resp ResponseMessage) {

internal/protocol/protocol_test.go

@@ -189,7 +189,7 @@ func TestVersionErr(t *testing.T) {
 		msgID:   0,
 		msgType: 0,
 	}))
-	w.WriteUint32(0)
+	w.WriteUint32(0) // Avoids reader closing due to EOF
 
 	if !m1.isClosed() {
 		t.Error("Connection should close due to unknown version")
@@ -212,7 +212,7 @@ func TestTypeErr(t *testing.T) {
 		msgID:   0,
 		msgType: 42,
 	}))
-	w.WriteUint32(0)
+	w.WriteUint32(0) // Avoids reader closing due to EOF
 
 	if !m1.isClosed() {
 		t.Error("Connection should close due to unknown message type")

internal/scanner/blocks.go

@@ -130,6 +130,24 @@ func Verify(r io.Reader, blocksize int, blocks []protocol.BlockInfo) error {
 	return nil
 }
 
+func VerifyBuffer(buf []byte, block protocol.BlockInfo) ([]byte, error) {
+	if len(buf) != int(block.Size) {
+		return nil, fmt.Errorf("length mismatch %d != %d", len(buf), block.Size)
+	}
+	hf := sha256.New()
+	_, err := hf.Write(buf)
+	if err != nil {
+		return nil, err
+	}
+	hash := hf.Sum(nil)
+
+	if !bytes.Equal(hash, block.Hash) {
+		return hash, fmt.Errorf("hash mismatch %x != %x", hash, block.Hash)
+	}
+
+	return hash, nil
+}
+
 // BlockEqual returns whether two slices of blocks are exactly the same hash
 // and index pair wise.
 func BlocksEqual(src, tgt []protocol.BlockInfo) bool {

internal/scanner/walk.go

@@ -49,6 +49,8 @@ type Walker struct {
 	// detected. Scanned files will get zero permission bits and the
 	// NoPermissionBits flag set.
 	IgnorePerms bool
+	// Number of routines to use for hashing
+	Hashers int
 }
 
 type TempNamer interface {
@@ -60,7 +62,7 @@ type TempNamer interface {
 
 type CurrentFiler interface {
 	// CurrentFile returns the file as seen at last scan.
-	CurrentFile(name string) protocol.FileInfo
+	CurrentFile(name string) (protocol.FileInfo, bool)
 }
 
 // Walk returns the list of files found in the local folder by scanning the
@@ -75,9 +77,14 @@ func (w *Walker) Walk() (chan protocol.FileInfo, error) {
 		return nil, err
 	}
 
+	workers := w.Hashers
+	if workers < 1 {
+		workers = runtime.NumCPU()
+	}
+
 	files := make(chan protocol.FileInfo)
 	hashedFiles := make(chan protocol.FileInfo)
-	newParallelHasher(w.Dir, w.BlockSize, runtime.NumCPU(), hashedFiles, files)
+	newParallelHasher(w.Dir, w.BlockSize, workers, hashedFiles, files)
 
 	go func() {
 		hashFiles := w.walkAndHashFiles(files)
@@ -183,13 +190,14 @@ func (w *Walker) walkAndHashFiles(fchan chan protocol.FileInfo) filepath.WalkFun
 
 			if w.CurrentFiler != nil {
 				// A symlink is "unchanged", if
+				//  - it exists
 				//  - it wasn't deleted (because it isn't now)
 				//  - it was a symlink
 				//  - it wasn't invalid
 				//  - the symlink type (file/dir) was the same
 				//  - the block list (i.e. hash of target) was the same
-				cf := w.CurrentFiler.CurrentFile(rn)
-				if !cf.IsDeleted() && cf.IsSymlink() && !cf.IsInvalid() && SymlinkTypeEqual(flags, cf.Flags) && BlocksEqual(cf.Blocks, blocks) {
+				cf, ok := w.CurrentFiler.CurrentFile(rn)
+				if ok && !cf.IsDeleted() && cf.IsSymlink() && !cf.IsInvalid() && SymlinkTypeEqual(flags, cf.Flags) && BlocksEqual(cf.Blocks, blocks) {
 					return rval
 				}
 			}
@@ -214,14 +222,15 @@ func (w *Walker) walkAndHashFiles(fchan chan protocol.FileInfo) filepath.WalkFun
 		if info.Mode().IsDir() {
 			if w.CurrentFiler != nil {
 				// A directory is "unchanged", if it
+				//  - exists
 				//  - has the same permissions as previously, unless we are ignoring permissions
 				//  - was not marked deleted (since it apparently exists now)
 				//  - was a directory previously (not a file or something else)
 				//  - was not a symlink (since it's a directory now)
 				//  - was not invalid (since it looks valid now)
-				cf := w.CurrentFiler.CurrentFile(rn)
+				cf, ok := w.CurrentFiler.CurrentFile(rn)
 				permUnchanged := w.IgnorePerms || !cf.HasPermissionBits() || PermsEqual(cf.Flags, uint32(info.Mode()))
-				if permUnchanged && !cf.IsDeleted() && cf.IsDirectory() && !cf.IsSymlink() && !cf.IsInvalid() {
+				if ok && permUnchanged && !cf.IsDeleted() && cf.IsDirectory() && !cf.IsSymlink() && !cf.IsInvalid() {
 					return nil
 				}
 			}
@@ -248,15 +257,18 @@ func (w *Walker) walkAndHashFiles(fchan chan protocol.FileInfo) filepath.WalkFun
 		if info.Mode().IsRegular() {
 			if w.CurrentFiler != nil {
 				// A file is "unchanged", if it
+				//  - exists
 				//  - has the same permissions as previously, unless we are ignoring permissions
 				//  - was not marked deleted (since it apparently exists now)
 				//  - had the same modification time as it has now
 				//  - was not a directory previously (since it's a file now)
 				//  - was not a symlink (since it's a file now)
 				//  - was not invalid (since it looks valid now)
-				cf := w.CurrentFiler.CurrentFile(rn)
+				//  - has the same size as previously
+				cf, ok := w.CurrentFiler.CurrentFile(rn)
 				permUnchanged := w.IgnorePerms || !cf.HasPermissionBits() || PermsEqual(cf.Flags, uint32(info.Mode()))
-				if permUnchanged && !cf.IsDeleted() && cf.Modified == info.ModTime().Unix() && !cf.IsDirectory() && !cf.IsSymlink() && !cf.IsInvalid() {
+				if ok && permUnchanged && !cf.IsDeleted() && cf.Modified == info.ModTime().Unix() && !cf.IsDirectory() &&
+					!cf.IsSymlink() && !cf.IsInvalid() && cf.Size() == info.Size() {
 					return nil
 				}
 

internal/upgrade/releasename_darwin.go

@@ -1,25 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This program is free software: you can redistribute it and/or modify it
-// under the terms of the GNU General Public License as published by the Free
-// Software Foundation, either version 3 of the License, or (at your option)
-// any later version.
-//
-// This program 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 General Public License for
-// more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program. If not, see <http://www.gnu.org/licenses/>.
-
-package upgrade
-
-import (
-	"fmt"
-	"runtime"
-)
-
-func releaseName(tag string) string {
-	return fmt.Sprintf("syncthing-macosx-%s-%s.", runtime.GOARCH, tag)
-}

internal/upgrade/releasename_linux_arm.go

@@ -1,38 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This program is free software: you can redistribute it and/or modify it
-// under the terms of the GNU General Public License as published by the Free
-// Software Foundation, either version 3 of the License, or (at your option)
-// any later version.
-//
-// This program 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 General Public License for
-// more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program. If not, see <http://www.gnu.org/licenses/>.
-
-package upgrade
-
-import (
-	"fmt"
-	"strings"
-	"syscall"
-)
-
-func releaseName(tag string) string {
-	return fmt.Sprintf("syncthing-linux-armv%s-%s.", goARM(), tag)
-}
-
-// Get the current ARM architecture version for upgrade purposes. If we can't
-// figure it out from the uname, default to ARMv6 (same as Go distribution).
-func goARM() string {
-	var name syscall.Utsname
-	syscall.Uname(&name)
-	machine := string(name.Machine[:5])
-	if strings.HasPrefix(machine, "armv") {
-		return machine[4:]
-	}
-	return "6"
-}

internal/upgrade/releasename_other.go

@@ -1,27 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This program is free software: you can redistribute it and/or modify it
-// under the terms of the GNU General Public License as published by the Free
-// Software Foundation, either version 3 of the License, or (at your option)
-// any later version.
-//
-// This program 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 General Public License for
-// more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program. If not, see <http://www.gnu.org/licenses/>.
-
-// +build !arm,!darwin
-
-package upgrade
-
-import (
-	"fmt"
-	"runtime"
-)
-
-func releaseName(tag string) string {
-	return fmt.Sprintf("syncthing-%s-%s-%s.", runtime.GOOS, runtime.GOARCH, tag)
-}

internal/upgrade/upgrade_common.go

@@ -18,6 +18,8 @@ package upgrade
 
 import (
 	"errors"
+	"fmt"
+	"runtime"
 	"strconv"
 	"strings"
 
@@ -87,8 +89,18 @@ func ToURL(url string) error {
 	}
 }
 
-// Returns 1 if a>b, -1 if a<b and 0 if they are equal
-func CompareVersions(a, b string) int {
+type Relation int
+
+const (
+	MajorOlder Relation = -2 // Older by a major version (x in x.y.z or 0.x.y).
+	Older               = -1 // Older by a minor version (y or z in x.y.z, or y in 0.x.y)
+	Equal               = 0  // Versions are semantically equal
+	Newer               = 1  // Newer by a minor version (y or z in x.y.z, or y in 0.x.y)
+	MajorNewer          = 2  // Newer by a major version (x in x.y.z or 0.x.y).
+)
+
+// Returns a relation describing how a compares to b.
+func CompareVersions(a, b string) Relation {
 	arel, apre := versionParts(a)
 	brel, bpre := versionParts(b)
 
@@ -100,27 +112,39 @@ func CompareVersions(a, b string) int {
 	// First compare major-minor-patch versions
 	for i := 0; i < minlen; i++ {
 		if arel[i] < brel[i] {
-			return -1
+			if i == 0 {
+				return MajorOlder
+			}
+			if i == 1 && arel[0] == 0 {
+				return MajorOlder
+			}
+			return Older
 		}
 		if arel[i] > brel[i] {
-			return 1
+			if i == 0 {
+				return MajorNewer
+			}
+			if i == 1 && arel[0] == 0 {
+				return MajorNewer
+			}
+			return Newer
 		}
 	}
 
 	// Longer version is newer, when the preceding parts are equal
 	if len(arel) < len(brel) {
-		return -1
+		return Older
 	}
 	if len(arel) > len(brel) {
-		return 1
+		return Newer
 	}
 
 	// Prerelease versions are older, if the versions are the same
 	if len(apre) == 0 && len(bpre) > 0 {
-		return 1
+		return Newer
 	}
 	if len(apre) > 0 && len(bpre) == 0 {
-		return -1
+		return Older
 	}
 
 	minlen = len(apre)
@@ -135,24 +159,24 @@ func CompareVersions(a, b string) int {
 			switch bv := bpre[i].(type) {
 			case int:
 				if av < bv {
-					return -1
+					return Older
 				}
 				if av > bv {
-					return 1
+					return Newer
 				}
 			case string:
-				return -1
+				return Older
 			}
 		case string:
 			switch bv := bpre[i].(type) {
 			case int:
-				return 1
+				return Newer
 			case string:
 				if av < bv {
-					return -1
+					return Older
 				}
 				if av > bv {
-					return 1
+					return Newer
 				}
 			}
 		}
@@ -160,14 +184,14 @@ func CompareVersions(a, b string) int {
 
 	// If all else is equal, longer prerelease string is newer
 	if len(apre) < len(bpre) {
-		return -1
+		return Older
 	}
 	if len(apre) > len(bpre) {
-		return 1
+		return Newer
 	}
 
 	// Looks like they're actually the same
-	return 0
+	return Equal
 }
 
 // Split a version into parts.
@@ -203,3 +227,12 @@ func versionParts(v string) ([]int, []interface{}) {
 
 	return release, prerelease
 }
+
+func releaseName(tag string) string {
+	switch runtime.GOOS {
+	case "darwin":
+		return fmt.Sprintf("syncthing-macosx-%s-%s.", runtime.GOARCH, tag)
+	default:
+		return fmt.Sprintf("syncthing-%s-%s-%s.", runtime.GOOS, runtime.GOARCH, tag)
+	}
+}

internal/upgrade/upgrade_supported.go

@@ -80,7 +80,7 @@ func upgradeTo(binary string, rel Release) error {
 		}
 
 		if strings.HasPrefix(assetName, expectedRelease) {
-			upgradeToURL(binary, asset.URL)
+			return upgradeToURL(binary, asset.URL)
 		}
 	}
 

internal/upgrade/upgrade_test.go

@@ -19,33 +19,37 @@ import "testing"
 
 var testcases = []struct {
 	a, b string
-	r    int
+	r    Relation
 }{
-	{"0.1.2", "0.1.2", 0},
-	{"0.1.3", "0.1.2", 1},
-	{"0.1.1", "0.1.2", -1},
-	{"0.3.0", "0.1.2", 1},
-	{"0.0.9", "0.1.2", -1},
-	{"1.1.2", "0.1.2", 1},
-	{"0.1.2", "1.1.2", -1},
-	{"0.1.10", "0.1.9", 1},
-	{"0.10.0", "0.2.0", 1},
-	{"30.10.0", "4.9.0", 1},
-	{"0.9.0-beta7", "0.9.0-beta6", 1},
-	{"1.0.0-alpha", "1.0.0-alpha.1", -1},
-	{"1.0.0-alpha.1", "1.0.0-alpha.beta", -1},
-	{"1.0.0-alpha.beta", "1.0.0-beta", -1},
-	{"1.0.0-beta", "1.0.0-beta.2", -1},
-	{"1.0.0-beta.2", "1.0.0-beta.11", -1},
-	{"1.0.0-beta.11", "1.0.0-rc.1", -1},
-	{"1.0.0-rc.1", "1.0.0", -1},
-	{"1.0.0+45", "1.0.0+23-dev-foo", 0},
-	{"1.0.0-beta.23+45", "1.0.0-beta.23+23-dev-foo", 0},
-	{"1.0.0-beta.3+99", "1.0.0-beta.24+0", -1},
+	{"0.1.2", "0.1.2", Equal},
+	{"0.1.3", "0.1.2", Newer},
+	{"0.1.1", "0.1.2", Older},
+	{"0.3.0", "0.1.2", MajorNewer},
+	{"0.0.9", "0.1.2", MajorOlder},
+	{"1.3.0", "1.1.2", Newer},
+	{"1.0.9", "1.1.2", Older},
+	{"2.3.0", "1.1.2", MajorNewer},
+	{"1.0.9", "2.1.2", MajorOlder},
+	{"1.1.2", "0.1.2", MajorNewer},
+	{"0.1.2", "1.1.2", MajorOlder},
+	{"0.1.10", "0.1.9", Newer},
+	{"0.10.0", "0.2.0", MajorNewer},
+	{"30.10.0", "4.9.0", MajorNewer},
+	{"0.9.0-beta7", "0.9.0-beta6", Newer},
+	{"1.0.0-alpha", "1.0.0-alpha.1", Older},
+	{"1.0.0-alpha.1", "1.0.0-alpha.beta", Older},
+	{"1.0.0-alpha.beta", "1.0.0-beta", Older},
+	{"1.0.0-beta", "1.0.0-beta.2", Older},
+	{"1.0.0-beta.2", "1.0.0-beta.11", Older},
+	{"1.0.0-beta.11", "1.0.0-rc.1", Older},
+	{"1.0.0-rc.1", "1.0.0", Older},
+	{"1.0.0+45", "1.0.0+23-dev-foo", Equal},
+	{"1.0.0-beta.23+45", "1.0.0-beta.23+23-dev-foo", Equal},
+	{"1.0.0-beta.3+99", "1.0.0-beta.24+0", Older},
 
-	{"v1.1.2", "1.1.2", 0},
-	{"v1.1.2", "V1.1.2", 0},
-	{"1.1.2", "V1.1.2", 0},
+	{"v1.1.2", "1.1.2", Equal},
+	{"v1.1.2", "V1.1.2", Equal},
+	{"1.1.2", "V1.1.2", Equal},
 }
 
 func TestCompareVersions(t *testing.T) {

internal/upnp/upnp.go

@@ -158,7 +158,7 @@ Mx: %d
 	var results []IGD
 	resultChannel := make(chan IGD, 8)
 
-	socket, err := net.ListenUDP("udp4", &net.UDPAddr{})
+	socket, err := net.ListenMulticastUDP("udp4", nil, &net.UDPAddr{IP: ssdp.IP})
 	if err != nil {
 		l.Infoln(err)
 		return results
@@ -448,19 +448,27 @@ func getIGDServices(rootURL string, device upnpDevice, wanDeviceURN string, wanC
 }
 
 func replaceRawPath(u *url.URL, rp string) {
-	var p, q string
-	fs := strings.Split(rp, "?")
-	p = fs[0]
-	if len(fs) > 1 {
-		q = fs[1]
-	}
-
-	if p[0] == '/' {
-		u.Path = p
+	asURL, err := url.Parse(rp)
+	if err != nil {
+		return
+	} else if asURL.IsAbs() {
+		u.Path = asURL.Path
+		u.RawQuery = asURL.RawQuery
 	} else {
-		u.Path += p
+		var p, q string
+		fs := strings.Split(rp, "?")
+		p = fs[0]
+		if len(fs) > 1 {
+			q = fs[1]
+		}
+
+		if p[0] == '/' {
+			u.Path = p
+		} else {
+			u.Path += p
+		}
+		u.RawQuery = q
 	}
-	u.RawQuery = q
 }
 
 func soapRequest(url, service, function, message string) ([]byte, error) {

internal/upnp/upnp_test.go

@@ -17,6 +17,7 @@ package upnp
 
 import (
 	"encoding/xml"
+	"net/url"
 	"testing"
 )
 
@@ -40,3 +41,25 @@ func TestExternalIPParsing(t *testing.T) {
 		t.Error("Parse of SOAP request failed.")
 	}
 }
+
+func TestControlURLParsing(t *testing.T) {
+	rootURL := "http://192.168.243.1:80/igd.xml"
+
+	u, _ := url.Parse(rootURL)
+	subject := "/upnp?control=WANCommonIFC1"
+	expected := "http://192.168.243.1:80/upnp?control=WANCommonIFC1"
+	replaceRawPath(u, subject)
+
+	if u.String() != expected {
+		t.Error("URL normalization of", subject, "failed; expected", expected, "got", u.String())
+	}
+
+	u, _ = url.Parse(rootURL)
+	subject = "http://192.168.243.1:80/upnp?control=WANCommonIFC1"
+	expected = "http://192.168.243.1:80/upnp?control=WANCommonIFC1"
+	replaceRawPath(u, subject)
+
+	if u.String() != expected {
+		t.Error("URL normalization of", subject, "failed; expected", expected, "got", u.String())
+	}
+}

internal/versioner/staggered.go

@@ -232,7 +232,9 @@ func (v Staggered) expire(versions []string) {
 
 		versionTime, err := time.Parse(TimeFormat, filenameTag(file))
 		if err != nil {
-			l.Infof("Versioner: file name %q is invalid: %v", file, err)
+			if debug {
+				l.Debugf("Versioner: file name %q is invalid: %v", file, err)
+			}
 			continue
 		}
 		age := int64(time.Since(versionTime).Seconds())

protocol/README.md

@@ -1,2 +1,2 @@
 Syncthing uses the protocols defined in
-https://github.com/syncthing/protocol/.
+https://github.com/syncthing/specs/.

test/cli_test.go

@@ -20,6 +20,7 @@ package integration
 import (
 	"os"
 	"os/exec"
+	"path/filepath"
 	"testing"
 	"time"
 )
@@ -54,6 +55,14 @@ func TestCLIReset(t *testing.T) {
 			t.Errorf("%s still exists", dir)
 		}
 	}
+
+	// Clean up
+
+	dirs, err = filepath.Glob("*.syncthing-reset-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	removeAll(dirs...)
 }
 
 func TestCLIGenerate(t *testing.T) {

test/filetype_test.go

@@ -101,10 +101,10 @@ func testFileTypeChange(t *testing.T) {
 	log.Println("Syncing...")
 
 	sender := syncthingProcess{ // id1
-		log:    "1.out",
-		argv:   []string{"-home", "h1"},
-		port:   8081,
-		apiKey: apiKey,
+		instance: "1",
+		argv:     []string{"-home", "h1"},
+		port:     8081,
+		apiKey:   apiKey,
 	}
 	err = sender.start()
 	if err != nil {
@@ -112,10 +112,10 @@ func testFileTypeChange(t *testing.T) {
 	}
 
 	receiver := syncthingProcess{ // id2
-		log:    "2.out",
-		argv:   []string{"-home", "h2"},
-		port:   8082,
-		apiKey: apiKey,
+		instance: "2",
+		argv:     []string{"-home", "h2"},
+		port:     8082,
+		apiKey:   apiKey,
 	}
 	err = receiver.start()
 	if err != nil {

test/http_test.go

@@ -41,9 +41,9 @@ var jsonEndpoints = []string{
 
 func TestGetIndex(t *testing.T) {
 	st := syncthingProcess{
-		argv: []string{"-home", "h2"},
-		port: 8082,
-		log:  "2.out",
+		argv:     []string{"-home", "h2"},
+		port:     8082,
+		instance: "2",
 	}
 	err := st.start()
 	if err != nil {
@@ -84,9 +84,9 @@ func TestGetIndex(t *testing.T) {
 
 func TestGetIndexAuth(t *testing.T) {
 	st := syncthingProcess{
-		argv: []string{"-home", "h1"},
-		port: 8081,
-		log:  "1.out",
+		argv:     []string{"-home", "h1"},
+		port:     8081,
+		instance: "1",
 	}
 	err := st.start()
 	if err != nil {
@@ -142,9 +142,9 @@ func TestGetIndexAuth(t *testing.T) {
 
 func TestGetJSON(t *testing.T) {
 	st := syncthingProcess{
-		argv: []string{"-home", "h2"},
-		port: 8082,
-		log:  "2.out",
+		argv:     []string{"-home", "h2"},
+		port:     8082,
+		instance: "2",
 	}
 	err := st.start()
 	if err != nil {
@@ -174,9 +174,9 @@ func TestGetJSON(t *testing.T) {
 
 func TestPOSTWithoutCSRF(t *testing.T) {
 	st := syncthingProcess{
-		argv: []string{"-home", "h2"},
-		port: 8082,
-		log:  "2.out",
+		argv:     []string{"-home", "h2"},
+		port:     8082,
+		instance: "2",
 	}
 	err := st.start()
 	if err != nil {