Revert "Merge pull request #2440 from Stefan-Code/master"

This reverts commit 81bc6bf34b, reversing
changes made to 7de736e8d0.

Unfortunately this tricks the upgrade system into picking the wrong
binary. We need to fix the upgrade system before merging this.

AUTHORS

@@ -36,6 +36,7 @@ Frank Isemann <frank@isemann.name>
 Gilli Sigurdsson <gilli@vx.is>
 Jacek Szafarkiewicz <szafar@linux.pl>
 Jakob Borg <jakob@nym.se>
+Jake Peterson <jake@acogdev.com>
 James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
 Jaroslav Malec <dzardacz@gmail.com>
 Jens Diemer <github.com@jensdiemer.de> <git@jensdiemer.de>
@@ -48,8 +49,8 @@ Lord Landon Agahnim <lordlandon@gmail.com>
 Marc Laporte <marc@marclaporte.com> <marc@laporte.name>
 Marc Pujol <kilburn@la3.org>
 Marcin Dziadus <dziadus.marcin@gmail.com>
-Mateon1 <matin1111@wp.pl>
-Matt Burke <mburke@amplify.com>
+Mateusz Naściszewski <matin1111@wp.pl>
+Matt Burke <mburke@amplify.com> <burkemw3@gmail.com>
 Michael Jephcote <rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
 Michael Tilli <pyfisch@gmail.com>
 Pascal Jungblut <github@pascalj.com> <mail@pascal-jungblut.com>
@@ -60,9 +61,11 @@ Piotr Bejda <piotrb10@gmail.com>
 Ryan Sullivan <kayoticsully@gmail.com>
 Sergey Mishin <ralder@yandex.ru>
 Stefan Tatschner <stefan@sevenbyte.org> <rumpelsepp@sevenbyte.org>
+Stefan Kuntz <stefan.github@gmail.com> <Stefan.github@gmail.com>
 Tim Abell <tim@timwise.co.uk>
 Tobias Nygren <tnn@nygren.pp.se>
 Tomas Cerveny <kozec@kozec.com>
 Tully Robinson <tully@tojr.org>
 Veeti Paananen <veeti.paananen@rojekti.fi>
 Vil Brekin <vilbrekin@gmail.com>
+Yannic A. <eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>

Godeps/Godeps.json

@@ -19,7 +19,7 @@
 		},
 		{
 			"ImportPath": "github.com/calmh/xdr",
-			"Rev": "5f7208e86762911861c94f1849eddbfc0a60cbf0"
+			"Rev": "47c0042d09a827b81ee62497f99e5e0c7f0bd31c"
 		},
 		{
 			"ImportPath": "github.com/golang/snappy",
@@ -64,11 +64,15 @@
 		},
 		{
 			"ImportPath": "golang.org/x/net/internal/iana",
-			"Rev": "db8e4de5b2d6653f66aea53094624468caad15d2"
+			"Rev": "4b709d93778b93d2f34943e3142c71578d83ad31"
 		},
 		{
 			"ImportPath": "golang.org/x/net/ipv6",
-			"Rev": "db8e4de5b2d6653f66aea53094624468caad15d2"
+			"Rev": "4b709d93778b93d2f34943e3142c71578d83ad31"
+		},
+		{
+			"ImportPath": "golang.org/x/net/proxy",
+			"Rev": "4b709d93778b93d2f34943e3142c71578d83ad31"
 		},
 		{
 			"ImportPath": "golang.org/x/text/transform",

Godeps/_workspace/src/github.com/calmh/xdr/.travis.yml

@@ -4,7 +4,7 @@ go:
 
 install:
 - export PATH=$PATH:$HOME/gopath/bin
-- go get code.google.com/p/go.tools/cmd/cover
+- go get golang.org/x/tools/cover
 - go get github.com/mattn/goveralls
 
 script:

Godeps/_workspace/src/github.com/calmh/xdr/README.md

@@ -1,7 +1,7 @@
 xdr
 ===
 
-[![Build Status](https://img.shields.io/travis/calmh/xdr.svg?style=flat)](https://travis-ci.org/calmh/xdr)
+[![Build Status](https://img.shields.io/circleci/project/calmh/xdr.svg?style=flat-square)](https://circleci.com/gh/calmh/xdr)
 [![Coverage Status](https://img.shields.io/coveralls/calmh/xdr.svg?style=flat)](https://coveralls.io/r/calmh/xdr?branch=master)
 [![API Documentation](http://img.shields.io/badge/api-Godoc-blue.svg?style=flat)](http://godoc.org/github.com/calmh/xdr)
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://opensource.org/licenses/MIT)

Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go

@@ -28,6 +28,7 @@ type fieldInfo struct {
 	Encoder   string // the encoder name, i.e. "Uint64" for Read/WriteUint64
 	Convert   string // what to convert to when encoding, i.e. "uint64"
 	Max       int    // max size for slices and strings
+	Submax    int    // max size for strings inside slices
 }
 
 type structInfo struct {
@@ -156,7 +157,11 @@ func (o *{{.TypeName}}) DecodeXDRFrom(xr *xdr.Reader) error {
 				{{if ne $fieldInfo.Convert ""}}
 					o.{{$fieldInfo.Name}}[i] = {{$fieldInfo.FieldType}}(xr.Read{{$fieldInfo.Encoder}}())
 				{{else if $fieldInfo.IsBasic}}
-					o.{{$fieldInfo.Name}}[i] = xr.Read{{$fieldInfo.Encoder}}()
+					{{if ge $fieldInfo.Submax 1}}
+						o.{{$fieldInfo.Name}}[i] = xr.Read{{$fieldInfo.Encoder}}Max({{$fieldInfo.Submax}})
+					{{else}}
+						o.{{$fieldInfo.Name}}[i] = xr.Read{{$fieldInfo.Encoder}}()
+					{{end}}
 				{{else}}
 					(&o.{{$fieldInfo.Name}}[i]).DecodeXDRFrom(xr)
 				{{end}}
@@ -166,7 +171,7 @@ func (o *{{.TypeName}}) DecodeXDRFrom(xr *xdr.Reader) error {
 	return xr.Error()
 }`))
 
-var maxRe = regexp.MustCompile(`\Wmax:(\d+)`)
+var maxRe = regexp.MustCompile(`(?:\Wmax:)(\d+)(?:\s*,\s*(\d+))?`)
 
 type typeSet struct {
 	Type    string
@@ -198,11 +203,15 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 		}
 
 		fn := sf.Names[0].Name
-		var max = 0
+		var max1, max2 int
 		if sf.Comment != nil {
 			c := sf.Comment.List[0].Text
-			if m := maxRe.FindStringSubmatch(c); m != nil {
-				max, _ = strconv.Atoi(m[1])
+			m := maxRe.FindStringSubmatch(c)
+			if len(m) >= 2 {
+				max1, _ = strconv.Atoi(m[1])
+			}
+			if len(m) >= 3 {
+				max2, _ = strconv.Atoi(m[2])
 			}
 			if strings.Contains(c, "noencode") {
 				continue
@@ -220,14 +229,16 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 					FieldType: tn,
 					Encoder:   enc.Encoder,
 					Convert:   enc.Type,
-					Max:       max,
+					Max:       max1,
+					Submax:    max2,
 				}
 			} else {
 				f = fieldInfo{
 					Name:      fn,
 					IsBasic:   false,
 					FieldType: tn,
-					Max:       max,
+					Max:       max1,
+					Submax:    max2,
 				}
 			}
 
@@ -245,7 +256,8 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 					FieldType: tn,
 					Encoder:   enc.Encoder,
 					Convert:   enc.Type,
-					Max:       max,
+					Max:       max1,
+					Submax:    max2,
 				}
 			} else if enc, ok := xdrEncoders[tn]; ok {
 				f = fieldInfo{
@@ -255,14 +267,16 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 					FieldType: tn,
 					Encoder:   enc.Encoder,
 					Convert:   enc.Type,
-					Max:       max,
+					Max:       max1,
+					Submax:    max2,
 				}
 			} else {
 				f = fieldInfo{
 					Name:      fn,
 					IsSlice:   true,
 					FieldType: tn,
-					Max:       max,
+					Max:       max1,
+					Submax:    max2,
 				}
 			}
 
@@ -270,7 +284,8 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 			f = fieldInfo{
 				Name:      fn,
 				FieldType: ft.Sel.Name,
-				Max:       max,
+				Max:       max1,
+				Submax:    max2,
 			}
 		}
 

Godeps/_workspace/src/golang.org/x/net/internal/iana/const.go

@@ -2,7 +2,7 @@
 // GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
 // Package iana provides protocol number resources managed by the Internet Assigned Numbers Authority (IANA).
-package iana
+package iana // import "golang.org/x/net/internal/iana"
 
 // Differentiated Services Field Codepoints (DSCP), Updated: 2013-06-25
 const (

Godeps/_workspace/src/golang.org/x/net/ipv6/doc.go

@@ -42,7 +42,7 @@
 // The outgoing packets will be labeled DiffServ assured forwarding
 // class 1 low drop precedence, known as AF11 packets.
 //
-//			if err := ipv6.NewConn(c).SetTrafficClass(DiffServAF11); err != nil {
+//			if err := ipv6.NewConn(c).SetTrafficClass(0x28); err != nil {
 //				// error handling
 //			}
 //			if _, err := c.Write(data); err != nil {
@@ -124,7 +124,7 @@
 //
 // The application can also send both unicast and multicast packets.
 //
-//		p.SetTrafficClass(DiffServCS0)
+//		p.SetTrafficClass(0x0)
 //		p.SetHopLimit(16)
 //		if _, err := p.WriteTo(data[:n], nil, src); err != nil {
 //			// error handling
@@ -237,4 +237,4 @@
 // MLDv1 and starts to listen to multicast traffic.
 // In the fallback case, ExcludeSourceSpecificGroup and
 // IncludeSourceSpecificGroup may return an error.
-package ipv6
+package ipv6 // import "golang.org/x/net/ipv6"

Godeps/_workspace/src/golang.org/x/net/proxy/direct.go

@@ -0,0 +1,18 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package proxy
+
+import (
+	"net"
+)
+
+type direct struct{}
+
+// Direct is a direct proxy: one that makes network connections directly.
+var Direct = direct{}
+
+func (direct) Dial(network, addr string) (net.Conn, error) {
+	return net.Dial(network, addr)
+}

Godeps/_workspace/src/golang.org/x/net/proxy/per_host.go

@@ -0,0 +1,140 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package proxy
+
+import (
+	"net"
+	"strings"
+)
+
+// A PerHost directs connections to a default Dialer unless the hostname
+// requested matches one of a number of exceptions.
+type PerHost struct {
+	def, bypass Dialer
+
+	bypassNetworks []*net.IPNet
+	bypassIPs      []net.IP
+	bypassZones    []string
+	bypassHosts    []string
+}
+
+// NewPerHost returns a PerHost Dialer that directs connections to either
+// defaultDialer or bypass, depending on whether the connection matches one of
+// the configured rules.
+func NewPerHost(defaultDialer, bypass Dialer) *PerHost {
+	return &PerHost{
+		def:    defaultDialer,
+		bypass: bypass,
+	}
+}
+
+// Dial connects to the address addr on the given network through either
+// defaultDialer or bypass.
+func (p *PerHost) Dial(network, addr string) (c net.Conn, err error) {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return p.dialerForRequest(host).Dial(network, addr)
+}
+
+func (p *PerHost) dialerForRequest(host string) Dialer {
+	if ip := net.ParseIP(host); ip != nil {
+		for _, net := range p.bypassNetworks {
+			if net.Contains(ip) {
+				return p.bypass
+			}
+		}
+		for _, bypassIP := range p.bypassIPs {
+			if bypassIP.Equal(ip) {
+				return p.bypass
+			}
+		}
+		return p.def
+	}
+
+	for _, zone := range p.bypassZones {
+		if strings.HasSuffix(host, zone) {
+			return p.bypass
+		}
+		if host == zone[1:] {
+			// For a zone "example.com", we match "example.com"
+			// too.
+			return p.bypass
+		}
+	}
+	for _, bypassHost := range p.bypassHosts {
+		if bypassHost == host {
+			return p.bypass
+		}
+	}
+	return p.def
+}
+
+// AddFromString parses a string that contains comma-separated values
+// specifying hosts that should use the bypass proxy. Each value is either an
+// IP address, a CIDR range, a zone (*.example.com) or a hostname
+// (localhost). A best effort is made to parse the string and errors are
+// ignored.
+func (p *PerHost) AddFromString(s string) {
+	hosts := strings.Split(s, ",")
+	for _, host := range hosts {
+		host = strings.TrimSpace(host)
+		if len(host) == 0 {
+			continue
+		}
+		if strings.Contains(host, "/") {
+			// We assume that it's a CIDR address like 127.0.0.0/8
+			if _, net, err := net.ParseCIDR(host); err == nil {
+				p.AddNetwork(net)
+			}
+			continue
+		}
+		if ip := net.ParseIP(host); ip != nil {
+			p.AddIP(ip)
+			continue
+		}
+		if strings.HasPrefix(host, "*.") {
+			p.AddZone(host[1:])
+			continue
+		}
+		p.AddHost(host)
+	}
+}
+
+// AddIP specifies an IP address that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match an IP.
+func (p *PerHost) AddIP(ip net.IP) {
+	p.bypassIPs = append(p.bypassIPs, ip)
+}
+
+// AddNetwork specifies an IP range that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match.
+func (p *PerHost) AddNetwork(net *net.IPNet) {
+	p.bypassNetworks = append(p.bypassNetworks, net)
+}
+
+// AddZone specifies a DNS suffix that will use the bypass proxy. A zone of
+// "example.com" matches "example.com" and all of its subdomains.
+func (p *PerHost) AddZone(zone string) {
+	if strings.HasSuffix(zone, ".") {
+		zone = zone[:len(zone)-1]
+	}
+	if !strings.HasPrefix(zone, ".") {
+		zone = "." + zone
+	}
+	p.bypassZones = append(p.bypassZones, zone)
+}
+
+// AddHost specifies a hostname that will use the bypass proxy.
+func (p *PerHost) AddHost(host string) {
+	if strings.HasSuffix(host, ".") {
+		host = host[:len(host)-1]
+	}
+	p.bypassHosts = append(p.bypassHosts, host)
+}

Godeps/_workspace/src/golang.org/x/net/proxy/per_host_test.go

@@ -0,0 +1,55 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package proxy
+
+import (
+	"errors"
+	"net"
+	"reflect"
+	"testing"
+)
+
+type recordingProxy struct {
+	addrs []string
+}
+
+func (r *recordingProxy) Dial(network, addr string) (net.Conn, error) {
+	r.addrs = append(r.addrs, addr)
+	return nil, errors.New("recordingProxy")
+}
+
+func TestPerHost(t *testing.T) {
+	var def, bypass recordingProxy
+	perHost := NewPerHost(&def, &bypass)
+	perHost.AddFromString("localhost,*.zone,127.0.0.1,10.0.0.1/8,1000::/16")
+
+	expectedDef := []string{
+		"example.com:123",
+		"1.2.3.4:123",
+		"[1001::]:123",
+	}
+	expectedBypass := []string{
+		"localhost:123",
+		"zone:123",
+		"foo.zone:123",
+		"127.0.0.1:123",
+		"10.1.2.3:123",
+		"[1000::]:123",
+	}
+
+	for _, addr := range expectedDef {
+		perHost.Dial("tcp", addr)
+	}
+	for _, addr := range expectedBypass {
+		perHost.Dial("tcp", addr)
+	}
+
+	if !reflect.DeepEqual(expectedDef, def.addrs) {
+		t.Errorf("Hosts which went to the default proxy didn't match. Got %v, want %v", def.addrs, expectedDef)
+	}
+	if !reflect.DeepEqual(expectedBypass, bypass.addrs) {
+		t.Errorf("Hosts which went to the bypass proxy didn't match. Got %v, want %v", bypass.addrs, expectedBypass)
+	}
+}

Godeps/_workspace/src/golang.org/x/net/proxy/proxy.go

@@ -0,0 +1,94 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package proxy provides support for a variety of protocols to proxy network
+// data.
+package proxy // import "golang.org/x/net/proxy"
+
+import (
+	"errors"
+	"net"
+	"net/url"
+	"os"
+)
+
+// A Dialer is a means to establish a connection.
+type Dialer interface {
+	// Dial connects to the given address via the proxy.
+	Dial(network, addr string) (c net.Conn, err error)
+}
+
+// Auth contains authentication parameters that specific Dialers may require.
+type Auth struct {
+	User, Password string
+}
+
+// FromEnvironment returns the dialer specified by the proxy related variables in
+// the environment.
+func FromEnvironment() Dialer {
+	allProxy := os.Getenv("all_proxy")
+	if len(allProxy) == 0 {
+		return Direct
+	}
+
+	proxyURL, err := url.Parse(allProxy)
+	if err != nil {
+		return Direct
+	}
+	proxy, err := FromURL(proxyURL, Direct)
+	if err != nil {
+		return Direct
+	}
+
+	noProxy := os.Getenv("no_proxy")
+	if len(noProxy) == 0 {
+		return proxy
+	}
+
+	perHost := NewPerHost(proxy, Direct)
+	perHost.AddFromString(noProxy)
+	return perHost
+}
+
+// proxySchemes is a map from URL schemes to a function that creates a Dialer
+// from a URL with such a scheme.
+var proxySchemes map[string]func(*url.URL, Dialer) (Dialer, error)
+
+// RegisterDialerType takes a URL scheme and a function to generate Dialers from
+// a URL with that scheme and a forwarding Dialer. Registered schemes are used
+// by FromURL.
+func RegisterDialerType(scheme string, f func(*url.URL, Dialer) (Dialer, error)) {
+	if proxySchemes == nil {
+		proxySchemes = make(map[string]func(*url.URL, Dialer) (Dialer, error))
+	}
+	proxySchemes[scheme] = f
+}
+
+// FromURL returns a Dialer given a URL specification and an underlying
+// Dialer for it to make network requests.
+func FromURL(u *url.URL, forward Dialer) (Dialer, error) {
+	var auth *Auth
+	if u.User != nil {
+		auth = new(Auth)
+		auth.User = u.User.Username()
+		if p, ok := u.User.Password(); ok {
+			auth.Password = p
+		}
+	}
+
+	switch u.Scheme {
+	case "socks5":
+		return SOCKS5("tcp", u.Host, auth, forward)
+	}
+
+	// If the scheme doesn't match any of the built-in schemes, see if it
+	// was registered by another package.
+	if proxySchemes != nil {
+		if f, ok := proxySchemes[u.Scheme]; ok {
+			return f(u, forward)
+		}
+	}
+
+	return nil, errors.New("proxy: unknown scheme: " + u.Scheme)
+}

Godeps/_workspace/src/golang.org/x/net/proxy/proxy_test.go

@@ -0,0 +1,142 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package proxy
+
+import (
+	"io"
+	"net"
+	"net/url"
+	"strconv"
+	"sync"
+	"testing"
+)
+
+func TestFromURL(t *testing.T) {
+	endSystem, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("net.Listen failed: %v", err)
+	}
+	defer endSystem.Close()
+	gateway, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("net.Listen failed: %v", err)
+	}
+	defer gateway.Close()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go socks5Gateway(t, gateway, endSystem, socks5Domain, &wg)
+
+	url, err := url.Parse("socks5://user:password@" + gateway.Addr().String())
+	if err != nil {
+		t.Fatalf("url.Parse failed: %v", err)
+	}
+	proxy, err := FromURL(url, Direct)
+	if err != nil {
+		t.Fatalf("FromURL failed: %v", err)
+	}
+	_, port, err := net.SplitHostPort(endSystem.Addr().String())
+	if err != nil {
+		t.Fatalf("net.SplitHostPort failed: %v", err)
+	}
+	if c, err := proxy.Dial("tcp", "localhost:"+port); err != nil {
+		t.Fatalf("FromURL.Dial failed: %v", err)
+	} else {
+		c.Close()
+	}
+
+	wg.Wait()
+}
+
+func TestSOCKS5(t *testing.T) {
+	endSystem, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("net.Listen failed: %v", err)
+	}
+	defer endSystem.Close()
+	gateway, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("net.Listen failed: %v", err)
+	}
+	defer gateway.Close()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go socks5Gateway(t, gateway, endSystem, socks5IP4, &wg)
+
+	proxy, err := SOCKS5("tcp", gateway.Addr().String(), nil, Direct)
+	if err != nil {
+		t.Fatalf("SOCKS5 failed: %v", err)
+	}
+	if c, err := proxy.Dial("tcp", endSystem.Addr().String()); err != nil {
+		t.Fatalf("SOCKS5.Dial failed: %v", err)
+	} else {
+		c.Close()
+	}
+
+	wg.Wait()
+}
+
+func socks5Gateway(t *testing.T, gateway, endSystem net.Listener, typ byte, wg *sync.WaitGroup) {
+	defer wg.Done()
+
+	c, err := gateway.Accept()
+	if err != nil {
+		t.Errorf("net.Listener.Accept failed: %v", err)
+		return
+	}
+	defer c.Close()
+
+	b := make([]byte, 32)
+	var n int
+	if typ == socks5Domain {
+		n = 4
+	} else {
+		n = 3
+	}
+	if _, err := io.ReadFull(c, b[:n]); err != nil {
+		t.Errorf("io.ReadFull failed: %v", err)
+		return
+	}
+	if _, err := c.Write([]byte{socks5Version, socks5AuthNone}); err != nil {
+		t.Errorf("net.Conn.Write failed: %v", err)
+		return
+	}
+	if typ == socks5Domain {
+		n = 16
+	} else {
+		n = 10
+	}
+	if _, err := io.ReadFull(c, b[:n]); err != nil {
+		t.Errorf("io.ReadFull failed: %v", err)
+		return
+	}
+	if b[0] != socks5Version || b[1] != socks5Connect || b[2] != 0x00 || b[3] != typ {
+		t.Errorf("got an unexpected packet: %#02x %#02x %#02x %#02x", b[0], b[1], b[2], b[3])
+		return
+	}
+	if typ == socks5Domain {
+		copy(b[:5], []byte{socks5Version, 0x00, 0x00, socks5Domain, 9})
+		b = append(b, []byte("localhost")...)
+	} else {
+		copy(b[:4], []byte{socks5Version, 0x00, 0x00, socks5IP4})
+	}
+	host, port, err := net.SplitHostPort(endSystem.Addr().String())
+	if err != nil {
+		t.Errorf("net.SplitHostPort failed: %v", err)
+		return
+	}
+	b = append(b, []byte(net.ParseIP(host).To4())...)
+	p, err := strconv.Atoi(port)
+	if err != nil {
+		t.Errorf("strconv.Atoi failed: %v", err)
+		return
+	}
+	b = append(b, []byte{byte(p >> 8), byte(p)}...)
+	if _, err := c.Write(b); err != nil {
+		t.Errorf("net.Conn.Write failed: %v", err)
+		return
+	}
+}

Godeps/_workspace/src/golang.org/x/net/proxy/socks5.go

@@ -0,0 +1,210 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package proxy
+
+import (
+	"errors"
+	"io"
+	"net"
+	"strconv"
+)
+
+// SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given address
+// with an optional username and password. See RFC 1928.
+func SOCKS5(network, addr string, auth *Auth, forward Dialer) (Dialer, error) {
+	s := &socks5{
+		network: network,
+		addr:    addr,
+		forward: forward,
+	}
+	if auth != nil {
+		s.user = auth.User
+		s.password = auth.Password
+	}
+
+	return s, nil
+}
+
+type socks5 struct {
+	user, password string
+	network, addr  string
+	forward        Dialer
+}
+
+const socks5Version = 5
+
+const (
+	socks5AuthNone     = 0
+	socks5AuthPassword = 2
+)
+
+const socks5Connect = 1
+
+const (
+	socks5IP4    = 1
+	socks5Domain = 3
+	socks5IP6    = 4
+)
+
+var socks5Errors = []string{
+	"",
+	"general failure",
+	"connection forbidden",
+	"network unreachable",
+	"host unreachable",
+	"connection refused",
+	"TTL expired",
+	"command not supported",
+	"address type not supported",
+}
+
+// Dial connects to the address addr on the network net via the SOCKS5 proxy.
+func (s *socks5) Dial(network, addr string) (net.Conn, error) {
+	switch network {
+	case "tcp", "tcp6", "tcp4":
+	default:
+		return nil, errors.New("proxy: no support for SOCKS5 proxy connections of type " + network)
+	}
+
+	conn, err := s.forward.Dial(s.network, s.addr)
+	if err != nil {
+		return nil, err
+	}
+	closeConn := &conn
+	defer func() {
+		if closeConn != nil {
+			(*closeConn).Close()
+		}
+	}()
+
+	host, portStr, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return nil, errors.New("proxy: failed to parse port number: " + portStr)
+	}
+	if port < 1 || port > 0xffff {
+		return nil, errors.New("proxy: port number out of range: " + portStr)
+	}
+
+	// the size here is just an estimate
+	buf := make([]byte, 0, 6+len(host))
+
+	buf = append(buf, socks5Version)
+	if len(s.user) > 0 && len(s.user) < 256 && len(s.password) < 256 {
+		buf = append(buf, 2 /* num auth methods */, socks5AuthNone, socks5AuthPassword)
+	} else {
+		buf = append(buf, 1 /* num auth methods */, socks5AuthNone)
+	}
+
+	if _, err := conn.Write(buf); err != nil {
+		return nil, errors.New("proxy: failed to write greeting to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+		return nil, errors.New("proxy: failed to read greeting from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+	if buf[0] != 5 {
+		return nil, errors.New("proxy: SOCKS5 proxy at " + s.addr + " has unexpected version " + strconv.Itoa(int(buf[0])))
+	}
+	if buf[1] == 0xff {
+		return nil, errors.New("proxy: SOCKS5 proxy at " + s.addr + " requires authentication")
+	}
+
+	if buf[1] == socks5AuthPassword {
+		buf = buf[:0]
+		buf = append(buf, 1 /* password protocol version */)
+		buf = append(buf, uint8(len(s.user)))
+		buf = append(buf, s.user...)
+		buf = append(buf, uint8(len(s.password)))
+		buf = append(buf, s.password...)
+
+		if _, err := conn.Write(buf); err != nil {
+			return nil, errors.New("proxy: failed to write authentication request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+
+		if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+			return nil, errors.New("proxy: failed to read authentication reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+
+		if buf[1] != 0 {
+			return nil, errors.New("proxy: SOCKS5 proxy at " + s.addr + " rejected username/password")
+		}
+	}
+
+	buf = buf[:0]
+	buf = append(buf, socks5Version, socks5Connect, 0 /* reserved */)
+
+	if ip := net.ParseIP(host); ip != nil {
+		if ip4 := ip.To4(); ip4 != nil {
+			buf = append(buf, socks5IP4)
+			ip = ip4
+		} else {
+			buf = append(buf, socks5IP6)
+		}
+		buf = append(buf, ip...)
+	} else {
+		if len(host) > 255 {
+			return nil, errors.New("proxy: destination hostname too long: " + host)
+		}
+		buf = append(buf, socks5Domain)
+		buf = append(buf, byte(len(host)))
+		buf = append(buf, host...)
+	}
+	buf = append(buf, byte(port>>8), byte(port))
+
+	if _, err := conn.Write(buf); err != nil {
+		return nil, errors.New("proxy: failed to write connect request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	if _, err := io.ReadFull(conn, buf[:4]); err != nil {
+		return nil, errors.New("proxy: failed to read connect reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	failure := "unknown error"
+	if int(buf[1]) < len(socks5Errors) {
+		failure = socks5Errors[buf[1]]
+	}
+
+	if len(failure) > 0 {
+		return nil, errors.New("proxy: SOCKS5 proxy at " + s.addr + " failed to connect: " + failure)
+	}
+
+	bytesToDiscard := 0
+	switch buf[3] {
+	case socks5IP4:
+		bytesToDiscard = net.IPv4len
+	case socks5IP6:
+		bytesToDiscard = net.IPv6len
+	case socks5Domain:
+		_, err := io.ReadFull(conn, buf[:1])
+		if err != nil {
+			return nil, errors.New("proxy: failed to read domain length from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+		bytesToDiscard = int(buf[0])
+	default:
+		return nil, errors.New("proxy: got unknown address type " + strconv.Itoa(int(buf[3])) + " from SOCKS5 proxy at " + s.addr)
+	}
+
+	if cap(buf) < bytesToDiscard {
+		buf = make([]byte, bytesToDiscard)
+	} else {
+		buf = buf[:bytesToDiscard]
+	}
+	if _, err := io.ReadFull(conn, buf); err != nil {
+		return nil, errors.New("proxy: failed to read address from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	// Also need to discard the port number
+	if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+		return nil, errors.New("proxy: failed to read port from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	closeConn = nil
+	return conn, nil
+}

NICKS

@@ -7,8 +7,10 @@ LordLandon	<lordlandon@gmail.com>
 Moter8		<moter8@gmail.com>
 Nutomic		<me@nutomic.com>
 Rewt0r		<rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
+Stefan-Code	<stefan.github@gmail.com> <Stefan.github@gmail.com>
 Vilbrekin	<vilbrekin@gmail.com>
 Zillode		<zillode@zillode.be>
+acogdev		<jake@acogdev.com>
 alex2108	<register-github@alex-graf.de>
 andrew-d	<andrew@du.nham.ca>
 asdil12		<dominik@heidler.eu>
@@ -18,7 +20,7 @@ brbecker	<brbecker@gmail.com>
 brendanlong	<self@brendanlong.com>
 brgmnn      <dan.arne.bergmann@gmail.com> <brgmnn@users.noreply.github.com>
 bsidhom		<bsidhom@gmail.com>
-burkemw3	<mburke@amplify.com>
+burkemw3	<mburke@amplify.com> <burkemw3@gmail.com>
 calmh		<jakob@nym.se>
 canton7	<antony.male@gmail.com>
 cdata		<chris@scriptolo.gy>
@@ -27,6 +29,7 @@ ceh		<emil@hessman.se>
 cqcallaw	<enlightened.despot@gmail.com>
 dva	<denisva@gmail.com>
 dzarda		<dzardacz@gmail.com>
+eipiminus1	<eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>
 facastagnini	<federico.castagnini@gmail.com>
 filoozoom	<philippe@schommers.be>
 frioux		<frew@afoolishmanifesto.com> <frioux@gmail.com>

README.md

@@ -48,7 +48,7 @@ Please see the [Syncthing documentation site][6].
 
 All code is licensed under the [MPLv2 License][7].
 
-[1]: https://github.com/syncthing/specs/blob/master/BEPv1.md
+[1]: http://docs.syncthing.net/specs/bep-v1.html
 [2]: http://docs.syncthing.net/intro/getting-started.html
 [3]: https://github.com/syncthing/syncthing/blob/master/etc
 [4]: https://webchat.freenode.net/

build.go

@@ -186,7 +186,7 @@ func setup() {
 
 func test(pkg string) {
 	setBuildEnv()
-	runPrint("go", "test", "-short", "-timeout", "60s", pkg)
+	runPrint("go", "test", "-short", "-race", "-timeout", "60s", pkg)
 }
 
 func bench(pkg string) {
@@ -195,7 +195,11 @@ func bench(pkg string) {
 }
 
 func install(pkg string, tags []string) {
-	os.Setenv("GOBIN", "./bin")
+	cwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	os.Setenv("GOBIN", filepath.Join(cwd, "bin"))
 	args := []string{"install", "-v", "-ldflags", ldflags()}
 	if len(tags) > 0 {
 		args = append(args, "-tags", strings.Join(tags, ","))

build.sh

@@ -108,10 +108,10 @@ case "${1:-default}" in
 		# For every package in the repo
 		for dir in $(go list ./...) ; do
 			# run the tests
-			godep go test -coverprofile=profile.out $dir
+			GOPATH="$(pwd)/Godeps/_workspace:$GOPATH" go test -race -coverprofile=profile.out $dir
 			if [ -f profile.out ] ; then
 				# and if there was test output, append it to coverage.out
-				grep -v "mode: set" profile.out >> coverage.out
+				grep -v "mode: " profile.out >> coverage.out
 				rm profile.out
 			fi
 		done

cmd/stindex/dump.go

@@ -0,0 +1,63 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+func dump(ldb *leveldb.DB) {
+	it := ldb.NewIterator(nil, nil)
+	var dev protocol.DeviceID
+	for it.Next() {
+		key := it.Key()
+		switch key[0] {
+		case db.KeyTypeDevice:
+			folder := nulString(key[1 : 1+64])
+			devBytes := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			copy(dev[:], devBytes)
+			fmt.Printf("[device] F:%q N:%q D:%v\n", folder, name, dev)
+
+			var f protocol.FileInfo
+			err := f.UnmarshalXDR(it.Value())
+			if err != nil {
+				log.Fatal(err)
+			}
+			fmt.Printf("  N:%q\n  F:%#o\n  M:%d\n  V:%v\n  S:%d\n  B:%d\n", f.Name, f.Flags, f.Modified, f.Version, f.Size(), len(f.Blocks))
+
+		case db.KeyTypeGlobal:
+			folder := nulString(key[1 : 1+64])
+			name := nulString(key[1+64:])
+			fmt.Printf("[global] F:%q N:%q V:%x\n", folder, name, it.Value())
+
+		case db.KeyTypeBlock:
+			folder := nulString(key[1 : 1+64])
+			hash := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			fmt.Printf("[block] F:%q H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value()))
+
+		case db.KeyTypeDeviceStatistic:
+			fmt.Printf("[dstat]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		case db.KeyTypeFolderStatistic:
+			fmt.Printf("[fstat]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		case db.KeyTypeVirtualMtime:
+			fmt.Printf("[mtime]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		default:
+			fmt.Printf("[???]\n  %x\n  %x\n", it.Key(), it.Value())
+		}
+	}
+}

cmd/stindex/dumpsize.go

@@ -0,0 +1,90 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"container/heap"
+	"fmt"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+// An IntHeap is a min-heap of ints.
+type SizedElement struct {
+	key  string
+	size int
+}
+
+type ElementHeap []SizedElement
+
+func (h ElementHeap) Len() int           { return len(h) }
+func (h ElementHeap) Less(i, j int) bool { return h[i].size > h[j].size }
+func (h ElementHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *ElementHeap) Push(x interface{}) {
+	*h = append(*h, x.(SizedElement))
+}
+
+func (h *ElementHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func dumpsize(ldb *leveldb.DB) {
+	h := &ElementHeap{}
+	heap.Init(h)
+
+	it := ldb.NewIterator(nil, nil)
+	var dev protocol.DeviceID
+	var ele SizedElement
+	for it.Next() {
+		key := it.Key()
+		switch key[0] {
+		case db.KeyTypeDevice:
+			folder := nulString(key[1 : 1+64])
+			devBytes := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			copy(dev[:], devBytes)
+			ele.key = fmt.Sprintf("DEVICE:%s:%s:%s", dev, folder, name)
+
+		case db.KeyTypeGlobal:
+			folder := nulString(key[1 : 1+64])
+			name := nulString(key[1+64:])
+			ele.key = fmt.Sprintf("GLOBAL:%s:%s", folder, name)
+
+		case db.KeyTypeBlock:
+			folder := nulString(key[1 : 1+64])
+			hash := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			ele.key = fmt.Sprintf("BLOCK:%s:%x:%s", folder, hash, name)
+
+		case db.KeyTypeDeviceStatistic:
+			ele.key = fmt.Sprintf("DEVICESTATS:%s", key[1:])
+
+		case db.KeyTypeFolderStatistic:
+			ele.key = fmt.Sprintf("FOLDERSTATS:%s", key[1:])
+
+		case db.KeyTypeVirtualMtime:
+			ele.key = fmt.Sprintf("MTIME:%s", key[1:])
+
+		default:
+			ele.key = fmt.Sprintf("UNKNOWN:%x", key)
+		}
+		ele.size = len(it.Value())
+		heap.Push(h, ele)
+	}
+
+	for h.Len() > 0 {
+		ele = heap.Pop(h).(SizedElement)
+		fmt.Println(ele.key, ele.size)
+	}
+}

cmd/stindex/main.go

@@ -7,25 +7,33 @@
 package main
 
 import (
-	"encoding/binary"
 	"flag"
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 
-	"github.com/syncthing/syncthing/lib/db"
-	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 )
 
 func main() {
+	var mode string
 	log.SetFlags(0)
 	log.SetOutput(os.Stdout)
 
+	flag.StringVar(&mode, "mode", "dump", "Mode of operation: dump, dumpsize")
+
 	flag.Parse()
 
-	ldb, err := leveldb.OpenFile(flag.Arg(0), &opt.Options{
+	path := flag.Arg(0)
+	if path == "" {
+		path = filepath.Join(defaultConfigDir(), "index-v0.11.0.db")
+	}
+
+	fmt.Println("Path:", path)
+
+	ldb, err := leveldb.OpenFile(path, &opt.Options{
 		ErrorIfMissing:         true,
 		Strict:                 opt.StrictAll,
 		OpenFilesCacheCapacity: 100,
@@ -34,53 +42,11 @@ func main() {
 		log.Fatal(err)
 	}
 
-	it := ldb.NewIterator(nil, nil)
-	var dev protocol.DeviceID
-	for it.Next() {
-		key := it.Key()
-		switch key[0] {
-		case db.KeyTypeDevice:
-			folder := nulString(key[1 : 1+64])
-			devBytes := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			copy(dev[:], devBytes)
-			fmt.Printf("[device] F:%q N:%q D:%v\n", folder, name, dev)
-
-			var f protocol.FileInfo
-			err := f.UnmarshalXDR(it.Value())
-			if err != nil {
-				log.Fatal(err)
-			}
-			fmt.Printf("  N:%q\n  F:%#o\n  M:%d\n  V:%v\n  S:%d\n  B:%d\n", f.Name, f.Flags, f.Modified, f.Version, f.Size(), len(f.Blocks))
-
-		case db.KeyTypeGlobal:
-			folder := nulString(key[1 : 1+64])
-			name := nulString(key[1+64:])
-			fmt.Printf("[global] F:%q N:%q V:%x\n", folder, name, it.Value())
-
-		case db.KeyTypeBlock:
-			folder := nulString(key[1 : 1+64])
-			hash := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			fmt.Printf("[block] F:%q H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value()))
-
-		case db.KeyTypeDeviceStatistic:
-			fmt.Printf("[dstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		case db.KeyTypeFolderStatistic:
-			fmt.Printf("[fstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		default:
-			fmt.Printf("[???]\n  %x\n  %x\n", it.Key(), it.Value())
-		}
+	if mode == "dump" {
+		dump(ldb)
+	} else if mode == "dumpsize" {
+		dumpsize(ldb)
+	} else {
+		fmt.Println("Unknown mode")
 	}
 }
-
-func nulString(bs []byte) string {
-	for i := range bs {
-		if bs[i] == 0 {
-			return string(bs[:i])
-		}
-	}
-	return string(bs)
-}

cmd/stindex/util.go

@@ -0,0 +1,52 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/syncthing/syncthing/lib/osutil"
+)
+
+func nulString(bs []byte) string {
+	for i := range bs {
+		if bs[i] == 0 {
+			return string(bs[:i])
+		}
+	}
+	return string(bs)
+}
+
+func defaultConfigDir() string {
+	switch runtime.GOOS {
+	case "windows":
+		if p := os.Getenv("LocalAppData"); p != "" {
+			return filepath.Join(p, "Syncthing")
+		}
+		return filepath.Join(os.Getenv("AppData"), "Syncthing")
+
+	case "darwin":
+		dir, err := osutil.ExpandTilde("~/Library/Application Support/Syncthing")
+		if err != nil {
+			log.Fatal(err)
+		}
+		return dir
+
+	default:
+		if xdgCfg := os.Getenv("XDG_CONFIG_HOME"); xdgCfg != "" {
+			return filepath.Join(xdgCfg, "syncthing")
+		}
+		dir, err := osutil.ExpandTilde("~/.config/syncthing")
+		if err != nil {
+			log.Fatal(err)
+		}
+		return dir
+	}
+}

cmd/syncthing/addresslister.go

@@ -63,13 +63,13 @@ func (e *addressLister) addresses(includePrivateIPV4 bool) []string {
 
 		if addr.IP == nil || addr.IP.IsUnspecified() {
 			// Address like 0.0.0.0:22000 or [::]:22000 or :22000; include as is.
-			addrs = append(addrs, "tcp://"+addr.String())
+			addrs = append(addrs, tcpAddr(addr.String()))
 		} else if isPublicIPv4(addr.IP) || isPublicIPv6(addr.IP) {
 			// A public address; include as is.
-			addrs = append(addrs, "tcp://"+addr.String())
+			addrs = append(addrs, tcpAddr(addr.String()))
 		} else if includePrivateIPV4 && addr.IP.To4().IsGlobalUnicast() {
 			// A private IPv4 address.
-			addrs = append(addrs, "tcp://"+addr.String())
+			addrs = append(addrs, tcpAddr(addr.String()))
 		}
 	}
 
@@ -117,3 +117,11 @@ func isPublicIPv6(ip net.IP) bool {
 
 	return ip.IsGlobalUnicast()
 }
+
+func tcpAddr(host string) string {
+	u := url.URL{
+		Scheme: "tcp",
+		Host:   host,
+	}
+	return u.String()
+}

cmd/syncthing/debug.go

@@ -22,11 +22,3 @@ func init() {
 	l.SetDebug("main", strings.Contains(os.Getenv("STTRACE"), "main") || os.Getenv("STTRACE") == "all")
 	l.SetDebug("http", strings.Contains(os.Getenv("STTRACE"), "http") || os.Getenv("STTRACE") == "all")
 }
-
-func shouldDebugMain() bool {
-	return l.ShouldDebug("main")
-}
-
-func shouldDebugHTTP() bool {
-	return l.ShouldDebug("http")
-}

cmd/syncthing/gui.go

@@ -83,12 +83,7 @@ func newAPISvc(id protocol.DeviceID, cfg *config.Wrapper, assetDir string, m *mo
 	return svc, err
 }
 
-func (s *apiSvc) getListener(cfg config.GUIConfiguration) (net.Listener, error) {
-	if guiAddress != "" {
-		// Override from the environment
-		cfg.Address = guiAddress
-	}
-
+func (s *apiSvc) getListener(guiCfg config.GUIConfiguration) (net.Listener, error) {
 	cert, err := tls.LoadX509KeyPair(locations[locHTTPSCertFile], locations[locHTTPSKeyFile])
 	if err != nil {
 		l.Infoln("Loading HTTPS certificate:", err)
@@ -125,7 +120,7 @@ func (s *apiSvc) getListener(cfg config.GUIConfiguration) (net.Listener, error)
 		},
 	}
 
-	rawListener, err := net.Listen("tcp", cfg.Address)
+	rawListener, err := net.Listen("tcp", guiCfg.Address())
 	if err != nil {
 		return nil, err
 	}
@@ -202,14 +197,10 @@ func (s *apiSvc) Serve() {
 	})
 
 	guiCfg := s.cfg.GUI()
-	if guiAPIKey != "" {
-		// Override from the environment
-		guiCfg.APIKey = guiAPIKey
-	}
 
 	// Wrap everything in CSRF protection. The /rest prefix should be
 	// protected, other requests will grant cookies.
-	handler := csrfMiddleware(s.id.String()[:5], "/rest", guiCfg.APIKey, mux)
+	handler := csrfMiddleware(s.id.String()[:5], "/rest", guiCfg.APIKey(), mux)
 
 	// Add our version and ID as a header to responses
 	handler = withDetailsMiddleware(s.id, handler)
@@ -220,7 +211,7 @@ func (s *apiSvc) Serve() {
 	}
 
 	// Redirect to HTTPS if we are supposed to
-	if guiCfg.UseTLS {
+	if guiCfg.UseTLS() {
 		handler = redirectToHTTPSMiddleware(handler)
 	}
 
@@ -236,6 +227,7 @@ func (s *apiSvc) Serve() {
 	s.fss.ServeBackground()
 
 	l.Infoln("API listening on", s.listener.Addr())
+	l.Infoln("GUI URL is", guiCfg.URL())
 	err := srv.Serve(s.listener)
 
 	// The return could be due to an intentional close. Wait for the stop
@@ -570,8 +562,7 @@ func (s *apiSvc) postSystemConfig(w http.ResponseWriter, r *http.Request) {
 	s.systemConfigMut.Lock()
 	defer s.systemConfigMut.Unlock()
 
-	var to config.Configuration
-	err := json.NewDecoder(r.Body).Decode(&to)
+	to, err := config.ReadJSON(r.Body, myID)
 	if err != nil {
 		l.Warnln("decoding posted config:", err)
 		http.Error(w, err.Error(), 500)

cmd/syncthing/gui_auth.go

@@ -25,8 +25,9 @@ var (
 )
 
 func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
+	apiKey := cfg.APIKey()
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if cfg.APIKey != "" && r.Header.Get("X-API-Key") == cfg.APIKey {
+		if apiKey != "" && r.Header.Get("X-API-Key") == apiKey {
 			next.ServeHTTP(w, r)
 			return
 		}

cmd/syncthing/main.go

@@ -9,6 +9,7 @@ package main
 import (
 	"bytes"
 	"crypto/tls"
+	"errors"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -30,6 +31,7 @@ import (
 	"github.com/syncthing/syncthing/lib/config"
 	"github.com/syncthing/syncthing/lib/connections"
 	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/dialer"
 	"github.com/syncthing/syncthing/lib/discover"
 	"github.com/syncthing/syncthing/lib/events"
 	"github.com/syncthing/syncthing/lib/logger"
@@ -41,9 +43,6 @@ import (
 	"github.com/syncthing/syncthing/lib/tlsutil"
 	"github.com/syncthing/syncthing/lib/upgrade"
 
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/errors"
-	"github.com/syndtr/goleveldb/leveldb/opt"
 	"github.com/thejerf/suture"
 )
 
@@ -205,8 +204,6 @@ var (
 	paused         bool
 	noRestart      = os.Getenv("STNORESTART") != ""
 	noUpgrade      = os.Getenv("STNOUPGRADE") != ""
-	guiAddress     = os.Getenv("STGUIADDRESS") // legacy
-	guiAPIKey      = os.Getenv("STGUIAPIKEY")  // legacy
 	profiler       = os.Getenv("STPROFILER")
 	guiAssets      = os.Getenv("STGUIASSETS")
 	cpuProfile     = os.Getenv("STCPUPROFILE") != ""
@@ -226,6 +223,7 @@ func main() {
 		flag.StringVar(&logFile, "logfile", "-", "Log file name (use \"-\" for stdout)")
 	}
 
+	var guiAddress, guiAPIKey string
 	flag.StringVar(&generateDir, "generate", "", "Generate key and config in specified dir, then exit")
 	flag.StringVar(&guiAddress, "gui-address", guiAddress, "Override GUI address")
 	flag.StringVar(&guiAPIKey, "gui-apikey", guiAPIKey, "Override GUI API key")
@@ -246,6 +244,15 @@ func main() {
 	flag.Usage = usageFor(flag.CommandLine, usage, longUsage)
 	flag.Parse()
 
+	if guiAddress != "" {
+		// The config picks this up from the environment.
+		os.Setenv("STGUIADDRESS", guiAddress)
+	}
+	if guiAPIKey != "" {
+		// The config picks this up from the environment.
+		os.Setenv("STGUIAPIKEY", guiAPIKey)
+	}
+
 	if noConsole {
 		osutil.HideConsole()
 	}
@@ -362,7 +369,7 @@ func main() {
 
 		if doUpgrade {
 			// Use leveldb database locks to protect against concurrent upgrades
-			_, err = leveldb.OpenFile(locations[locDatabase], &opt.Options{OpenFilesCacheCapacity: 100})
+			_, err = db.Open(locations[locDatabase])
 			if err != nil {
 				l.Infoln("Attempting upgrade through running Syncthing...")
 				err = upgradeViaRest()
@@ -422,16 +429,13 @@ func upgradeViaRest() error {
 	if err != nil {
 		return err
 	}
-	target := cfg.GUI().Address
-	if cfg.GUI().UseTLS {
-		target = "https://" + target
-	} else {
-		target = "http://" + target
-	}
+	target := cfg.GUI().URL()
 	r, _ := http.NewRequest("POST", target+"/rest/system/upgrade", nil)
-	r.Header.Set("X-API-Key", cfg.GUI().APIKey)
+	r.Header.Set("X-API-Key", cfg.GUI().APIKey())
 
 	tr := &http.Transport{
+		Dial:            dialer.Dial,
+		Proxy:           http.ProxyFromEnvironment,
 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
 	}
 	client := &http.Client{
@@ -510,6 +514,7 @@ func syncthingMain() {
 
 	l.Infoln(LongVersion)
 	l.Infoln("My ID:", myID)
+	printHashRate()
 
 	// Emit the Starting event, now that we know who we are.
 
@@ -593,51 +598,45 @@ func syncthingMain() {
 
 	if (opts.MaxRecvKbps > 0 || opts.MaxSendKbps > 0) && !opts.LimitBandwidthInLan {
 		lans, _ = osutil.GetLans()
-		networks := make([]string, 0, len(lans))
-		for _, lan := range lans {
-			networks = append(networks, lan.String())
-		}
 		for _, lan := range opts.AlwaysLocalNets {
 			_, ipnet, err := net.ParseCIDR(lan)
 			if err != nil {
 				l.Infoln("Network", lan, "is malformed:", err)
 				continue
 			}
-			networks = append(networks, ipnet.String())
+			lans = append(lans, ipnet)
+		}
+
+		networks := make([]string, len(lans))
+		for i, lan := range lans {
+			networks[i] = lan.String()
 		}
 		l.Infoln("Local networks:", strings.Join(networks, ", "))
 	}
 
 	dbFile := locations[locDatabase]
-	dbOpts := dbOpts(cfg)
-	ldb, err := leveldb.OpenFile(dbFile, dbOpts)
-	if leveldbIsCorrupted(err) {
-		ldb, err = leveldb.RecoverFile(dbFile, dbOpts)
-	}
-	if leveldbIsCorrupted(err) {
-		// The database is corrupted, and we've tried to recover it but it
-		// didn't work. At this point there isn't much to do beyond dropping
-		// the database and reindexing...
-		l.Infoln("Database corruption detected, unable to recover. Reinitializing...")
-		if err := resetDB(); err != nil {
-			l.Fatalln("Remove database:", err)
-		}
-		ldb, err = leveldb.OpenFile(dbFile, dbOpts)
-	}
+	ldb, err := db.Open(dbFile)
 	if err != nil {
 		l.Fatalln("Cannot open database:", err, "- Is another copy of Syncthing already running?")
 	}
 
+	protectedFiles := []string{
+		locations[locDatabase],
+		locations[locConfigFile],
+		locations[locCertFile],
+		locations[locKeyFile],
+	}
+
 	// Remove database entries for folders that no longer exist in the config
 	folders := cfg.Folders()
-	for _, folder := range db.ListFolders(ldb) {
+	for _, folder := range ldb.ListFolders() {
 		if _, ok := folders[folder]; !ok {
 			l.Infof("Cleaning data for dropped folder %q", folder)
 			db.DropFolder(ldb, folder)
 		}
 	}
 
-	m := model.NewModel(cfg, myID, myName, "syncthing", Version, ldb)
+	m := model.NewModel(cfg, myID, myName, "syncthing", Version, ldb, protectedFiles)
 	cfg.Subscribe(m)
 
 	if t := os.Getenv("STDEADLOCKTIMEOUT"); len(t) > 0 {
@@ -830,6 +829,22 @@ func syncthingMain() {
 	os.Exit(code)
 }
 
+// printHashRate prints the hashing performance in MB/s, formatting it with
+// appropriate precision for the value, i.e. 182 MB/s, 18 MB/s, 1.8 MB/s, 0.18
+// MB/s.
+func printHashRate() {
+	hashRate := cpuBench(3, 100*time.Millisecond)
+
+	decimals := 0
+	if hashRate < 1 {
+		decimals = 2
+	} else if hashRate < 10 {
+		decimals = 1
+	}
+
+	l.Infof("Single thread hash performance is ~%.*f MB/s", decimals, hashRate)
+}
+
 func loadConfig(cfgFile string) (*config.Wrapper, string, error) {
 	info, err := os.Stat(cfgFile)
 	if err != nil {
@@ -853,40 +868,6 @@ func loadConfig(cfgFile string) (*config.Wrapper, string, error) {
 	return cfg, myName, nil
 }
 
-func dbOpts(cfg *config.Wrapper) *opt.Options {
-	// Calculate a suitable database block cache capacity.
-
-	// Default is 8 MiB.
-	blockCacheCapacity := 8 << 20
-	// Increase block cache up to this maximum:
-	const maxCapacity = 64 << 20
-	// ... which we reach when the box has this much RAM:
-	const maxAtRAM = 8 << 30
-
-	if v := cfg.Options().DatabaseBlockCacheMiB; v != 0 {
-		// Use the value from the config, if it's set.
-		blockCacheCapacity = v << 20
-	} else if bytes, err := memorySize(); err == nil {
-		// We start at the default of 8 MiB and use larger values for machines
-		// with more memory.
-
-		if bytes > maxAtRAM {
-			// Cap the cache at maxCapacity when we reach maxAtRam amount of memory
-			blockCacheCapacity = maxCapacity
-		} else if bytes > maxAtRAM/maxCapacity*int64(blockCacheCapacity) {
-			// Grow from the default to maxCapacity at maxAtRam amount of memory
-			blockCacheCapacity = int(bytes * maxCapacity / maxAtRAM)
-		}
-		l.Infoln("Database block cache capacity", blockCacheCapacity/1024, "KiB")
-	}
-
-	return &opt.Options{
-		OpenFilesCacheCapacity: 100,
-		BlockCacheCapacity:     blockCacheCapacity,
-		WriteBuffer:            4 << 20,
-	}
-}
-
 func startAuditing(mainSvc *suture.Supervisor) {
 	auditFile := timestampedLoc(locAuditLog)
 	fd, err := os.OpenFile(auditFile, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
@@ -910,75 +891,41 @@ func setupGUI(mainSvc *suture.Supervisor, cfg *config.Wrapper, m *model.Model, a
 	if !guiCfg.Enabled {
 		return
 	}
-	if guiCfg.Address == "" {
-		return
-	}
 
-	addr, err := net.ResolveTCPAddr("tcp", guiCfg.Address)
+	api, err := newAPISvc(myID, cfg, guiAssets, m, apiSub, discoverer, relaySvc, errors, systemLog)
 	if err != nil {
-		l.Fatalf("Cannot start GUI on %q: %v", guiCfg.Address, err)
-	} else {
-		var hostOpen, hostShow string
-		switch {
-		case addr.IP == nil:
-			hostOpen = "localhost"
-			hostShow = "0.0.0.0"
-		case addr.IP.IsUnspecified():
-			hostOpen = "localhost"
-			hostShow = addr.IP.String()
-		default:
-			hostOpen = addr.IP.String()
-			hostShow = hostOpen
-		}
+		l.Fatalln("Cannot start GUI:", err)
+	}
+	cfg.Subscribe(api)
+	mainSvc.Add(api)
 
-		var proto = "http"
-		if guiCfg.UseTLS {
-			proto = "https"
-		}
-
-		urlShow := fmt.Sprintf("%s://%s/", proto, net.JoinHostPort(hostShow, strconv.Itoa(addr.Port)))
-		l.Infoln("Starting web GUI on", urlShow)
-
-		api, err := newAPISvc(myID, cfg, guiAssets, m, apiSub, discoverer, relaySvc, errors, systemLog)
-		if err != nil {
-			l.Fatalln("Cannot start GUI:", err)
-		}
-		cfg.Subscribe(api)
-		mainSvc.Add(api)
-
-		if cfg.Options().StartBrowser && !noBrowser && !stRestarting {
-			urlOpen := fmt.Sprintf("%s://%s/", proto, net.JoinHostPort(hostOpen, strconv.Itoa(addr.Port)))
-			// Can potentially block if the utility we are invoking doesn't
-			// fork, and just execs, hence keep it in it's own routine.
-			go openURL(urlOpen)
-		}
+	if cfg.Options().StartBrowser && !noBrowser && !stRestarting {
+		// Can potentially block if the utility we are invoking doesn't
+		// fork, and just execs, hence keep it in it's own routine.
+		go openURL(guiCfg.URL())
 	}
 }
 
 func defaultConfig(myName string) config.Configuration {
+	defaultFolder := config.NewFolderConfiguration("default", locations[locDefFolder])
+	defaultFolder.RescanIntervalS = 60
+	defaultFolder.MinDiskFreePct = 1
+	defaultFolder.Devices = []config.FolderDeviceConfiguration{{DeviceID: myID}}
+	defaultFolder.AutoNormalize = true
+	defaultFolder.MaxConflicts = -1
+
+	thisDevice := config.NewDeviceConfiguration(myID, myName)
+	thisDevice.Addresses = []string{"dynamic"}
+
 	newCfg := config.New(myID)
-	newCfg.Folders = []config.FolderConfiguration{
-		{
-			ID:              "default",
-			RawPath:         locations[locDefFolder],
-			RescanIntervalS: 60,
-			MinDiskFreePct:  1,
-			Devices:         []config.FolderDeviceConfiguration{{DeviceID: myID}},
-		},
-	}
-	newCfg.Devices = []config.DeviceConfiguration{
-		{
-			DeviceID:  myID,
-			Addresses: []string{"dynamic"},
-			Name:      myName,
-		},
-	}
+	newCfg.Folders = []config.FolderConfiguration{defaultFolder}
+	newCfg.Devices = []config.DeviceConfiguration{thisDevice}
 
 	port, err := getFreePort("127.0.0.1", 8384)
 	if err != nil {
 		l.Fatalln("get free port (GUI):", err)
 	}
-	newCfg.GUI.Address = fmt.Sprintf("127.0.0.1:%d", port)
+	newCfg.GUI.RawAddress = fmt.Sprintf("127.0.0.1:%d", port)
 
 	port, err = getFreePort("0.0.0.0", 22000)
 	if err != nil {
@@ -1166,19 +1113,3 @@ func checkShortIDs(cfg *config.Wrapper) error {
 	}
 	return nil
 }
-
-// A "better" version of leveldb's errors.IsCorrupted.
-func leveldbIsCorrupted(err error) bool {
-	switch {
-	case err == nil:
-		return false
-
-	case errors.IsCorrupted(err):
-		return true
-
-	case strings.Contains(err.Error(), "corrupted"):
-		return true
-	}
-
-	return false
-}

cmd/syncthing/main_test.go

@@ -14,9 +14,6 @@ import (
 	"github.com/syncthing/syncthing/lib/db"
 	"github.com/syncthing/syncthing/lib/model"
 	"github.com/syncthing/syncthing/lib/protocol"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 func TestFolderErrors(t *testing.T) {
@@ -38,11 +35,11 @@ func TestFolderErrors(t *testing.T) {
 		}
 	}
 
-	ldb, _ := leveldb.Open(storage.NewMemStorage(), nil)
+	ldb := db.OpenMemory()
 
 	// Case 1 - new folder, directory and marker created
 
-	m := model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m := model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err != nil {
@@ -73,7 +70,7 @@ func TestFolderErrors(t *testing.T) {
 		Folders: []config.FolderConfiguration{fcfg},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err != nil {
@@ -96,7 +93,7 @@ func TestFolderErrors(t *testing.T) {
 		{Name: "dummyfile"},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder marker missing" {
@@ -127,7 +124,7 @@ func TestFolderErrors(t *testing.T) {
 		Folders: []config.FolderConfiguration{fcfg},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder path missing" {

cmd/syncthing/monitor.go

@@ -28,8 +28,10 @@ var (
 )
 
 const (
-	countRestarts = 4
-	loopThreshold = 60 * time.Second
+	countRestarts         = 4
+	loopThreshold         = 60 * time.Second
+	logFileAutoCloseDelay = 5 * time.Second
+	logFileMaxOpenTime    = time.Minute
 )
 
 func monitorMain() {
@@ -37,16 +39,10 @@ func monitorMain() {
 	os.Setenv("STMONITORED", "yes")
 	l.SetPrefix("[monitor] ")
 
-	var err error
 	var dst io.Writer = os.Stdout
 
 	if logFile != "-" {
-		var fileDst io.Writer
-
-		fileDst, err = os.Create(logFile)
-		if err != nil {
-			l.Fatalln("log file:", err)
-		}
+		var fileDst io.Writer = newAutoclosedFile(logFile, logFileAutoCloseDelay, logFileMaxOpenTime)
 
 		if runtime.GOOS == "windows" {
 			// Translate line breaks to Windows standard
@@ -262,3 +258,114 @@ func restartMonitorWindows(args []string) error {
 	cmd.Stdin = os.Stdin
 	return cmd.Start()
 }
+
+// An autoclosedFile is an io.WriteCloser that opens itself for appending on
+// Write() and closes itself after an interval of no writes (closeDelay) or
+// when the file has been open for too long (maxOpenTime). A call to Write()
+// will return any error that happens on the resulting Open() call too. Errors
+// on automatic Close() calls are silently swallowed...
+type autoclosedFile struct {
+	name        string        // path to write to
+	closeDelay  time.Duration // close after this long inactivity
+	maxOpenTime time.Duration // or this long after opening
+
+	fd         io.WriteCloser // underlying WriteCloser
+	opened     time.Time      // timestamp when the file was last opened
+	closed     chan struct{}  // closed on Close(), stops the closerLoop
+	closeTimer *time.Timer    // fires closeDelay after a write
+
+	mut sync.Mutex
+}
+
+func newAutoclosedFile(name string, closeDelay, maxOpenTime time.Duration) *autoclosedFile {
+	f := &autoclosedFile{
+		name:        name,
+		closeDelay:  closeDelay,
+		maxOpenTime: maxOpenTime,
+		mut:         sync.NewMutex(),
+		closed:      make(chan struct{}),
+		closeTimer:  time.NewTimer(time.Minute),
+	}
+	go f.closerLoop()
+	return f
+}
+
+func (f *autoclosedFile) Write(bs []byte) (int, error) {
+	f.mut.Lock()
+	defer f.mut.Unlock()
+
+	// Make sure the file is open for appending
+	if err := f.ensureOpen(); err != nil {
+		return 0, err
+	}
+
+	// If we haven't run into the maxOpenTime, postpone close for another
+	// closeDelay
+	if time.Since(f.opened) < f.maxOpenTime {
+		f.closeTimer.Reset(f.closeDelay)
+	}
+
+	return f.fd.Write(bs)
+}
+
+func (f *autoclosedFile) Close() error {
+	f.mut.Lock()
+	defer f.mut.Unlock()
+
+	// Stop the timer and closerLoop() routine
+	f.closeTimer.Stop()
+	close(f.closed)
+
+	// Close the file, if it's open
+	if f.fd != nil {
+		return f.fd.Close()
+	}
+
+	return nil
+}
+
+// Must be called with f.mut held!
+func (f *autoclosedFile) ensureOpen() error {
+	if f.fd != nil {
+		// File is already open
+		return nil
+	}
+
+	// We open the file for write only, and create it if it doesn't exist.
+	flags := os.O_WRONLY | os.O_CREATE
+	if f.opened.IsZero() {
+		// This is the first time we are opening the file. We should truncate
+		// it to better emulate an os.Create() call.
+		flags |= os.O_TRUNC
+	} else {
+		// The file was already opened once, so we should append to it.
+		flags |= os.O_APPEND
+	}
+
+	fd, err := os.OpenFile(f.name, flags, 0644)
+	if err != nil {
+		return err
+	}
+
+	f.fd = fd
+	f.opened = time.Now()
+	return nil
+}
+
+func (f *autoclosedFile) closerLoop() {
+	for {
+		select {
+		case <-f.closeTimer.C:
+			// Close the file when the timer expires.
+			f.mut.Lock()
+			if f.fd != nil {
+				f.fd.Close() // errors, schmerrors
+				f.fd = nil
+			}
+			f.mut.Unlock()
+
+		case <-f.closed:
+			return
+		}
+	}
+}

cmd/syncthing/usage_report.go

@@ -20,6 +20,7 @@ import (
 	"time"
 
 	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/dialer"
 	"github.com/syncthing/syncthing/lib/model"
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/upgrade"
@@ -111,15 +112,7 @@ func reportData(cfg *config.Wrapper, m *model.Model) map[string]interface{} {
 	var mem runtime.MemStats
 	runtime.ReadMemStats(&mem)
 	res["memoryUsageMiB"] = (mem.Sys - mem.HeapReleased) / 1024 / 1024
-
-	var perf float64
-	for i := 0; i < 5; i++ {
-		p := cpuBench()
-		if p > perf {
-			perf = p
-		}
-	}
-	res["sha256Perf"] = perf
+	res["sha256Perf"] = cpuBench(5, 125*time.Millisecond)
 
 	bytes, err := memorySize()
 	if err == nil {
@@ -208,7 +201,7 @@ func reportData(cfg *config.Wrapper, m *model.Model) map[string]interface{} {
 	defaultRelayServers, otherRelayServers := 0, 0
 	for _, addr := range cfg.Options().RelayServers {
 		switch addr {
-		case "dynamic+https://relays.syncthing.net":
+		case "dynamic+https://relays.syncthing.net/endpoint":
 			defaultRelayServers++
 		default:
 			otherRelayServers++
@@ -261,7 +254,7 @@ func (s *usageReportingService) sendUsageReport() error {
 	if BuildEnv == "android" {
 		// This works around the lack of DNS resolution on Android... :(
 		transp.Dial = func(network, addr string) (net.Conn, error) {
-			return net.Dial(network, "194.126.249.13:443")
+			return dialer.Dial(network, "194.126.249.13:443")
 		}
 	}
 
@@ -300,7 +293,17 @@ func (s *usageReportingService) Stop() {
 }
 
 // cpuBench returns CPU performance as a measure of single threaded SHA-256 MiB/s
-func cpuBench() float64 {
+func cpuBench(iterations int, duration time.Duration) float64 {
+	var perf float64
+	for i := 0; i < iterations; i++ {
+		if v := cpuBenchOnce(duration); v > perf {
+			perf = v
+		}
+	}
+	return perf
+}
+
+func cpuBenchOnce(duration time.Duration) float64 {
 	chunkSize := 100 * 1 << 10
 	h := sha256.New()
 	bs := make([]byte, chunkSize)
@@ -308,7 +311,7 @@ func cpuBench() float64 {
 
 	t0 := time.Now()
 	b := 0
-	for time.Since(t0) < 125*time.Millisecond {
+	for time.Since(t0) < duration {
 		h.Write(bs)
 		b += chunkSize
 	}

etc/linux-upstart/README.md

@@ -0,0 +1,16 @@
+# Upstart Configuration
+
+This directory contains example configuration files for running Syncthing under
+the "Upstart" service manager on Linux. To have syncthing start when you login
+place "user/syncthing.conf" in the "/home/[username]/.config/upstart/" folder.
+To have syncthing start when the system boots place "system/syncthing.conf"
+in the "/etc/init/" folder.
+To manualy start syncthing via Upstart when using the system configuration use:
+
+```
+    sudo initctl start syncthing
+```
+
+For further documentation see [http://docs.syncthing.net/users/autostart.html][1].
+
+[1]: http://docs.syncthing.net/users/autostart.html#Upstart

etc/linux-upstart/system/syncthing.conf

@@ -0,0 +1,13 @@
+description "Syncthing"
+
+start on (local-filesystems and net-device-up IFACE!=lo)
+stop on runlevel [!2345]
+
+env STNORESTART=yes
+env HOME=/home/$USER
+setuid "$USER"
+setgid "$USER"
+
+exec /usr/local/bin/syncthing
+
+respawn

etc/linux-upstart/user/syncthing.conf

@@ -0,0 +1,21 @@
+# Location of the syncthing executable
+env SYNCTHING_EXE="/usr/local/bin"
+
+# Set the name of the application
+description "Syncthing"
+
+# Start syncthing you login to your desktop
+start on desktop-start
+
+# Stop syncthing you logout of your desktop
+stop on desktop-end
+
+# Set STNORESTART to yes to have Upstart monitor the process instead
+# of having a separate syncthing process do the monitoring
+env STNORESTART=yes
+
+# If Upstart detects syncthing has failed - it should restart it
+respawn
+
+# the syncthing command Upstart is to execute when it is started up
+exec $SYNCTHING_EXE -no-browser

gui/assets/font/raleway.css

@@ -2,5 +2,5 @@
   font-family: 'Raleway';
   font-style: normal;
   font-weight: 500;
-  src: local('Raleway'), url(raleway-500.woff) format('woff');
+  src: local('Raleway Medium'), local('Raleway-Medium'), url(raleway-500.woff) format('woff');
 }

gui/assets/lang/lang-bg.json

@@ -1,8 +1,8 @@
 {
-    "A negative number of days doesn't make sense.": "Няма логика на зададен отрицателен брой дни.",
+    "A negative number of days doesn't make sense.": "Няма логика в задаването на отрицателен брой дни.",
     "A new major version may not be compatible with previous versions.": "Нова основна версия, която може да не е съвмеситима с предишни версии.",
     "API Key": "API Ключ",
-    "About": "За Програмата",
+    "About": "За програмата",
     "Actions": "Действия",
     "Add": "Добави",
     "Add Device": "Добави устройство",
@@ -13,35 +13,36 @@
     "Advanced": "Допълнителни",
     "Advanced Configuration": "Допълнителни настройки",
     "All Data": "Всички данни",
-    "Allow Anonymous Usage Reporting?": "Разреши анонимен доклад за ползване на програмата?",
+    "Allow Anonymous Usage Reporting?": "Разреши анонимно докладване за употребата на програмата?",
     "Alphabetic": "Азбучен ред",
     "An external command handles the versioning. It has to remove the file from the synced folder.": "Друга команда се занимава с версиите. Тази команда трябва да премахни файла от синхронизираната папка.",
-    "Anonymous Usage Reporting": "Анонимен Доклад",
+    "Anonymous Usage Reporting": "Анонимен доклад",
     "Any devices configured on an introducer device will be added to this device as well.": "Устройства настроени на introducer компютъра също ще бъдат добавени към този компютър.",
-    "Automatic upgrades": "Автоматични ъпдейти",
-    "Be careful!": "Внимавай!",
+    "Automatic upgrades": "Автоматично обновяване",
+    "Be careful!": "Внимание!",
     "Bugs": "Бъгове",
-    "CPU Utilization": "Натоварване на Процесора",
-    "Changelog": "Сипъск с промени",
+    "CPU Utilization": "Процесор в употреба",
+    "Changelog": "Списък с промени",
     "Clean out after": "Изчисти след",
     "Close": "Затвори",
     "Command": "Команда",
     "Comment, when used at the start of a line": "Коментар, използван в началото на реда",
-    "Compression": "Компресия",
-    "Connection Error": "Грешка при Свързването",
+    "Compression": "Компресиране",
+    "Connection Error": "Грешка при свързването",
     "Copied from elsewhere": "Копиране от някъде другаде",
     "Copied from original": "Копиран от оригинала",
-    "Copyright © 2015 the following Contributors:": "Правата запазени © 2015 Сътрудници:",
+    "Copyright © 2015 the following Contributors:": "Всички правата запазени © 2015 Сътрудници:",
     "Delete": "Изтрий",
     "Deleted": "Изтрито",
     "Device ID": "Идентификатор на устройство",
-    "Device Identification": "Идентификация на устройство",
+    "Device Identification": "Идентификатор на устройство",
     "Device Name": "Име на устройство",
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Устройство {{device}} ({{address}}) желае да се свърже. Добави ново устройство?",
     "Devices": "Устройства",
-    "Disconnected": "Прекрати Връзката",
+    "Disconnected": "Не е свързано",
+    "Discovery": "Откриване",
     "Documentation": "Документация",
-    "Download Rate": "Скорост на Теглене",
+    "Download Rate": "Скорост на сваляне",
     "Downloaded": "Изтеглен",
     "Downloading": "Изтегляне",
     "Edit": "Промени",
@@ -49,49 +50,49 @@
     "Edit Folder": "Промени папка",
     "Editing": "Променяне",
     "Enable UPnP": "Включи UPnP",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Въведи адреси разделени със запетая (\"tcp://ip:port\", \"tcp://host:port\") или \"dynamic\", за да извършиш автоматична връзка на адреси.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Въведете адреси разделени със запетая (\"tcp://ip:port\", \"tcp://host:port\") или \"dynamic\", за да автоматично откриване на наличните адреси.",
     "Enter ignore patterns, one per line.": "Добави шаблони за игнориране, по един на ред.",
     "Error": "Грешка",
-    "External File Versioning": "Външно упраление на версиите",
+    "External File Versioning": "Външно управление на версиите",
     "Failed Items": "Неуспешни",
-    "File Pull Order": "По ред на дърпане",
-    "File Versioning": "Файлови Версии",
-    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Битовете за права за достъп са игнорирани, когато се проверява за промени. Използвай с файлови системи тип FAT.",
+    "File Pull Order": "Ред на сваляне",
+    "File Versioning": "Версии на файловете",
+    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Битовете за права за достъп ще бъдат игнорирани, когато се проверява за промени. Ползвайте за файлови системи тип FAT.",
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Файловете биват преместени в .stversions папка, когато са заменен или изтрити от Syncthing.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Когато syncthing замени или изтрие файл той се премества в  .stversions и преименува с дабавени дата и час.",
-    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Файловете са защитени от промени направени на други устройства, но промени направени на това устройство ще бъдат синхронизирани с другите устройства.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Когато syncthing замени или изтрие файл той се премества в  .stversions и преименува с набавени дата и час.",
+    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Защитава файловете от промени направени на други устройства, но промените направени на това устройство ще бъдат синхронизирани с останалите устройства.",
     "Folder": "Папка",
-    "Folder ID": "Идентификатор на папка",
+    "Folder ID": "Идентификатор на папката",
     "Folder Master": "Главна папка",
     "Folder Path": "Път до папката",
     "Folders": "Папки",
-    "GUI": "Потребителски интефейс",
-    "GUI Authentication Password": "Парола за Потребителския Интерфейс",
-    "GUI Authentication User": "Потребител за Потребителския Интерфейс",
-    "GUI Listen Addresses": "Адрес за Свързване с Потребителския Интерфейс",
+    "GUI": "Потребителски интерфейс",
+    "GUI Authentication Password": "Парола за потребителския интерфейс",
+    "GUI Authentication User": "Потребител за потребителския интерфейс",
+    "GUI Listen Addresses": "Адрес за свързване с потребителския интерфейс",
     "Generate": "Генерирай",
-    "Global Discovery": "Глобавно Откриване",
-    "Global Discovery Server": "Сървър за Глобално Откриване",
+    "Global Discovery": "Глобално откриване",
+    "Global Discovery Server": "Сървър за глобално откриване",
     "Global State": "Глобално състояние",
     "Help": "Помощ",
     "Home page": "Начална страница",
     "Ignore": "Игнорирай",
-    "Ignore Patterns": "Шаблони за Игнориране",
-    "Ignore Permissions": "Игнорирай Права за Достъп",
-    "Incoming Rate Limit (KiB/s)": "Входящ Лимит на Скоростта (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Неправилни настройки могат да повредят съдържанието на папката и да попречат на по-нататъшно синхронизиране.",
+    "Ignore Patterns": "Шаблони за игнориране",
+    "Ignore Permissions": "Игнорирай правата за достъп",
+    "Incoming Rate Limit (KiB/s)": "Входящ лимит на скоростта (KiB/s)",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Неправилни настройки могат да повредят файловете и да попречат на синхронизирането.",
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Обратното на даденото условие (пр. не изключвай)",
-    "Keep Versions": "Пази Версии",
-    "Largest First": "Най-големите първо",
+    "Keep Versions": "Пази версии",
+    "Largest First": " Първо най-големите",
     "Last File Received": "Последния получен файл",
     "Last seen": "Последно видян",
     "Later": "По-късно",
-    "Local Discovery": "Локално Откриване",
+    "Local Discovery": "Локално откриване",
     "Local State": "Локално състояние",
-    "Local State (Total)": "Локално Състояние (Общо)",
+    "Local State (Total)": "Локално състояние (Общо)",
     "Major Upgrade": "Основно Обновяване",
-    "Maximum Age": "Максимална Възраст",
+    "Maximum Age": "Максимална възраст",
     "Metadata Only": "Само мета информация",
     "Minimum Free Disk Space": "Минимално свободно дисково пространство",
     "Move to top of queue": "Премести в началото на опашката",
@@ -99,66 +100,66 @@
     "Never": "Никога",
     "New Device": "Ново устройство",
     "New Folder": "Нова папка",
-    "Newest First": "Най-новите първо",
+    "Newest First": "Първо най-новите",
     "No": "Не",
-    "No File Versioning": "Няма Файлови Версии",
+    "No File Versioning": "Без версии",
     "Notice": "Известие",
     "OK": "ОК",
     "Off": "Изключено",
-    "Oldest First": "Най-старите първо",
+    "Oldest First": "Първо най-старите",
     "Options": "Настройки",
-    "Out of Sync": "Не синхронизиран",
+    "Out of Sync": "Несинхронизирано",
     "Out of Sync Items": "Несинхронизирани елементи",
-    "Outgoing Rate Limit (KiB/s)": "Лимит на Изходящата Скорост (KiB/s)",
-    "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": "Пътят до папката на този компютър. Ще бъде създадена ако не съществува. Символът тилда (~) може да бъде използван като заместител на",
+    "Outgoing Rate Limit (KiB/s)": "Лимит на изходящата скорост (KiB/s)",
+    "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 where versions should be stored (leave empty for the default .stversions folder in the folder).": "Пътят, където версиите да бъдат складирани(остави празно за папката .stversions).",
     "Pause": "Пауза",
     "Paused": "На пауза",
     "Please consult the release notes before performing a major upgrade.": "Моля прочети бележките по обновяването преди да започнеш.",
     "Please wait": "Моля изчакай",
     "Preview": "Преглед",
-    "Preview Usage Report": "Разгледай Доклада за Използване",
+    "Preview Usage Report": "Разгледай доклада за използване",
     "Quick guide to supported patterns": "Бърз наръчник към поддържаните шаблони",
-    "RAM Utilization": "RAM Натоварване",
-    "Random": "Произволно",
+    "RAM Utilization": "RAM в употреба",
+    "Random": "Произволен",
     "Relayed via": "Препратено през",
     "Relays": "Препращачи",
     "Release Notes": "Бележки по обновяването",
     "Remove": "Премахни",
-    "Rescan": "Повторно Сканиране",
-    "Rescan All": "Пълно повторно сканиране",
-    "Rescan Interval": "Интервал за Повторно Сканиране",
+    "Rescan": "Сканирай повторно",
+    "Rescan All": "Сканирай повторно всички",
+    "Rescan Interval": "Интервал за повторно сканиране",
     "Restart": "Рестартирай",
-    "Restart Needed": "Изискава се Рестартиране",
+    "Restart Needed": "Изисква се рестартиране",
     "Restarting": "Рестартиране",
     "Resume": "Пусни",
     "Reused": "Повторно използван",
     "Save": "Запази",
     "Scanning": "Сканиране",
-    "Select the devices to share this folder with.": "Избери устройствата, с които да споделиш тази папка.",
+    "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 With Devices": "Споделяне с устройства",
     "Share this folder?": "Сподели тази папка?",
-    "Shared With": "Споделена със",
-    "Short identifier for the folder. Must be the same on all cluster devices.": "Кратък идентификатор на папката. Трябва да бъде същият на всички компютри.",
-    "Show ID": "Покажи Идентификатора",
+    "Shared With": "Споделена с",
+    "Short identifier for the folder. Must be the same on all cluster devices.": "Идентификаторът на папката трябва да бъде еднакъв на всички устройства.",
+    "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 updated to the name the device advertises if left empty.": "Покажи вместо идентификатор на устройството в статус на клъстъра. Ще бъде обновено с името по подразбиране изпратено от другия компютър.",
-    "Shutdown": "Спри Програмата",
+    "Shutdown": "Спри програмата",
     "Shutdown Complete": "Спирането завършено",
-    "Simple File Versioning": "Опростени Файлови Версии",
+    "Simple File Versioning": "Опростени версии",
     "Single level wildcard (matches within a directory only)": "Маска на едно ниво (покрива само в папка)",
-    "Smallest First": "Най-малките първо",
-    "Source Code": "Сорс Код",
-    "Staggered File Versioning": "Наслагващи се Файлови Версии",
-    "Start Browser": "Стартирай Браузъра",
+    "Smallest First": "Първо най-малките",
+    "Source Code": "Сорс код",
+    "Staggered File Versioning": "Наслагващи се версии",
+    "Start Browser": "Стартирай браузъра",
     "Statistics": "Статистика",
-    "Stopped": "Спряна",
+    "Stopped": "Без синхронизиране",
     "Support": "Помощ",
     "Sync Protocol Listen Addresses": "Адрес за слушане на синхронизиращия протокол",
     "Syncing": "Синхронизиране",
@@ -171,12 +172,12 @@
     "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.": "Полето идентификатор на устройство не може да бъде празно.",
-    "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).": "Идентификатор на устройство за въвеждане тук, може да бъде намерен в \"Промени > Покажи Идентификатора\". Интервалите и тиретата са пожелание(биват прескачани).",
-    "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.": "Криптираният доклад се изпраща дневно. Използва се, за да следи общи платформи, размери на папки и версии на приложението. Ако събираните данни се променят, ще бъдете информиран с подобен на този диалог.",
-    "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.": "Въведни идентификатор на устройство не е валиден. Трябва да бъде 52 или 56 символа и да се състои от букви и цифри, като интервалите и тиретата са пожелание.",
+    "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).": "Идентификатор на устройство за въвеждане тук, може да бъде намерен в \"Промени > Покажи идентификатора\". Интервалите и тиретата са пожелание (биват прескачани).",
+    "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.": "Криптираният доклад се изпраща ежедневно. Използва се, за отичане на ползваните платформи, размер на папки и версии на приложението. Ако събираните данни се променят, ще бъдете информиран с подобен на този диалог.",
+    "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.": "Въведеният идентификатор на устройство не е валиден. Трябва да бъде 52 или 56 символа и да се състои от букви и цифри, като интервалите и тиретата са пожелание.",
     "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "Първият параметър за командата е пътя до папката, а вторият е релативния път в самата папка.",
-    "The folder ID cannot be blank.": "Полето идентификатор на папка неможе да бъде празно.",
-    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "Идентификаторът на папка трябва да бъде къс (64 символа или по-малко) състоящ се само от букви, цифри, точка(.), тире(-) и подчерта (_).",
+    "The folder ID cannot be blank.": "Полето идентификатор на папка не може да бъде празно.",
+    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "Идентификаторът на папка трябва да бъде къс (64 символа или по-малко) състоящ се само от букви, цифри, точка (.), тире (-) и подчерта (_).",
     "The folder ID must be unique.": "Идентификаторът на папката тряба да бъде уникален.",
     "The folder path cannot be blank.": "Пътят до папката не може да бъде празен.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Използва се следния интервал: за първия час се пази версия всеки 30 секунди, за първия ден се пази версия всеки час, за първите 30 дена се пази версия всеки ден, до максимума се пази една версия всяка седмица.",
@@ -184,29 +185,29 @@
     "The maximum age must be a number and cannot be blank.": "Максималната възраст трябва да е число и не може д ае празна.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Максималното време да се пазят весрсии (в дни, сложи 0, за да пазиш версии завинаги).",
     "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Минималното свободно дисково пространство в проценти трябва да е между 0 и 100 (включително).",
-    "The number of days must be a number and cannot be blank.": "Броят дни трябва да бъде число и неможе да бъде празно.",
+    "The number of days must be a number and cannot be blank.": "Броят дни трябва да бъде число и не може да бъде празно.",
     "The number of days to keep files in the trash can. Zero means forever.": "Броят дни за запазване на файловете в кошчето. Нула значи завинаги.",
     "The number of old versions to keep, per file.": "Броят стари версии, които да бъдат пазени за всеки файл.",
     "The number of versions must be a number and cannot be blank.": "Броят версии трябва да бъде число и не може да бъде празно.",
-    "The path cannot be blank.": "Пътят неможе да бъде празен.",
-    "The rate limit must be a non-negative number (0: no limit)": "Ограничението на скорста трябва да бъде положително число (0: неограничено)",
+    "The path cannot be blank.": "Пътят не може да бъде празен.",
+    "The rate limit must be a non-negative number (0: no limit)": "Ограничението на скоростта трябва да бъде положително число (0: неограничено)",
     "The rescan interval must be a non-negative number of seconds.": "Интервала на сканиране трябва да бъде не отрицателно число в секунди.",
     "They are retried automatically and will be synced when the error is resolved.": "Ще бъдат спрени и автоматично синхронизирани, когато грешката бъде оправена.",
     "This is a major version upgrade.": "Това е нова основна версия.",
-    "Trash Can File Versioning": "Версии на файлове в кошчето",
-    "Unknown": "Неясен",
-    "Unshared": "Споделянето прекратено",
+    "Trash Can File Versioning": "Само на файловете в кошчето",
+    "Unknown": "Неясно",
+    "Unshared": "Несподелена",
     "Unused": "Неизползван",
-    "Up to Date": "Актуален",
+    "Up to Date": "Синхронизирано",
     "Updated": "Обновено",
     "Upgrade": "Обнови",
-    "Upgrade To {%version%}": "Обновен До {{version}}",
+    "Upgrade To {%version%}": "Обновен до {{version}}",
     "Upgrading": "Обновяване",
-    "Upload Rate": "Скорост на Качване",
-    "Uptime": "Работи вече",
-    "Use HTTPS for GUI": "Използвай HTTPS за Потребителския Интерфейс",
+    "Upload Rate": "Скорост на качване",
+    "Uptime": "Работи от",
+    "Use HTTPS for GUI": "Използвай HTTPS за потребителския интерфейс",
     "Version": "Версия",
-    "Versions Path": "Път до Версиите",
+    "Versions Path": "Път до версиите",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Версиите биват изтривани автоматично, когато са по-стари от максималната възраст или надминават броя файлове разрешени в даден интервал.",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "Когато добавяш ново устройство помни, че твоето устройство също трябва да бъде добавено от другата страна.",
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Когато добавяш нов идентификатор на папка помни, че той се използва за свързване на папките на различни устройства. Главни/малки букви са от значение и трябва да са еднакви на всички устройства.",
@@ -214,6 +215,6 @@
     "You must keep at least one version.": "Трябва да пазиш поне една версия.",
     "days": "дни",
     "full documentation": "пълна документация",
-    "items": "артикула",
+    "items": "елемента",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} желае да сподели папка \"{{folder}}\"."
 }

gui/assets/lang/lang-ca.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "El dispositiu {{device}} ({{address}}) vol conectar-se. Afegir nou dispositiu?",
     "Devices": "Dispositius",
     "Disconnected": "Desconnectat",
+    "Discovery": "Discovery",
     "Documentation": "Documentació",
     "Download Rate": "Tasca de descarrega",
     "Downloaded": "Descarregat",

gui/assets/lang/lang-ca@valencia.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "El dispositiu {{device}} ({{address}}) vol connectar-se. Afegir nou dispositiu?",
     "Devices": "Dispositius",
     "Disconnected": "Desconnectat",
+    "Discovery": "Discovery",
     "Documentation": "Documentació",
     "Download Rate": "Velocitat de descàrrega",
     "Downloaded": "Descarregat",

gui/assets/lang/lang-cs.json

@@ -40,6 +40,7 @@
     "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": "Odpojen",
+    "Discovery": "Oznamování",
     "Documentation": "Dokumentace",
     "Download Rate": "Rychlost stahování",
     "Downloaded": "Staženo",
@@ -79,7 +80,7 @@
     "Ignore Patterns": "Ignorované vzory",
     "Ignore Permissions": "Ignorovat oprávnění",
     "Incoming Rate Limit (KiB/s)": "Omezení příchozí rychlosti (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Nesprávné nastavení může poškodit obsah Vašich složek a učinit Syncthing nefunkční.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Nesprávné nastavení může poškodit obsah Vašich adresářů a učinit Syncthing nefunkční.",
     "Introducer": "Zavaděč",
     "Inversion of the given condition (i.e. do not exclude)": "Prohození zadané podmínky (např. nevynechat)",
     "Keep Versions": "Ponechat verze",

gui/assets/lang/lang-de.json

@@ -40,8 +40,9 @@
     "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",
+    "Discovery": "Gerätesuche",
     "Documentation": "Dokumentation",
-    "Download Rate": "Download-Rate",
+    "Download Rate": "Download",
     "Downloaded": "Heruntergeladen",
     "Downloading": "Lädt herunter",
     "Edit": "Bearbeiten",
@@ -89,7 +90,7 @@
     "Later": "Später",
     "Local Discovery": "Lokale Gerätesuche",
     "Local State": "Lokaler Status",
-    "Local State (Total)": "Lokaler Status (total)",
+    "Local State (Total)": "Lokaler Status (Gesamt)",
     "Major Upgrade": "Hauptversionsupgrade",
     "Maximum Age": "Höchstalter",
     "Metadata Only": "Nur Metadaten",
@@ -148,7 +149,7 @@
     "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",
     "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Wird anstatt der Geräte ID angezeigt. Wird als optionaler Gerätename an die anderen Clients im Cluster weitergegeben.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Wird anstatt der Geräte ID im Verbunds-Status angezeigt.Wird auf den Namen aktualisiert, den das Gerät angibt, wenn nichts eingetragen wird.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Wird auf diesem Gerät als Gerätename angezeigt und an die anderen Geräte im Geräte-Verbund weitergegeben. Wenn kein Gerätename anegegeben wird, wird der Name des entfernten Gerätes genommen.",
     "Shutdown": "Herunterfahren",
     "Shutdown Complete": "Vollständig Heruntergefahren",
     "Simple File Versioning": "Einfache Dateiversionierung",

gui/assets/lang/lang-el.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Η συσκευή {{device}} ({{address}}) επιθυμεί να συνδεθεί. Προσθήκη της νέας συσκευής1",
     "Devices": "Συσκευές",
     "Disconnected": "Αποσυνδεδεμένος",
+    "Discovery": "Discovery",
     "Documentation": "Τεκμηρίωση",
     "Download Rate": "Ταχύτητα λήψης",
     "Downloaded": "Έχει ληφθεί",

gui/assets/lang/lang-en-GB.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
     "Devices": "Devices",
     "Disconnected": "Disconnected",
+    "Discovery": "Discovery",
     "Documentation": "Documentation",
     "Download Rate": "Download Rate",
     "Downloaded": "Downloaded",

gui/assets/lang/lang-en.json

@@ -40,6 +40,7 @@
    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
    "Devices": "Devices",
    "Disconnected": "Disconnected",
+   "Discovery": "Discovery",
    "Documentation": "Documentation",
    "Download Rate": "Download Rate",
    "Downloaded": "Downloaded",

gui/assets/lang/lang-es-ES.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "El dispositivo {{device}} ({{address}}) quiere conectarse. ¿Añadir nuevo dispositivo?",
     "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
+    "Discovery": "Discovery",
     "Documentation": "Documentación",
     "Download Rate": "Velocidad de descarga",
     "Downloaded": "Descargado",

gui/assets/lang/lang-es.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "El dispositivo {{device}} ({{address}}) se quiere conectar. ¿Agregar nuevo dispositivo?",
     "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
+    "Discovery": "Discovery",
     "Documentation": "Documentación",
     "Download Rate": "Tasa de descarga",
     "Downloaded": "Descargado",
@@ -74,12 +75,12 @@
     "Global Discovery Server": "Servidor global de identificación",
     "Global State": "Estado global",
     "Help": "Ayuda",
-    "Home page": "Home page",
+    "Home page": "Pagina de inicio",
     "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)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Incorrect configuration may damage your folder contents and render Syncthing inoperable.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Configuración incorrecta puede dañar los contenidos de la carpeta y hacer Syncthing inoperable.",
     "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",
@@ -93,7 +94,7 @@
     "Major Upgrade": "Actualización mayor",
     "Maximum Age": "Edad máxima",
     "Metadata Only": "Sólo metadatos",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "Espacio mínimo libre en disco",
     "Move to top of queue": "Mover al principio de la cola.",
     "Multi level wildcard (matches multiple directory levels)": "Carácter comodín multinivel (coincide en el directorio y  sus subdirectorios)",
     "Never": "Nunca",
@@ -122,8 +123,8 @@
     "Quick guide to supported patterns": "Guía rápida sobre los patrones soportados",
     "RAM Utilization": "Utilización de RAM",
     "Random": "Aleatorio",
-    "Relayed via": "Relayed via",
-    "Relays": "Relays",
+    "Relayed via": "retransmitida vía",
+    "Relays": "Relés",
     "Release Notes": "Notas de lanzamiento",
     "Remove": "Eliminar",
     "Rescan": "Reescanear",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Al agregar un nuevo repositorio, tenga en cuenta que la ID del repositorio se utiliza para conectar los repositorios entre dispositivos. Se distingue entre mayúsculas y minúsculas y debe ser exactamente igual en todos los dispositivos.",
     "Yes": "Sí",
     "You must keep at least one version.": "Debe mantener al menos una versión",
-    "days": "days",
+    "days": "días",
     "full documentation": "documentación completa",
     "items": "ítems",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} quiere compartir repositorio \"{{folder}}\"."

gui/assets/lang/lang-fi.json

@@ -1,5 +1,5 @@
 {
-    "A negative number of days doesn't make sense.": "A negative number of days doesn't make sense.",
+    "A negative number of days doesn't make sense.": "Negatiivinen määrä päiviä ei ole järjellinen.",
     "A new major version may not be compatible with previous versions.": "A new major version may not be compatible with previous versions.",
     "API Key": "API-avain",
     "About": "Tietoja",
@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Laite {{device}} ({{address}}) haluaa yhdistää. Lisää uusi laite?",
     "Devices": "Laitteet",
     "Disconnected": "Yhteys katkaistu",
+    "Discovery": "Discovery",
     "Documentation": "Dokumentaatio",
     "Download Rate": "Latausmäärä",
     "Downloaded": "Ladattu",
@@ -49,7 +50,7 @@
     "Edit Folder": "Muokkaa kansiota",
     "Editing": "Muokkaus",
     "Enable UPnP": "Ota UPnP käyttöön",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Syötä osoitteet pilkuilla erotettuina (\"tcp://ip:portti, tcp://nimi:portti\") tai \"dynamic\" käyttääksesi osoitteen automaattista selvitystä.",
     "Enter ignore patterns, one per line.": "Syötä ohituslausekkeet, yksi riviä kohden.",
     "Error": "Virhe",
     "External File Versioning": "Ulkoinen tiedostoversionti",
@@ -57,10 +58,10 @@
     "File Pull Order": "File Pull Order",
     "File Versioning": "Tiedostoversiointi",
     "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Tiedostojen oikeusbitit jätetään huomiotta etsittäessä muutoksia. Käytä FAT-tiedostojärjestelmissä.",
-    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Files are moved to .stversions folder when replaced or deleted by Syncthing.",
+    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Kun Syncthing poistaa tai korvaa tiedostoja, ne siirretään .stversions-hakemistoon.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Tiedostot siirretään päivämäärällä merkityiksi versioiksi .stversions-kansioon, kun Syncthing korvaa tai poistaa ne.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Tiedostot on suojattu muilla laitteilla tehdyiltä muutoksilta, mutta tällä laitteella tehdyt muutokset lähetetään muuhun ryhmään.",
-    "Folder": "Folder",
+    "Folder": "Kansio",
     "Folder ID": "Kansion ID",
     "Folder Master": "Hallitsijakansio",
     "Folder Path": "Kansion polku",
@@ -93,7 +94,7 @@
     "Major Upgrade": "Major Upgrade",
     "Maximum Age": "Maksimi-ikä",
     "Metadata Only": "Vain metadata",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "Vapaan levytilan vähimmäismäärä",
     "Move to top of queue": "Siirrä jonon alkuun",
     "Multi level wildcard (matches multiple directory levels)": "Monitasoinen jokerimerkki (vaikuttaa useassa kansiotasossa)",
     "Never": "Ei koskaan",
@@ -113,8 +114,8 @@
     "Override Changes": "Ohita muutokset",
     "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": "Polku kansioon paikallisella tietokoneella. Kansio luodaan, ellei sitä ole olemassa. Tilde-merkkiä (~) voidaan käyttää oikotienä polulle",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Polku jonne versiot tullaan tallentamaan (jätä tyhjäksi oletusvalintaa .stversions varten).",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "Keskeytä",
+    "Paused": "Keskeytetty",
     "Please consult the release notes before performing a major upgrade.": "Please consult the release notes before performing a major upgrade.",
     "Please wait": "Ole hyvä ja odota",
     "Preview": "Esikatselu",
@@ -123,16 +124,16 @@
     "RAM Utilization": "RAM:n käyttö",
     "Random": "Satunnaien",
     "Relayed via": "Relayed via",
-    "Relays": "Relays",
-    "Release Notes": "Release Notes",
-    "Remove": "Remove",
+    "Relays": "Välityspalvelimet",
+    "Release Notes": "Julkaisutiedot",
+    "Remove": "Poista",
     "Rescan": "Skannaa uudelleen",
     "Rescan All": "Skannaa kaikki uudelleen",
     "Rescan Interval": "Uudelleenskannauksen aikaväli",
     "Restart": "Käynnistä uudelleen",
     "Restart Needed": "Uudelleenkäynnistys tarvitaan",
     "Restarting": "Käynnistetään uudelleen",
-    "Resume": "Resume",
+    "Resume": "Jatka",
     "Reused": "Uudelleenkäytetty",
     "Save": "Tallenna",
     "Scanning": "Skannataan",
@@ -153,11 +154,11 @@
     "Shutdown Complete": "Sammutus valmis",
     "Simple File Versioning": "Yksinkertainen tiedostoversiointi",
     "Single level wildcard (matches within a directory only)": "Yksitasoinen jokerimerkki (vaikuttaa vain kyseisen kansion sisällä)",
-    "Smallest First": "Smallest First",
+    "Smallest First": "Pienin ensin",
     "Source Code": "Lähdekoodi",
     "Staggered File Versioning": "Porrastettu tiedostoversiointi",
     "Start Browser": "Käynnistä selain",
-    "Statistics": "Statistics",
+    "Statistics": "Tilastot",
     "Stopped": "Pysäytetty",
     "Support": "Tuki",
     "Sync Protocol Listen Addresses": "Synkronointiprotokollan kuunteluosoite",
@@ -180,16 +181,16 @@
     "The folder ID must be unique.": "Kansion ID:n tulee olla uniikki.",
     "The folder path cannot be blank.": "Kansion polku ei voi olla tyhjä.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Seuraavat aikavälit ovat käytössä: ensimmäisen tunnin ajalta uusi versio säilytetään joka 30 sekunti, ensimmäisen päivän ajalta uusi versio säilytetään tunneittain ja ensimmäisen 30 päivän aikana uusi versio säilytetään päivittäin. Lopulta uusi versio säilytetään viikoittain, kunnes maksimi-ikä saavutetaan.",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
+    "The following items could not be synchronized.": "Seuraavia nimikkeitä ei voitu synkronoida.",
     "The maximum age must be a number and cannot be blank.": "Maksimi-iän tulee olla numero, eikä se voi olla tyhjä.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Maksimiaika versioiden säilytykseen (päivissä, aseta 0 säilyttääksesi versiot ikuisesti).",
-    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
-    "The number of days must be a number and cannot be blank.": "The number of days must be a number and cannot be blank.",
-    "The number of days to keep files in the trash can. Zero means forever.": "The number of days to keep files in the trash can. Zero means forever.",
+    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Vapaan levytilan vähimmäismäärä prosentteina tulee olla positiivinen luku (suljetulta) väliltä 0-100.",
+    "The number of days must be a number and cannot be blank.": "Päivien määrän tulee olla numero, eikä se voi olla tyhjä.",
+    "The number of days to keep files in the trash can. Zero means forever.": "Montako päivää tiedostoja säilytetään roskakorissa. Nolla (0) = ikuisesti.",
     "The number of old versions to keep, per file.": "Säilytettävien vanhojen versioiden määrä tiedostoa kohden.",
     "The number of versions must be a number and cannot be blank.": "Versioiden määrän rulee olla numero, eikä se voi olla tyhjä.",
     "The path cannot be blank.": "Polku ei voi olla tyhjä.",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
+    "The rate limit must be a non-negative number (0: no limit)": "Nopeusrajan tulee olla positiivinen luku tai nolla. (0: ei rajaa)",
     "The rescan interval must be a non-negative number of seconds.": "Uudelleenskannauksen aikavälin tulee olla ei-negatiivinen numero sekunteja.",
     "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
     "This is a major version upgrade.": "This is a major version upgrade.",
@@ -203,7 +204,7 @@
     "Upgrade To {%version%}": "Päivitä versioon {{version}}",
     "Upgrading": "Päivitetään",
     "Upload Rate": "Lähetysmäärä",
-    "Uptime": "Uptime",
+    "Uptime": "Päälläoloaika",
     "Use HTTPS for GUI": "Käytä HTTPS:ää GUI:n kanssa",
     "Version": "Versio",
     "Versions Path": "Versioiden polku",

gui/assets/lang/lang-fr-CA.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "L'appareil {{device}} ({{address}}) veut se connecter. Voulez-vous ajouter cette appareil ?",
     "Devices": "Appareil",
     "Disconnected": "Déconnecté",
+    "Discovery": "Discovery",
     "Documentation": "Documentation",
     "Download Rate": "Débit de réception",
     "Downloaded": "Téléchargé",

gui/assets/lang/lang-fr.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "L'appareil {{device}} ({{address}}) veut se connecter. Voulez-vous ajouter cette appareil ?",
     "Devices": "Appareil",
     "Disconnected": "Déconnecté",
+    "Discovery": "Discovery",
     "Documentation": "Documentation",
     "Download Rate": "Débit de réception",
     "Downloaded": "Téléchargé",

gui/assets/lang/lang-hu.json

@@ -31,7 +31,7 @@
     "Connection Error": "Kapcsolódási hiba",
     "Copied from elsewhere": "Másolva máshonnan",
     "Copied from original": "Másolva az eredetiről",
-    "Copyright © 2015 the following Contributors:": "Copyright © 2015 az alábbi Közreműködők",
+    "Copyright © 2015 the following Contributors:": "Copyright © 2015 az alábbi Közreműködők:",
     "Delete": "Törlés",
     "Deleted": "Törölve",
     "Device ID": "Eszköz azonosító",
@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "{{device}} ({{address}}) csatlakozni szeretne. Hozzáadod az új eszközt?",
     "Devices": "Eszközök",
     "Disconnected": "Kapcsolat bontva",
+    "Discovery": "Felfedezés",
     "Documentation": "Dokumentáció",
     "Download Rate": "Letöltési sebesség",
     "Downloaded": "Letöltve",

gui/assets/lang/lang-it.json

@@ -10,8 +10,8 @@
     "Add new folder?": "Aggiungere una nuova cartella?",
     "Address": "Indirizzo",
     "Addresses": "Indirizzi",
-    "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
+    "Advanced": "Avanzato",
+    "Advanced Configuration": "Configurazione avanzata",
     "All Data": "Tutti i Dati",
     "Allow Anonymous Usage Reporting?": "Abilitare Statistiche Anonime di Utilizzo?",
     "Alphabetic": "Alfabetico",
@@ -19,7 +19,7 @@
     "Anonymous Usage Reporting": "Statistiche Anonime di Utilizzo",
     "Any devices configured on an introducer device will be added to this device as well.": "Qualsiasi dispositivo configurato in un introduttore verrà aggiunto anche a questo dispositivo.",
     "Automatic upgrades": "Aggiornamenti automatici",
-    "Be careful!": "Be careful!",
+    "Be careful!": "Fai attenzione!",
     "Bugs": "Bug",
     "CPU Utilization": "Utilizzo CPU",
     "Changelog": "Changelog",
@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Il dispositivo {{device}} ({{address}}) chiede di connettersi. Aggiungere il nuovo dispositivo?",
     "Devices": "Dispositivi",
     "Disconnected": "Disconnesso",
+    "Discovery": "Individuazione",
     "Documentation": "Documentazione",
     "Download Rate": "Velocità Download",
     "Downloaded": "Scaricato",
@@ -49,23 +50,23 @@
     "Edit Folder": "Modifica Cartella",
     "Editing": "Modifica di",
     "Enable UPnP": "Attiva UPnP",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Inserisci indirizzi separati da virgola (\"tcp://ip:porta\", \"tcp://host:porta\")  oppure \"dynamic\" per effettuare il rilevamento automatico dell'indirizzo.",
     "Enter ignore patterns, one per line.": "Inserisci gli schemi di esclusione, uno per riga.",
     "Error": "Errore",
     "External File Versioning": "Controllo Versione Esterno",
-    "Failed Items": "Failed Items",
+    "Failed Items": "Elementi errati",
     "File Pull Order": "Ordine di prelievo dei file",
     "File Versioning": "Controllo Versione dei File",
     "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Il software evita i bit dei permessi dei file durante il controllo delle modifiche. Utilizzato nei filesystem FAT.",
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "I file sono spostati nella certella .stversions quando vengono sostituiti o cancellati da Syncthing.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "I file sostituiti o eliminati da Syncthing vengono datati e spostati in una cartella .stversions.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "I file sono protetti dalle modifiche effettuate negli altri dispositivi, ma le modifiche effettuate in questo dispositivo verranno inviate anche al resto del cluster.",
-    "Folder": "Folder",
+    "Folder": "Cartella",
     "Folder ID": "ID Cartella",
     "Folder Master": "Cartella Principale",
     "Folder Path": "Percorso Cartella",
     "Folders": "Cartelle",
-    "GUI": "GUI",
+    "GUI": "Interfaccia grafica utente",
     "GUI Authentication Password": "Password di Autenticazione dell'Utente",
     "GUI Authentication User": "Utente dell'Interfaccia Grafica",
     "GUI Listen Addresses": "Indirizzi dell'Interfaccia Grafica",
@@ -74,12 +75,12 @@
     "Global Discovery Server": "Server di Ricerca Globale",
     "Global State": "Stato Globale",
     "Help": "Aiuto",
-    "Home page": "Home page",
+    "Home page": "Pagina home",
     "Ignore": "Ignora",
     "Ignore Patterns": "Schemi Esclusione File",
     "Ignore Permissions": "Ignora Permessi",
     "Incoming Rate Limit (KiB/s)": "Limite Velocità in Ingresso (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Incorrect configuration may damage your folder contents and render Syncthing inoperable.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Una configurazione incorretta potrebbe danneggiare il contenuto delle cartelle e rendere Syncthing inoperativo.",
     "Introducer": "Introduttore",
     "Inversion of the given condition (i.e. do not exclude)": "Inversione della condizione indicata (ad es. non escludere)",
     "Keep Versions": "Versioni Mantenute",
@@ -93,7 +94,7 @@
     "Major Upgrade": "Aggiornamento principale",
     "Maximum Age": "Durata Massima",
     "Metadata Only": "Solo i Metadati",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "Minimo spazio libero su disco",
     "Move to top of queue": "Posiziona in cima alla coda",
     "Multi level wildcard (matches multiple directory levels)": "Metacarattere multi-livello (corrisponde alle cartelle e alle sotto-cartelle)",
     "Never": "Mai",
@@ -106,15 +107,15 @@
     "OK": "OK",
     "Off": "Disattiva",
     "Oldest First": "Prima il meno recente",
-    "Options": "Options",
-    "Out of Sync": "Out of Sync",
+    "Options": "Opzioni",
+    "Out of Sync": "Non sincronizzato",
     "Out of Sync Items": "Elementi Non Sincronizzati",
     "Outgoing Rate Limit (KiB/s)": "Limite Velocità in Uscita (KiB/s)",
     "Override Changes": "Ignora Modifiche",
     "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": "Percorso della cartella nel computer locale. Verrà creata se non esiste già. Il carattere tilde (~) può essere utilizzato come scorciatoia per",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Percorso di salvataggio delle versioni (lasciare vuoto per utilizzare la cartella predefinita .stversions in questa cartella).",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "Pausa",
+    "Paused": "In pausa",
     "Please consult the release notes before performing a major upgrade.": "Si prega di consultare le note di rilascio prima di eseguire un aggiornamento principale.",
     "Please wait": "Attendere prego",
     "Preview": "Anteprima",
@@ -122,17 +123,17 @@
     "Quick guide to supported patterns": "Guida veloce agli schemi supportati",
     "RAM Utilization": "Utilizzo RAM",
     "Random": "Casuale",
-    "Relayed via": "Relayed via",
-    "Relays": "Relays",
+    "Relayed via": "Reindirizzato tramite",
+    "Relays": "Servers di reindirizzamento",
     "Release Notes": "Note di rilascio",
-    "Remove": "Remove",
+    "Remove": "Rimuovi",
     "Rescan": "Riscansiona",
     "Rescan All": "Riscansiona Tutto",
     "Rescan Interval": "Intervallo Scansione",
     "Restart": "Riavvia",
     "Restart Needed": "Riavvio Necessario",
     "Restarting": "Riavvio",
-    "Resume": "Resume",
+    "Resume": "Riprendi",
     "Reused": "Riutilizzato",
     "Save": "Salva",
     "Scanning": "Scansione in corso",
@@ -157,7 +158,7 @@
     "Source Code": "Codice Sorgente",
     "Staggered File Versioning": "Controllo Versione Cadenzato",
     "Start Browser": "Avvia Browser",
-    "Statistics": "Statistics",
+    "Statistics": "Statistiche",
     "Stopped": "Fermato",
     "Support": "Supporto",
     "Sync Protocol Listen Addresses": "Indirizzi del Protocollo di Sincronizzazione",
@@ -180,18 +181,18 @@
     "The folder ID must be unique.": "L'ID della cartella dev'essere unico.",
     "The folder path cannot be blank.": "Il percorso della cartella non può essere vuoto.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Vengono utilizzati i seguenti intervalli temporali: per la prima ora viene mantenuta una versione ogni 30 secondi, per il primo giorno viene mantenuta una versione ogni ora, per i primi 30 giorni viene mantenuta una versione al giorno, successivamente viene mantenuta una versione ogni settimana fino al periodo massimo impostato.",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
+    "The following items could not be synchronized.": "Non è stato possibile sincronizzare i seguenti elementi",
     "The maximum age must be a number and cannot be blank.": "La durata massima dev'essere un numero e non può essere vuoto.",
     "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 minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
+    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Lo spazio libero minimo su disco deve essere un numero non negativo tra 0 e 100 (inclusi)",
     "The number of days must be a number and cannot be blank.": "Il numero di giorni deve essere un numero e non può essere vuoto.",
     "The number of days to keep files in the trash can. Zero means forever.": "Il numero di giorni per conservare i file nel cestino. Zero significa 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 path cannot be blank.": "Il percorso non può essere vuoto.",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
+    "The rate limit must be a non-negative number (0: no limit)": "Il limite di banda deve essere un numero non negativo (da 0 a infinito)",
     "The rescan interval must be a non-negative number of seconds.": "L'intervallo di scansione deve essere un numero superiore a zero secondi.",
-    "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
+    "They are retried automatically and will be synced when the error is resolved.": "Verranno effettuati tentativi in automatico e verranno sincronizzati quando l'errore sarà risolto.",
     "This is a major version upgrade.": "Questo è un aggiornamento di versione principale",
     "Trash Can File Versioning": "Controllo Versione con Cestino",
     "Unknown": "Sconosciuto",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Quando aggiungi una nuova cartella, ricordati che gli ID vengono utilizzati per collegare le cartelle nei dispositivi. Distinguono maiuscole e minuscole e devono corrispondere esattamente su tutti i dispositivi.",
     "Yes": "Sì",
     "You must keep at least one version.": "È necessario mantenere almeno una versione.",
-    "days": "days",
+    "days": "giorni",
     "full documentation": "documentazione completa",
     "items": "elementi",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} vuole condividere la cartella \"{{folder}}\"."

gui/assets/lang/lang-ja.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "デバイス {{device}} ({{address}}) が接続を求めています。新しいデバイスとして追加しますか?",
     "Devices": "デバイス",
     "Disconnected": "切断中",
+    "Discovery": "Discovery",
     "Documentation": "マニュアル",
     "Download Rate": "ダウンロード速度",
     "Downloaded": "ダウンロード済",

gui/assets/lang/lang-ko-KR.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "다른 기기 {{device}} ({{address}}) 에서 접속을 요청했습니다. 새 장치를 추가하시겠습니까?",
     "Devices": "기기",
     "Disconnected": "연결 끊김",
+    "Discovery": "Discovery",
     "Documentation": "문서",
     "Download Rate": "다운로드 속도",
     "Downloaded": "다운로드됨",

gui/assets/lang/lang-lt.json

@@ -10,8 +10,8 @@
     "Add new folder?": "Pridėti naują aplanką?",
     "Address": "Adresas",
     "Addresses": "Adresai",
-    "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
+    "Advanced": "Pažangus",
+    "Advanced Configuration": "Pažangus nustatymai",
     "All Data": "Visiems duomenims",
     "Allow Anonymous Usage Reporting?": "Siųsti anonimišką vartojimo ataskaitą?",
     "Alphabetic": "Abėcėlės tvarka",
@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Įrenginys {{device}} ({{address}}) nori prisijungti. Pridėti naują įrenginį?",
     "Devices": "Įrenginiai",
     "Disconnected": "Atsijungęs",
+    "Discovery": "Lokacija",
     "Documentation": "Aprašymas",
     "Download Rate": "Parsisiuntimo greitis",
     "Downloaded": "Parsisiųstas",
@@ -53,19 +54,19 @@
     "Enter ignore patterns, one per line.": "Suveskite nepaisomus šablonus, kiekvieną naujoje eilutėje.",
     "Error": "Klaida",
     "External File Versioning": "Išorinis versijų valdymas",
-    "Failed Items": "Failed Items",
+    "Failed Items": "Nepavykę siuntimai",
     "File Pull Order": "Failų siuntimo tvarka",
     "File Versioning": "Versijų valdymas",
     "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Ieškant pakeitimų, į failų leidimų bitus yra nekreipiama dėmesio. Naudoti FAT failų sistemose.",
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Failai perkeliami į .stversions aplanką kai tampa pakeisti arba ištrinti.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Programai Syncthing pakeičiant ar ištrinant failus, jie yra perkeliami į datomis pažymėtas versijas, aplanke .stversions.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Failai apsaugoti nuo pakeitimų atliktų kituose įrenginiuose, bet pakeitimai šiame įrenginyje bus nusiųsti kitiems.",
-    "Folder": "Folder",
+    "Folder": "Aplankas",
     "Folder ID": "Aplanko ID",
     "Folder Master": "Aplanko vadovas",
     "Folder Path": "Kelias iki apkanko",
     "Folders": "Aplankai",
-    "GUI": "GUI",
+    "GUI": "Valdymo skydelis",
     "GUI Authentication Password": "Valdymo skydelio slaptažodis",
     "GUI Authentication User": "Valdymo skydelio vartotojo vardas",
     "GUI Listen Addresses": "Valdymo skydelio adresas",
@@ -74,7 +75,7 @@
     "Global Discovery Server": "Visuotinio matomumo serveris",
     "Global State": "Visuotinė būsena",
     "Help": "Pagalba",
-    "Home page": "Home page",
+    "Home page": "Pagrindinis puslapis",
     "Ignore": "Ignoruoti",
     "Ignore Patterns": "Nepaisyti šablonų",
     "Ignore Permissions": "Nepaisyti failų prieigos leidimų",
@@ -113,8 +114,8 @@
     "Override Changes": "Perrašyti pakeitimus",
     "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": "Kelias iki aplanko šiame kompiuteryje. Bus sukurtas, jei neegzistuoja. Tildės simbolis (~) gali būti naudojamas kaip trumpinys",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Kelias, kur bus saugomos versijos (palikite tuščią numatytam .stversions aplankui).",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "Sustabdyti",
+    "Paused": "Sustabdyta",
     "Please consult the release notes before performing a major upgrade.": "Peržvelkite laidos informaciją prieš atlikdami stambų atnaujinimą.",
     "Please wait": "Prašome palaukti",
     "Preview": "Peržiūra",
@@ -122,8 +123,8 @@
     "Quick guide to supported patterns": "Trumpas leistinų šablonų vadovas",
     "RAM Utilization": "Atminties naudojimas",
     "Random": "Atsitiktinė",
-    "Relayed via": "Relayed via",
-    "Relays": "Relays",
+    "Relayed via": "Retransliuojama per",
+    "Relays": "Retransliatoriai",
     "Release Notes": "Laidos Informacija",
     "Remove": "Pašalinti",
     "Rescan": "Nuskaityti iš naujo",
@@ -132,7 +133,7 @@
     "Restart": "Perleisti",
     "Restart Needed": "Reikalingas perleidimas",
     "Restarting": "Persileidžia",
-    "Resume": "Resume",
+    "Resume": "Pratęsti",
     "Reused": "Pakartotinas",
     "Save": "Išsaugoti",
     "Scanning": "Skenuojama",
@@ -180,7 +181,7 @@
     "The folder ID must be unique.": "Aplanko ID turi būti unikalus.",
     "The folder path cannot be blank.": "Kelias iki aplanko negali būti tuščias.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Šie pertraukų nustatymai naudojami: pirmą valandą versijos laikomos 30 sekundžių, pirmą dieną versijos laikomos valandą, pirmas 30 dienų versijos laikomos parą, kol nebus viršytas nustatytas maksimalus amžius.",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
+    "The following items could not be synchronized.": "Nepavyko parsiųsti šių failų",
     "The maximum age must be a number and cannot be blank.": "Maksimalus amžius  turi būti skaitmuo ir negali būti tuščias laukelis.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Maksimalus laikas kurį bus saugojama versija (dienomis, nustatykite 0 norėdami saugoti amžinai).",
     "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
@@ -191,7 +192,7 @@
     "The path cannot be blank.": "Kelias negali būti tuščias.",
     "The rate limit must be a non-negative number (0: no limit)": "Srauto maksimalus greitis privalo būti ne neigiamas skaičius (0: nėra apribojimo)",
     "The rescan interval must be a non-negative number of seconds.": "Nuskaitymo dažnis negali būti neigiamas skaičius.",
-    "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
+    "They are retried automatically and will be synced when the error is resolved.": "Failus bus automatiškai badoma parsiųsti dar kartą kai išspręsite klaidas",
     "This is a major version upgrade.": "Tai yra stambus atnaujinimas.",
     "Trash Can File Versioning": "Šiukšliadėžės versijų valdymas",
     "Unknown": "Nežinoma",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Kai įvedate naują aplanką neužmirškite, kad jis bus naudojamas visuose įrenginiuose. Svarbu visur įvesti visiškai tokį pat aplanko vardą neužmirštant apie didžiąsias ir mažąsias raides.",
     "Yes": "Taip",
     "You must keep at least one version.": "Būtina saugoti bent vieną versiją.",
-    "days": "days",
+    "days": "dienos",
     "full documentation": "pilna dokumentacija",
     "items": "įrašai",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} nori dalintis aplanku \"{{folder}}\""

gui/assets/lang/lang-nb.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Enhet {{device}} ({{address}}) ønsker å koble seg til. Legg til ny enhet?",
     "Devices": "Enheter",
     "Disconnected": "Frakoblet",
+    "Discovery": "Oppdagelse",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsrate",
     "Downloaded": "Lastet ned",

gui/assets/lang/lang-nl.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Apparaat {{device}} ({{address}}) wil verbinding maken. Dit apparaat toevoegen?",
     "Devices": "Apparaten",
     "Disconnected": "Niet verbonden",
+    "Discovery": "Zoeken",
     "Documentation": "Documentatie",
     "Download Rate": "Downloadsnelheid",
     "Downloaded": "Gedownload",

gui/assets/lang/lang-nn.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Eininga {{device}} ({{address}}) vil kopla seg til. Vil du leggja ho til?",
     "Devices": "Einingar",
     "Disconnected": "Fråkopla",
+    "Discovery": "Discovery",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsfart",
     "Downloaded": "Lasta ned",

gui/assets/lang/lang-pl.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Urządzenie {{device}} ({{address}}) chce się połączyć. Zezwolić?",
     "Devices": "Urządzenia",
     "Disconnected": "Rozłączony",
+    "Discovery": "Odnajdywanie",
     "Documentation": "Dokumentacja",
     "Download Rate": "Prędkość pobierania",
     "Downloaded": "Pobrane",
@@ -49,7 +50,7 @@
     "Edit Folder": "Edytuj folder",
     "Editing": "Edytowanie",
     "Enable UPnP": "Włącz UPnP",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Wpisz oddzielone przecinkiem adresy (\"tcp://ip:port\", \"tcp://host:port\") lub \"dynamic\" by przeprowadzić automatyczne odnalezienie adresu.",
     "Enter ignore patterns, one per line.": "Wprowadz wzorce ignorowania, jeden w każdej linii.",
     "Error": "Błąd",
     "External File Versioning": "Zewnętrzne wersjonowanie pliku",
@@ -93,7 +94,7 @@
     "Major Upgrade": "Ważna aktualizacja",
     "Maximum Age": "Maksymalny wiek",
     "Metadata Only": "Tylko metadane",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "Minimum wolnego miejsca na dysku",
     "Move to top of queue": "Przenieś na początek kolejki",
     "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",
@@ -107,14 +108,14 @@
     "Off": "Wyłącz",
     "Oldest First": "Najstarsze na początku",
     "Options": "Opcje",
-    "Out of Sync": "Utracono synchronizację",
+    "Out of Sync": "Niezsynchronizowane",
     "Out of Sync Items": "Niezsynchronizowane pliki",
     "Outgoing Rate Limit (KiB/s)": "Ograniczenie prędkości wysyłania (KiB/s)",
     "Override Changes": "Nadpisz zmiany",
     "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": "Ścieżka do lokalnego folderu. Zostanie utworzona jeżeli nie istnieje.\nZnak tyldy (~) może zostać użyty jako skrót do",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Ścieżka gdzie będą przechowywane wersje (pozostaw puste dla domyślnego folderu .stversions)",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "Zatrzymaj",
+    "Paused": "Zatrzymany",
     "Please consult the release notes before performing a major upgrade.": "Zaleca się przeanalizowanie \"release notes\" przed przeprowadzeniem znaczącej aktualizacji.",
     "Please wait": "Proszę czekać",
     "Preview": "Podgląd",
@@ -122,17 +123,17 @@
     "Quick guide to supported patterns": "Krótki przewodnik po obsługiwanych wzorcach",
     "RAM Utilization": "Użycie pamięci RAM",
     "Random": "Losowo",
-    "Relayed via": "Relayed via",
-    "Relays": "Relays",
+    "Relayed via": "Przekazane przez",
+    "Relays": "Przekaźniki",
     "Release Notes": "Informacje o wydaniu",
-    "Remove": "Remove",
+    "Remove": "Usuń",
     "Rescan": "Skanuj ponownie",
     "Rescan All": "Skanuj wszystko ponownie",
     "Rescan Interval": "Interwał skanowania",
     "Restart": "Uruchom ponownie",
     "Restart Needed": "Wymagane ponowne uruchomienie",
     "Restarting": "Uruchamianie ponowne",
-    "Resume": "Resume",
+    "Resume": "Wznów",
     "Reused": "Ponownie użyte",
     "Save": "Zapisz",
     "Scanning": "Skanowanie",
@@ -183,13 +184,13 @@
     "The following items could not be synchronized.": "Następujące elementy nie mogły zostać zsynchronizowane.",
     "The maximum age must be a number and cannot be blank.": "Maksymalny wiek musi być liczbą i nie może być pusty.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Maksymalny czas zachowania wersji (w dniach, ustaw 0 aby zachować na zawsze)",
-    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
+    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Procent minimalnej ilości wolnego miejsca na dysku musi być nieujemną liczbą od 0 do 100 (włącznie).",
     "The number of days must be a number and cannot be blank.": "Ilość dni musi być dodatnia.",
     "The number of days to keep files in the trash can. Zero means forever.": "Liczba dni przez które pliki trzymane będą w koszu. Zero oznacza brak ograniczeń.",
     "The number of old versions to keep, per file.": "Liczba wersji pliku do zachowania.",
     "The number of versions must be a number and cannot be blank.": "Liczba wersji musi być liczbą i nie może być pusta.",
     "The path cannot be blank.": "Ścieżka nie może być pusta.",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
+    "The rate limit must be a non-negative number (0: no limit)": "Ograniczenie prędkości powinno być nieujemną liczbą całkowitą (0: brak ograniczeń)",
     "The rescan interval must be a non-negative number of seconds.": "Interwał skanowania musi być niezerową liczbą sekund.",
     "They are retried automatically and will be synced when the error is resolved.": "Ponowne próby zachodzą automatycznie, synchronizacja nastąpi po usunięciu usterki.",
     "This is a major version upgrade.": "To jest ważna aktualizacja",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Przy dodawaniu nowego folderu, pamiętaj, że ID użyte jest do łączenia folderów pomiędzy urządzeniami. Wielkość liter ciągu ma znaczenie musi zgadzać się na wszystkich urządzeniach.",
     "Yes": "Tak",
     "You must keep at least one version.": "Musisz posiadać przynajmniej jedną wersję",
-    "days": "days",
+    "days": "dni",
     "full documentation": "pełna dokumentacja",
     "items": "pozycji",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} chce udostępnić folder \"{{folder}}\""

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

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "O dispositivo {{device}} ({{address}}) quer se conectar. Adicionar novo dispositivo?",
     "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
+    "Discovery": "Descoberta",
     "Documentation": "Documentação",
     "Download Rate": "Velocidade de recepção",
     "Downloaded": "Recebido",
@@ -197,7 +198,7 @@
     "Unknown": "Desconhecida",
     "Unshared": "Não compartilhada",
     "Unused": "Não utilizado",
-    "Up to Date": "Sincronizada",
+    "Up to Date": "Em sincronia",
     "Updated": "Atualizado",
     "Upgrade": "Atualização",
     "Upgrade To {%version%}": "Atualizar para {{version}}",

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

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "O dispositivo {{device}} ({{address}}) quer conectar-se. Adiciono este novo dispositivo?",
     "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
+    "Discovery": "Detecção",
     "Documentation": "Documentação",
     "Download Rate": "Velocidade de recepção",
     "Downloaded": "Recebido",
@@ -49,7 +50,7 @@
     "Edit Folder": "Editar pasta",
     "Editing": "Editando",
     "Enable UPnP": "Activar UPnP",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Introduza endereços separados por vírgulas (\"tcp://ip:porto\", \"tcp://máquina:porto\") ou \"dynamic\" para descobrir automaticamente os endereços.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Introduza endereços separados por vírgulas (\"tcp://ip:porto\", \"tcp://máquina:porto\") ou \"dynamic\" para detectar automaticamente os endereços.",
     "Enter ignore patterns, one per line.": "Escreva os padrões de exclusão, um por linha.",
     "Error": "Erro",
     "External File Versioning": "Externa",
@@ -70,8 +71,8 @@
     "GUI Authentication User": "Utilizador da autenticação na interface gráfica",
     "GUI Listen Addresses": "Endereço de escuta da interface gráfica",
     "Generate": "Gerar",
-    "Global Discovery": "Busca global",
-    "Global Discovery Server": "Servidor da busca global",
+    "Global Discovery": "Detecção global",
+    "Global Discovery Server": "Servidor de detecção global",
     "Global State": "Estado global",
     "Help": "Ajuda",
     "Home page": "Página do projecto",
@@ -87,7 +88,7 @@
     "Last File Received": "Último ficheiro recebido",
     "Last seen": "Última vez que foi verificado",
     "Later": "Mais tarde",
-    "Local Discovery": "Busca local",
+    "Local Discovery": "Detecção local",
     "Local State": "Estado local",
     "Local State (Total)": "Estado local (total)",
     "Major Upgrade": "Actualização importante",
@@ -122,8 +123,8 @@
     "Quick guide to supported patterns": "Guia rápido dos padrões suportados",
     "RAM Utilization": "Utilização da RAM",
     "Random": "Aleatória",
-    "Relayed via": "Transmitido via",
-    "Relays": "Transmissores",
+    "Relayed via": "Retransmitido via",
+    "Relays": "Retransmissores",
     "Release Notes": "Notas de lançamento",
     "Remove": "Remover",
     "Rescan": "Verificar agora",

gui/assets/lang/lang-ro-RO.json

@@ -11,7 +11,7 @@
     "Address": "Adresă",
     "Addresses": "Adrese",
     "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
+    "Advanced Configuration": "Configurari avansate",
     "All Data": "Toate Datele",
     "Allow Anonymous Usage Reporting?": "Permiteţi raportarea anonimă de folosire a aplicaţiei?",
     "Alphabetic": "Alphabetic",
@@ -19,7 +19,7 @@
     "Anonymous Usage Reporting": "Raport Anonim despre Folosirea Aplicației",
     "Any devices configured on an introducer device will be added to this device as well.": "Toate dispozitivele configurate pe un dispozitiv iniţiator vor fi adăugate şi pe acest dispozitiv. ",
     "Automatic upgrades": "Actualizare automată",
-    "Be careful!": "Be careful!",
+    "Be careful!": "Fii atent!",
     "Bugs": "Bug-uri",
     "CPU Utilization": "CPU ",
     "Changelog": "Noutăți",
@@ -33,13 +33,14 @@
     "Copied from original": "Copiat  din original",
     "Copyright © 2015 the following Contributors:": "Copyright ©2015 Următorii Contribuitori:",
     "Delete": "Şterge",
-    "Deleted": "Deleted",
+    "Deleted": "Șters",
     "Device ID": "ID Dispozitiv",
     "Device Identification": "Identificare Dispozitiv",
     "Device Name": "Nume Dispozitiv",
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Dispozitivul{{dispoztiv}}({{adresă}})vrea sa se conecteze.Adaug un dispozitiv nou?",
     "Devices": "Dispozitiv",
     "Disconnected": "Deconectat",
+    "Discovery": "Discovery",
     "Documentation": "Documentaţie",
     "Download Rate": "Viteză de Descărcare",
     "Downloaded": "Descărcat",
@@ -60,7 +61,7 @@
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Files are moved to .stversions folder when replaced or deleted by Syncthing.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Documentele sînt mutate într-un fișier .stversions conținînd versiuni datate atunci cînd sînt șterse sau înlocuite de Syncthing. ",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Fișierele sunt protejate de schimbările făcute pe alte dispozitive dar schimbările efectuate pe acest dispozitiv vor fi trimise catre restul grupului.",
-    "Folder": "Folder",
+    "Folder": "Mapă",
     "Folder ID": "ID Mapă",
     "Folder Master": "Master Măpi",
     "Folder Path": "Locaţie Mapei",
@@ -106,14 +107,14 @@
     "OK": "OK",
     "Off": "Închis",
     "Oldest First": "Oldest First",
-    "Options": "Options",
+    "Options": "Opțiuni",
     "Out of Sync": "Out of Sync",
     "Out of Sync Items": "Elemente Nesincronizate",
     "Outgoing Rate Limit (KiB/s)": "Limită Viteză de Upload (KB/s)",
     "Override Changes": "Suprascrie Schimbări",
     "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": "Localizarea fișierului în acest computer. Dacă nu există, va fi creat. Tilda (~) înlocuiește ",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Locul unde vor fi stocate versiunile (a se lăsa neschimbat pentru fișierul .stversions din fișier). ",
-    "Pause": "Pause",
+    "Pause": "Pauză",
     "Paused": "Paused",
     "Please consult the release notes before performing a major upgrade.": "Please consult the release notes before performing a major upgrade.",
     "Please wait": "Aşteaptă",
@@ -157,7 +158,7 @@
     "Source Code": "Cod Sursă",
     "Staggered File Versioning": "Versiuni eşalonate ale documentelor",
     "Start Browser": "Lansează Browser",
-    "Statistics": "Statistics",
+    "Statistics": "Statistici",
     "Stopped": "Oprit",
     "Support": "Suport Tehnic",
     "Sync Protocol Listen Addresses": "Adresa protocolului de sincronizare",
@@ -185,7 +186,7 @@
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Câte zile să se păstreze o versiune (setează 0 pentru nelimitat)",
     "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
     "The number of days must be a number and cannot be blank.": "The number of days must be a number and cannot be blank.",
-    "The number of days to keep files in the trash can. Zero means forever.": "The number of days to keep files in the trash can. Zero means forever.",
+    "The number of days to keep files in the trash can. Zero means forever.": "Numărul de zile pentru a păstra fișierele in urnă.Zero înseamnă permanent.",
     "The number of old versions to keep, per file.": "Numărul de versiuni vechi de salvat per fişier.",
     "The number of versions must be a number and cannot be blank.": "Numărul de versiuni trebuie să fie un număr şi nu poate fi gol.",
     "The path cannot be blank.": "Locația nu poate fi goală.",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Cînd adăugaţi un fişier nou, nu uitaţi că ID-ul fişierului va rămîne acelaşi pe toate dispozitivele. Iar literele mari sînt diferite de literele mici. ",
     "Yes": "Da",
     "You must keep at least one version.": "Trebuie să păstrezi cel puţin o versiune.",
-    "days": "days",
+    "days": "Zile",
     "full documentation": "toată documentaţia",
     "items": "obiecte",
     "{%device%} wants to share folder \"{%folder%}\".": "{{Dispozitivul}} vrea să transmită mapa {{Mapa}}"

gui/assets/lang/lang-ru.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Устройство {{device}} ({{address}}) хочет подключиться. Добавить новое устройство?",
     "Devices": "Устройства",
     "Disconnected": "Нет соединения",
+    "Discovery": "Обнаружение",
     "Documentation": "Документация",
     "Download Rate": "Скорость загрузки",
     "Downloaded": "Загружено",

gui/assets/lang/lang-sv.json

@@ -1,5 +1,5 @@
 {
-    "A negative number of days doesn't make sense.": "A negative number of days doesn't make sense.",
+    "A negative number of days doesn't make sense.": "Negativt antal dagar är inte troligt.",
     "A new major version may not be compatible with previous versions.": "En ny huvudversion kan eventuellt vara inkompatibel med tidigare versioner.",
     "API Key": "API-nyckel",
     "About": "Om",
@@ -10,8 +10,8 @@
     "Add new folder?": "Lägg till katalog?",
     "Address": "Adress",
     "Addresses": "Adresser",
-    "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
+    "Advanced": "Avancerat",
+    "Advanced Configuration": "Avancerad konfiguration",
     "All Data": "All data",
     "Allow Anonymous Usage Reporting?": "Tillåt anonym användarstatistik?",
     "Alphabetic": "Alfabetisk",
@@ -19,11 +19,11 @@
     "Anonymous Usage Reporting": "Anonym användarstatistik",
     "Any devices configured on an introducer device will be added to this device as well.": "Enheter konfigurerade på en introduktörsenhet kommer också att läggas till den här enheten.",
     "Automatic upgrades": "Automatisk uppgradering",
-    "Be careful!": "Be careful!",
+    "Be careful!": "Var aktsam!",
     "Bugs": "Buggar",
     "CPU Utilization": "CPU-användning",
     "Changelog": "Changelog",
-    "Clean out after": "Clean out after",
+    "Clean out after": "Rensa efteråt",
     "Close": "Stäng",
     "Command": "Kommando",
     "Comment, when used at the start of a line": "Kommentar, vid början av en rad.",
@@ -33,13 +33,14 @@
     "Copied from original": "Oförändrat",
     "Copyright © 2015 the following Contributors:": "Copyright © 2015 följande medverkande:",
     "Delete": "Radera",
-    "Deleted": "Deleted",
+    "Deleted": "Borttaget",
     "Device ID": "Enhets-ID",
     "Device Identification": "Enhetsidentifikation",
     "Device Name": "Enhetsnamn",
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Enheten {{device}} ({{address}}) vill ansluta. Lägg till ny enhet?",
     "Devices": "Enheter",
     "Disconnected": "Ej ansluten",
+    "Discovery": "Uppslagning",
     "Documentation": "Dokumentation",
     "Download Rate": "Nedladdningshastighet",
     "Downloaded": "Nerladdat",
@@ -49,18 +50,18 @@
     "Edit Folder": "Redigera katalog",
     "Editing": "Redigerar",
     "Enable UPnP": "Använd UPnP",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Ange kommaseparerade (\"tcp://ip:port\", \"tcp://host:port\")-adresser eller ordet \"dynamic\" för att använda automatisk uppslagning.",
     "Enter ignore patterns, one per line.": "Ange filmönster, ett per rad.",
     "Error": "Fel",
     "External File Versioning": "Extern versionshantering",
-    "Failed Items": "Failed Items",
+    "Failed Items": "Misslyckade filer",
     "File Pull Order": "Hämtningsprioritering av filer",
     "File Versioning": "Versionshantering",
     "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Filrättigheter ignoreras vid sökning efter förändringar. Används på FAT-filsystem.",
-    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Files are moved to .stversions folder when replaced or deleted by Syncthing.",
+    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Filer flyttas till katalogen .stversions om de ersätts eller raderas av Syncthing.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Filer flyttas till datummärkta versioner i en .stversions-mapp när de ersatts eller raderats av Syncthing.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Filer skyddas från ändringar gjorda på andra enheter, men ändringar som görs på den här noden skickas till de andra klustermedlemmarna.",
-    "Folder": "Folder",
+    "Folder": "Katalog",
     "Folder ID": "Katalog-ID",
     "Folder Master": "Huvudlagring",
     "Folder Path": "Sökväg",
@@ -74,12 +75,12 @@
     "Global Discovery Server": "Global uppslagningsserver",
     "Global State": "Global status",
     "Help": "Hjälp",
-    "Home page": "Home page",
+    "Home page": "Hemsida",
     "Ignore": "Ignorera",
     "Ignore Patterns": "Ignorerade filmönster",
     "Ignore Permissions": "Ignorera filrättigheter",
     "Incoming Rate Limit (KiB/s)": "Max nedladdningshastighet (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Incorrect configuration may damage your folder contents and render Syncthing inoperable.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Inkorrekt konfiguration kan skada innehållet i katalogen and få Syncthing att sluta fungera.",
     "Introducer": "introduktör",
     "Inversion of the given condition (i.e. do not exclude)": "Vänder på villkoret, d.v.s. exkluderar inte.",
     "Keep Versions": "Behåll versioner",
@@ -89,11 +90,11 @@
     "Later": "Senare",
     "Local Discovery": "Lokal uppslagning",
     "Local State": "Lokal status",
-    "Local State (Total)": "Local State (Total)",
+    "Local State (Total)": "Lokal status (Total)",
     "Major Upgrade": "Stor uppgradering",
     "Maximum Age": "Högsta åldersgräns",
     "Metadata Only": "Endast metadata",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "Minimum ledigt diskutrymme",
     "Move to top of queue": "Flytta till överst i kön",
     "Multi level wildcard (matches multiple directory levels)": "Jokertecken som representerar noll eller fler godtyckliga tecken, även över kataloggränser.",
     "Never": "Aldrig",
@@ -106,15 +107,15 @@
     "OK": "OK",
     "Off": "Av",
     "Oldest First": "Äldst först",
-    "Options": "Options",
-    "Out of Sync": "Out of Sync",
+    "Options": "Alternativ",
+    "Out of Sync": "Osynkad",
     "Out of Sync Items": "Osynkade poster",
     "Outgoing Rate Limit (KiB/s)": "Max uppladdningshastighet (KiB/s)",
     "Override Changes": "Skriv över ändringar",
     "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": "Sökväg till katalogen på din dator. Kommer att skapas om det inte finns. Tecknet tilde (~) kan användas som en genväg för",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Sökväg där versioner sparas (lämna tomt för att använda .stversions i den ordinarie katalogen).",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "Paus",
+    "Paused": "Pausad",
     "Please consult the release notes before performing a major upgrade.": "Läs igenom versionsnyheterna innan den stora uppgraderingen.",
     "Please wait": "Var god vänta",
     "Preview": "Förhandsgranska",
@@ -122,17 +123,17 @@
     "Quick guide to supported patterns": "Snabb guide till filmönster som stöds",
     "RAM Utilization": "Minnesanvändning",
     "Random": "Slumpmässig",
-    "Relayed via": "Relayed via",
-    "Relays": "Relays",
+    "Relayed via": "Vidarbefordras via",
+    "Relays": "Vidarbefordringar",
     "Release Notes": "versionsnyheter",
-    "Remove": "Remove",
+    "Remove": "Ta bort",
     "Rescan": "Uppdatera",
     "Rescan All": "Uppdatera alla",
     "Rescan Interval": "Uppdateringsintervall",
     "Restart": "Starta om",
     "Restart Needed": "Omstart behövs",
     "Restarting": "Startar om",
-    "Resume": "Resume",
+    "Resume": "Återuppta",
     "Reused": "Återanvänt",
     "Save": "Spara",
     "Scanning": "Uppdaterar",
@@ -157,7 +158,7 @@
     "Source Code": "Källkod",
     "Staggered File Versioning": "Versionshantering i intervall",
     "Start Browser": "Starta browser",
-    "Statistics": "Statistics",
+    "Statistics": "Statistik",
     "Stopped": "Stoppad",
     "Support": "Support",
     "Sync Protocol Listen Addresses": "Address för inkommande anslutningar",
@@ -180,25 +181,25 @@
     "The folder ID must be unique.": "Katalog-ID:t måste vara unikt.",
     "The folder path cannot be blank.": "Ange en sökväg.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "De följande intervallen används: varje 30 sekunder under den första timmen; varje timme under den första dagen; varje dag för de första 30 dagarna; varje vecka tills den maximala åldersgränsen uppnås.",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
+    "The following items could not be synchronized.": "Följande filer kunde inte synkroniseras.",
     "The maximum age must be a number and cannot be blank.": "Åldersgränsen måste vara ett tal och kan inte lämnas tomt.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Den längsta tiden att behålla en version (i dagar, sätt till 0 för att behålla versioner för evigt).",
-    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
-    "The number of days must be a number and cannot be blank.": "The number of days must be a number and cannot be blank.",
-    "The number of days to keep files in the trash can. Zero means forever.": "The number of days to keep files in the trash can. Zero means forever.",
+    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Minimum ledigt diskutrymme i procent måste vara en icke negativ siffra mellan 0 och 100 (inklusive).",
+    "The number of days must be a number and cannot be blank.": "Antalet dagar måste vara en siffra och får inte vara tomt.",
+    "The number of days to keep files in the trash can. Zero means forever.": "Antal dagar som filer ligger kvar i papperskorgen. Noll betyder för alltid.",
     "The number of old versions to keep, per file.": "Antalet gamla versioner som ska behållas, per fil.",
     "The number of versions must be a number and cannot be blank.": "Antalet versioner måste vara ett nummer och kan inte lämnas tomt.",
     "The path cannot be blank.": "Ange en sökväg",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
+    "The rate limit must be a non-negative number (0: no limit)": "Frekvensgränsen måste vara ett icke-negativt tal (0: ingen gräns)",
     "The rescan interval must be a non-negative number of seconds.": "Förnyelseintervallet måste vara ett positivt antal sekunder",
-    "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
+    "They are retried automatically and will be synced when the error is resolved.": "De omprövas automatiskt och kommer att synkroniseras när felet är löst.",
     "This is a major version upgrade.": "Det här är en stor uppgradering.",
-    "Trash Can File Versioning": "Trash Can File Versioning",
+    "Trash Can File Versioning": "Versionshantering på filer i papperskorgen",
     "Unknown": "Okänt",
     "Unshared": "Inte delad",
     "Unused": "Oanvänd",
     "Up to Date": "Helt uppdaterad",
-    "Updated": "Updated",
+    "Updated": "Uppdaterad",
     "Upgrade": "Uppgradering",
     "Upgrade To {%version%}": "Uppgradera till {{version}}",
     "Upgrading": "Uppgraderar",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "När du lägger till ny katalog, tänk på att katalog-ID:t knyter ihop katalogen mellan olika noder. De måste vara exakt desamma mellan noder och stora eller små bokstäver har betydelse.",
     "Yes": "Ja",
     "You must keep at least one version.": "Du måste behålla åtminstone en version.",
-    "days": "days",
+    "days": "dagar",
     "full documentation": "fullständig dokumentation",
     "items": "poster",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} vill dela katalogen \"{{folder}}\"."

gui/assets/lang/lang-uk.json

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "Пристрій {{device}} ({{address}}) намагається під’єднатися. Додати новий пристрій?",
     "Devices": "Пристрої",
     "Disconnected": "З’єднання відсутнє",
+    "Discovery": "Discovery",
     "Documentation": "Документація",
     "Download Rate": "Швидкість завантаження",
     "Downloaded": "Завантажено",
@@ -212,7 +213,7 @@
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Коли додаєте нову директорію, пам’ятайте, що ID цієї директорії використовується для того, щоб зв’язувати директорії разом між вузлами. Назви є чутливими до регістра та повинні співпадати точно між усіма вузлами.",
     "Yes": "Так",
     "You must keep at least one version.": "Ви повинні зберігати щонайменше одну версію.",
-    "days": "days",
+    "days": "днів",
     "full documentation": "повна документація",
     "items": "елементи",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} хоче поділитися директорією \"{{folder}}\"."

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

@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "设备：{{device}} 地址：({{address}}) 请求连接。是否添加新设备？",
     "Devices": "设备",
     "Disconnected": "连接已断开",
+    "Discovery": "Discovery",
     "Documentation": "文档",
     "Download Rate": "下载速度",
     "Downloaded": "已下载",

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

@@ -1,6 +1,6 @@
 {
     "A negative number of days doesn't make sense.": "一個負的天數並不合理。",
-    "A new major version may not be compatible with previous versions.": "A new major version may not be compatible with previous versions.",
+    "A new major version may not be compatible with previous versions.": "一個新的主要版本可能與以前的版本並不相容。",
     "API Key": "API 金鑰",
     "About": "關於",
     "Actions": "操作",
@@ -10,8 +10,8 @@
     "Add new folder?": "新增資料夾?",
     "Address": "位址",
     "Addresses": "位址",
-    "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
+    "Advanced": "進階",
+    "Advanced Configuration": "進階設定",
     "All Data": "全部資料",
     "Allow Anonymous Usage Reporting?": "允許匿名的使用資訊回報？",
     "Alphabetic": "字母順序",
@@ -19,18 +19,18 @@
     "Anonymous Usage Reporting": "匿名的使用資訊回報",
     "Any devices configured on an introducer device will be added to this device as well.": "任何在引入者裝置所設置的裝置將會一併新增至此裝置",
     "Automatic upgrades": "自動升級",
-    "Be careful!": "Be careful!",
+    "Be careful!": "請小心！",
     "Bugs": "程式錯誤",
     "CPU Utilization": "CPU 使用",
     "Changelog": "更新日誌",
-    "Clean out after": "Clean out after",
+    "Clean out after": "於之後清空",
     "Close": "關閉",
     "Command": "指令",
     "Comment, when used at the start of a line": "註解，當輸入在一行的開頭時",
     "Compression": "壓縮",
     "Connection Error": "連線錯誤",
     "Copied from elsewhere": "從別處複製",
-    "Copied from original": "Copied from original",
+    "Copied from original": "從原來複製",
     "Copyright © 2015 the following Contributors:": "Copyright © 2015 下列貢獻者：",
     "Delete": "刪除",
     "Deleted": "已刪除",
@@ -40,6 +40,7 @@
     "Device {%device%} ({%address%}) wants to connect. Add new device?": "裝置 {{device}} ({{address}}) 想要連線。要新增裝置嗎？",
     "Devices": "裝置",
     "Disconnected": "斷線",
+    "Discovery": "Discovery",
     "Documentation": "說明文件",
     "Download Rate": "下載速率",
     "Downloaded": "已下載",
@@ -53,10 +54,10 @@
     "Enter ignore patterns, one per line.": "輸入忽略樣式，每行一種。",
     "Error": "錯誤",
     "External File Versioning": "外部檔案版本控制",
-    "Failed Items": "Failed Items",
+    "Failed Items": "失敗的項目",
     "File Pull Order": "提取檔案的順序",
     "File Versioning": "檔案版本控制",
-    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "File permission bits are ignored when looking for changes. Use on FAT file systems.",
+    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "當改變時，檔案權限位元 File permission bits 會被忽略。用於 FAT 檔案系統上。",
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Files are moved to .stversions folder when replaced or deleted by Syncthing.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "其他裝置做的改變不會影響到此裝置的檔案，但在此裝置上的變化將被發送到叢集中的其他部分。",
@@ -79,7 +80,7 @@
     "Ignore Patterns": "忽略樣式",
     "Ignore Permissions": "忽略權限",
     "Incoming Rate Limit (KiB/s)": "連入速率限制 (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Incorrect configuration may damage your folder contents and render Syncthing inoperable.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "不正確的設定可能會損壞你的資料夾內容，並引致 Syncthing 的不正當運作。",
     "Introducer": "引入者",
     "Inversion of the given condition (i.e. do not exclude)": "反轉給定條件 (即：不要排除)",
     "Keep Versions": "保留歷史版本數",
@@ -89,11 +90,11 @@
     "Later": "稍後",
     "Local Discovery": "本地探索",
     "Local State": "本地狀態",
-    "Local State (Total)": "Local State (Total)",
+    "Local State (Total)": "本地狀態 (總結)",
     "Major Upgrade": "重大更新",
     "Maximum Age": "最長保留時間",
     "Metadata Only": "僅中繼資料",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
+    "Minimum Free Disk Space": "最少閒置磁碟空間",
     "Move to top of queue": "移到隊列頂端",
     "Multi level wildcard (matches multiple directory levels)": "多階層萬用字元 (可比對多層資料夾)",
     "Never": "從未",
@@ -113,8 +114,8 @@
     "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 where versions should be stored (leave empty for the default .stversions folder in the folder).": "儲存歷史版本的路徑 (若為空，則預設使用資料夾中的 .stversions 資料夾)。",
-    "Pause": "Pause",
-    "Paused": "Paused",
+    "Pause": "暫停",
+    "Paused": "暫停",
     "Please consult the release notes before performing a major upgrade.": "執行重大升級前請先參閱版本資訊。",
     "Please wait": "請稍後",
     "Preview": "預覽",
@@ -122,7 +123,7 @@
     "Quick guide to supported patterns": "可支援樣式的快速指南",
     "RAM Utilization": "記憶體使用",
     "Random": "隨機",
-    "Relayed via": "Relayed via",
+    "Relayed via": "中繼於",
     "Relays": "中繼點",
     "Release Notes": "版本資訊",
     "Remove": "移除",
@@ -132,8 +133,8 @@
     "Restart": "重新啟動",
     "Restart Needed": "需要重新啟動",
     "Restarting": "正在重新啟動",
-    "Resume": "Resume",
-    "Reused": "Reused",
+    "Resume": "繼續",
+    "Reused": "重用",
     "Save": "儲存",
     "Scanning": "正在掃描",
     "Select the devices to share this folder with.": "選擇要共享這個資料夾的裝置。",
@@ -180,18 +181,18 @@
     "The folder ID must be unique.": "資料夾識別碼必須為獨一無二的。",
     "The folder path cannot be blank.": "資料夾路徑不能空白。",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "使用下列的間隔：在第一個小時內每 30 秒保留一個版本，在第一天內每小時保留一個版本，在第 30 天內每一天保留一個版本，在達到最長保留時間前每一星期保留一個版本。",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
+    "The following items could not be synchronized.": "以下項目不能被同步。",
     "The maximum age must be a number and cannot be blank.": "最長保留時間必須為一個數字且不得為空。",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "一個版本被保留的最長時間 (單位為天，若設定為 0 則表示永遠保留)。",
     "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
     "The number of days must be a number and cannot be blank.": "天數必須必須為一個數字且不得為空。",
-    "The number of days to keep files in the trash can. Zero means forever.": "The number of days to keep files in the trash can. Zero means forever.",
+    "The number of days to keep files in the trash can. Zero means forever.": "檔案在 trash can 中保留的日子。零表示永遠地保留。",
     "The number of old versions to keep, per file.": "每個檔案要保留的舊版本數量。",
     "The number of versions must be a number and cannot be blank.": "每個檔案要保留的舊版本數量必須是數字且不能為空白。",
     "The path cannot be blank.": "路徑不能空白。",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
+    "The rate limit must be a non-negative number (0: no limit)": "限制速率必須為非負的數字 (0: 不設限制)",
     "The rescan interval must be a non-negative number of seconds.": "重新掃描間隔必須為一個非負數的秒數。",
-    "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
+    "They are retried automatically and will be synced when the error is resolved.": "解決間題後，將會自動重試和同步。",
     "This is a major version upgrade.": "這是一個主要版本更新。",
     "Trash Can File Versioning": "Trash Can File Versioning",
     "Unknown": "未知",
@@ -208,11 +209,11 @@
     "Version": "版本",
     "Versions Path": "歷史版本路徑",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "當檔案歷史版本的存留時間大於設定的最大值，或是其數量在一段時間內超出允許值時，則會被刪除。",
-    "When adding a new device, keep in mind that this device must be added on the other side too.": "當新增一個裝置時，請記住，這個裝置也必須被添加至另一邊。",
+    "When adding a new device, keep in mind that this device must be added on the other side too.": "當新增一個裝置時，務必記住，當前的這個裝置也同樣必須被添加至另一邊。",
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "當新增一個資料夾時，請記住，資料夾識別碼是用來將裝置之間的資料夾綁定在一起的。它們有區分大小寫，且必須在所有裝置之間完全相同。",
     "Yes": "是",
     "You must keep at least one version.": "您必須保留至少一個版本。",
-    "days": "days",
+    "days": "日",
     "full documentation": "完整說明文件",
     "items": "個項目",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} 想要分享資料夾 \"{{folder}}\"。"

gui/index.html

@@ -469,7 +469,7 @@
                       <th><span class="fa fa-fw fa-thumbs-o-up"></span>&nbsp;<span translate>Introducer</span></th>
                       <td translate class="text-right">Yes</td>
                     </tr>
-                    <tr ng-if="connections[deviceCfg.deviceID].version">
+                    <tr ng-if="connections[deviceCfg.deviceID].clientVersion">
                       <th><span class="fa fa-fw fa-tag"></span>&nbsp;<span translate>Version</span></th>
                       <td class="text-right">{{connections[deviceCfg.deviceID].clientVersion}}</td>
                     </tr>

gui/syncthing/core/aboutModalView.html

@@ -47,6 +47,7 @@
         <li class="auto-generated">Frank Isemann</li>
         <li class="auto-generated">Gilli Sigurdsson</li>
         <li class="auto-generated">Jacek Szafarkiewicz</li>
+        <li class="auto-generated">Jake Peterson</li>
         <li class="auto-generated">Jakob Borg</li>
         <li class="auto-generated">James Patterson</li>
         <li class="auto-generated">Jaroslav Malec</li>
@@ -60,7 +61,7 @@
         <li class="auto-generated">Marc Laporte</li>
         <li class="auto-generated">Marc Pujol</li>
         <li class="auto-generated">Marcin Dziadus</li>
-        <li class="auto-generated">Mateon1</li>
+        <li class="auto-generated">Mateusz Naściszewski</li>
         <li class="auto-generated">Matt Burke</li>
         <li class="auto-generated">Michael Jephcote</li>
         <li class="auto-generated">Michael Tilli</li>
@@ -71,6 +72,7 @@
         <li class="auto-generated">Piotr Bejda</li>
         <li class="auto-generated">Ryan Sullivan</li>
         <li class="auto-generated">Sergey Mishin</li>
+        <li class="auto-generated">Stefan Kuntz</li>
         <li class="auto-generated">Stefan Tatschner</li>
         <li class="auto-generated">Tim Abell</li>
         <li class="auto-generated">Tobias Nygren</li>
@@ -78,6 +80,7 @@
         <li class="auto-generated">Tully Robinson</li>
         <li class="auto-generated">Veeti Paananen</li>
         <li class="auto-generated">Vil Brekin</li>
+        <li class="auto-generated">Yannic A.</li>
       </ul>
     </div>
   </div>

gui/syncthing/core/syncthingController.js

@@ -1135,6 +1135,7 @@ angular.module('syncthing.core')
             };
             $scope.currentFolder.rescanIntervalS = 60;
             $scope.currentFolder.minDiskFreePct = 1;
+            $scope.currentFolder.maxConflicts = -1;
             $scope.currentFolder.order = "random";
             $scope.currentFolder.fileVersioningSelector = "none";
             $scope.currentFolder.trashcanClean = 0;
@@ -1156,6 +1157,7 @@ angular.module('syncthing.core')
                 selectedDevices: {},
                 rescanIntervalS: 60,
                 minDiskFreePct: 1,
+                maxConflicts: -1,
                 order: "random",
                 fileVersioningSelector: "none",
                 trashcanClean: 0,

lib/beacon/beacon.go

@@ -25,10 +25,6 @@ type Interface interface {
 	Error() error
 }
 
-type readerFrom interface {
-	ReadFrom([]byte) (int, net.Addr, error)
-}
-
 type errorHolder struct {
 	err error
 	mut stdsync.Mutex // uses stdlib sync as I want this to be trivially embeddable, and there is no risk of blocking

lib/beacon/broadcast.go

@@ -11,6 +11,7 @@ import (
 	"net"
 	"time"
 
+	"github.com/syncthing/syncthing/lib/sync"
 	"github.com/thejerf/suture"
 )
 
@@ -42,13 +43,15 @@ func NewBroadcast(port int) *Broadcast {
 	}
 
 	b.br = &broadcastReader{
-		port:   port,
-		outbox: b.outbox,
+		port:    port,
+		outbox:  b.outbox,
+		connMut: sync.NewMutex(),
 	}
 	b.Add(b.br)
 	b.bw = &broadcastWriter{
-		port:  port,
-		inbox: b.inbox,
+		port:    port,
+		inbox:   b.inbox,
+		connMut: sync.NewMutex(),
 	}
 	b.Add(b.bw)
 
@@ -72,9 +75,10 @@ func (b *Broadcast) Error() error {
 }
 
 type broadcastWriter struct {
-	port  int
-	inbox chan []byte
-	conn  *net.UDPConn
+	port    int
+	inbox   chan []byte
+	conn    *net.UDPConn
+	connMut sync.Mutex
 	errorHolder
 }
 
@@ -82,14 +86,17 @@ func (w *broadcastWriter) Serve() {
 	l.Debugln(w, "starting")
 	defer l.Debugln(w, "stopping")
 
-	var err error
-	w.conn, err = net.ListenUDP("udp4", nil)
+	conn, err := net.ListenUDP("udp4", nil)
 	if err != nil {
 		l.Debugln(err)
 		w.setError(err)
 		return
 	}
-	defer w.conn.Close()
+	defer conn.Close()
+
+	w.connMut.Lock()
+	w.conn = conn
+	w.connMut.Unlock()
 
 	for bs := range w.inbox {
 		addrs, err := net.InterfaceAddrs()
@@ -118,9 +125,9 @@ func (w *broadcastWriter) Serve() {
 		for _, ip := range dsts {
 			dst := &net.UDPAddr{IP: ip, Port: w.port}
 
-			w.conn.SetWriteDeadline(time.Now().Add(time.Second))
-			_, err := w.conn.WriteTo(bs, dst)
-			w.conn.SetWriteDeadline(time.Time{})
+			conn.SetWriteDeadline(time.Now().Add(time.Second))
+			_, err := conn.WriteTo(bs, dst)
+			conn.SetWriteDeadline(time.Time{})
 
 			if err, ok := err.(net.Error); ok && err.Timeout() {
 				// Write timeouts should not happen. We treat it as a fatal
@@ -154,7 +161,11 @@ func (w *broadcastWriter) Serve() {
 }
 
 func (w *broadcastWriter) Stop() {
-	w.conn.Close()
+	w.connMut.Lock()
+	if w.conn != nil {
+		w.conn.Close()
+	}
+	w.connMut.Unlock()
 }
 
 func (w *broadcastWriter) String() string {
@@ -162,9 +173,10 @@ func (w *broadcastWriter) String() string {
 }
 
 type broadcastReader struct {
-	port   int
-	outbox chan recv
-	conn   *net.UDPConn
+	port    int
+	outbox  chan recv
+	conn    *net.UDPConn
+	connMut sync.Mutex
 	errorHolder
 }
 
@@ -172,18 +184,21 @@ func (r *broadcastReader) Serve() {
 	l.Debugln(r, "starting")
 	defer l.Debugln(r, "stopping")
 
-	var err error
-	r.conn, err = net.ListenUDP("udp4", &net.UDPAddr{Port: r.port})
+	conn, err := net.ListenUDP("udp4", &net.UDPAddr{Port: r.port})
 	if err != nil {
 		l.Debugln(err)
 		r.setError(err)
 		return
 	}
-	defer r.conn.Close()
+	defer conn.Close()
+
+	r.connMut.Lock()
+	r.conn = conn
+	r.connMut.Unlock()
 
 	bs := make([]byte, 65536)
 	for {
-		n, addr, err := r.conn.ReadFrom(bs)
+		n, addr, err := conn.ReadFrom(bs)
 		if err != nil {
 			l.Debugln(err)
 			r.setError(err)
@@ -206,7 +221,11 @@ func (r *broadcastReader) Serve() {
 }
 
 func (r *broadcastReader) Stop() {
-	r.conn.Close()
+	r.connMut.Lock()
+	if r.conn != nil {
+		r.conn.Close()
+	}
+	r.connMut.Unlock()
 }
 
 func (r *broadcastReader) String() string {

lib/beacon/multicast.go

@@ -18,7 +18,6 @@ import (
 
 type Multicast struct {
 	*suture.Supervisor
-	addr   *net.UDPAddr
 	inbox  chan []byte
 	outbox chan recv
 	mr     *multicastReader

lib/config/config.go

@@ -8,25 +8,22 @@
 package config
 
 import (
+	"encoding/json"
 	"encoding/xml"
-	"fmt"
 	"io"
 	"math/rand"
+	"net/url"
 	"os"
-	"path/filepath"
 	"reflect"
-	"runtime"
 	"sort"
 	"strconv"
 	"strings"
 
-	"github.com/syncthing/syncthing/lib/osutil"
 	"github.com/syncthing/syncthing/lib/protocol"
-	"golang.org/x/crypto/bcrypt"
 )
 
 const (
-	OldestHandledVersion = 5
+	OldestHandledVersion = 10
 	CurrentVersion       = 12
 	MaxRescanIntervalS   = 365 * 24 * 60 * 60
 )
@@ -38,10 +35,10 @@ var (
 	// saved to the config.
 	DefaultDiscoveryServers = []string{
 		"https://discovery-v4-1.syncthing.net/?id=SR7AARM-TCBUZ5O-VFAXY4D-CECGSDE-3Q6IZ4G-XG7AH75-OBIXJQV-QJ6NLQA", // 194.126.249.5, Sweden
-		"https://discovery-v4-2.syncthing.net/?id=AQEHEO2-XOS7QRA-X2COH5K-PO6OPVA-EWOSEGO-KZFMD32-XJ4ZV46-CUUVKAS", // 45.55.230.38, USA
+		"https://discovery-v4-2.syncthing.net/?id=DVU36WY-H3LVZHW-E6LLFRE-YAFN5EL-HILWRYP-OC2M47J-Z4PE62Y-ADIBDQC", // 45.55.230.38, USA
 		"https://discovery-v4-3.syncthing.net/?id=7WT2BVR-FX62ZOW-TNVVW25-6AHFJGD-XEXQSBW-VO3MPL2-JBTLL4T-P4572Q4", // 128.199.95.124, Singapore
 		"https://discovery-v6-1.syncthing.net/?id=SR7AARM-TCBUZ5O-VFAXY4D-CECGSDE-3Q6IZ4G-XG7AH75-OBIXJQV-QJ6NLQA", // 2001:470:28:4d6::5, Sweden
-		"https://discovery-v6-2.syncthing.net/?id=AQEHEO2-XOS7QRA-X2COH5K-PO6OPVA-EWOSEGO-KZFMD32-XJ4ZV46-CUUVKAS", // 2604:a880:800:10::182:a001, USA
+		"https://discovery-v6-2.syncthing.net/?id=DVU36WY-H3LVZHW-E6LLFRE-YAFN5EL-HILWRYP-OC2M47J-Z4PE62Y-ADIBDQC", // 2604:a880:800:10::182:a001, USA
 		"https://discovery-v6-3.syncthing.net/?id=7WT2BVR-FX62ZOW-TNVVW25-6AHFJGD-XEXQSBW-VO3MPL2-JBTLL4T-P4572Q4", // 2400:6180:0:d0::d9:d001, Singapore
 	}
 
@@ -57,6 +54,48 @@ var (
 	}
 )
 
+func New(myID protocol.DeviceID) Configuration {
+	var cfg Configuration
+	cfg.Version = CurrentVersion
+	cfg.OriginalVersion = CurrentVersion
+
+	setDefaults(&cfg)
+	setDefaults(&cfg.Options)
+	setDefaults(&cfg.GUI)
+
+	cfg.prepare(myID)
+
+	return cfg
+}
+
+func ReadXML(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
+	var cfg Configuration
+
+	setDefaults(&cfg)
+	setDefaults(&cfg.Options)
+	setDefaults(&cfg.GUI)
+
+	err := xml.NewDecoder(r).Decode(&cfg)
+	cfg.OriginalVersion = cfg.Version
+
+	cfg.prepare(myID)
+	return cfg, err
+}
+
+func ReadJSON(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
+	var cfg Configuration
+
+	setDefaults(&cfg)
+	setDefaults(&cfg.Options)
+	setDefaults(&cfg.GUI)
+
+	err := json.NewDecoder(r).Decode(&cfg)
+	cfg.OriginalVersion = cfg.Version
+
+	cfg.prepare(myID)
+	return cfg, err
+}
+
 type Configuration struct {
 	Version        int                   `xml:"version,attr" json:"version"`
 	Folders        []FolderConfiguration `xml:"folder" json:"folders"`
@@ -93,237 +132,6 @@ func (cfg Configuration) Copy() Configuration {
 	return newCfg
 }
 
-type FolderConfiguration struct {
-	ID                    string                      `xml:"id,attr" json:"id"`
-	RawPath               string                      `xml:"path,attr" json:"path"`
-	Devices               []FolderDeviceConfiguration `xml:"device" json:"devices"`
-	ReadOnly              bool                        `xml:"ro,attr" json:"readOnly"`
-	RescanIntervalS       int                         `xml:"rescanIntervalS,attr" json:"rescanIntervalS"`
-	IgnorePerms           bool                        `xml:"ignorePerms,attr" json:"ignorePerms"`
-	AutoNormalize         bool                        `xml:"autoNormalize,attr" json:"autoNormalize"`
-	MinDiskFreePct        float64                     `xml:"minDiskFreePct" json:"minDiskFreePct"`
-	Versioning            VersioningConfiguration     `xml:"versioning" json:"versioning"`
-	Copiers               int                         `xml:"copiers" json:"copiers"` // This defines how many files are handled concurrently.
-	Pullers               int                         `xml:"pullers" json:"pullers"` // Defines how many blocks are fetched at the same time, possibly between separate copier routines.
-	Hashers               int                         `xml:"hashers" json:"hashers"` // Less than one sets the value to the number of cores. These are CPU bound due to hashing.
-	Order                 PullOrder                   `xml:"order" json:"order"`
-	IgnoreDelete          bool                        `xml:"ignoreDelete" json:"ignoreDelete"`
-	ScanProgressIntervalS int                         `xml:"scanProgressIntervalS" json:"scanProgressIntervalS"` // Set to a negative value to disable. Value of 0 will get replaced with value of 2 (default value)
-	PullerSleepS          int                         `xml:"pullerSleepS" json:"pullerSleepS"`
-	PullerPauseS          int                         `xml:"pullerPauseS" json:"pullerPauseS"`
-
-	Invalid string `xml:"-" json:"invalid"` // Set at runtime when there is an error, not saved
-}
-
-func (f FolderConfiguration) Copy() FolderConfiguration {
-	c := f
-	c.Devices = make([]FolderDeviceConfiguration, len(f.Devices))
-	copy(c.Devices, f.Devices)
-	return c
-}
-
-func (f FolderConfiguration) Path() string {
-	// This is intentionally not a pointer method, because things like
-	// cfg.Folders["default"].Path() should be valid.
-
-	// Attempt tilde expansion; leave unchanged in case of error
-	if path, err := osutil.ExpandTilde(f.RawPath); err == nil {
-		f.RawPath = path
-	}
-
-	// Attempt absolutification; leave unchanged in case of error
-	if !filepath.IsAbs(f.RawPath) {
-		// Abs() looks like a fairly expensive syscall on Windows, while
-		// IsAbs() is a whole bunch of string mangling. I think IsAbs() may be
-		// somewhat faster in the general case, hence the outer if...
-		if path, err := filepath.Abs(f.RawPath); err == nil {
-			f.RawPath = path
-		}
-	}
-
-	// Attempt to enable long filename support on Windows. We may still not
-	// have an absolute path here if the previous steps failed.
-	if runtime.GOOS == "windows" && filepath.IsAbs(f.RawPath) && !strings.HasPrefix(f.RawPath, `\\`) {
-		return `\\?\` + f.RawPath
-	}
-
-	return f.RawPath
-}
-
-func (f *FolderConfiguration) CreateMarker() error {
-	if !f.HasMarker() {
-		marker := filepath.Join(f.Path(), ".stfolder")
-		fd, err := os.Create(marker)
-		if err != nil {
-			return err
-		}
-		fd.Close()
-		osutil.HideFile(marker)
-	}
-
-	return nil
-}
-
-func (f *FolderConfiguration) HasMarker() bool {
-	_, err := os.Stat(filepath.Join(f.Path(), ".stfolder"))
-	if err != nil {
-		return false
-	}
-	return true
-}
-
-func (f *FolderConfiguration) DeviceIDs() []protocol.DeviceID {
-	deviceIDs := make([]protocol.DeviceID, len(f.Devices))
-	for i, n := range f.Devices {
-		deviceIDs[i] = n.DeviceID
-	}
-	return deviceIDs
-}
-
-type VersioningConfiguration struct {
-	Type   string            `xml:"type,attr" json:"type"`
-	Params map[string]string `json:"params"`
-}
-
-type InternalVersioningConfiguration struct {
-	Type   string          `xml:"type,attr,omitempty"`
-	Params []InternalParam `xml:"param"`
-}
-
-type InternalParam struct {
-	Key string `xml:"key,attr"`
-	Val string `xml:"val,attr"`
-}
-
-func (c *VersioningConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
-	var tmp InternalVersioningConfiguration
-	tmp.Type = c.Type
-	for k, v := range c.Params {
-		tmp.Params = append(tmp.Params, InternalParam{k, v})
-	}
-
-	return e.EncodeElement(tmp, start)
-
-}
-
-func (c *VersioningConfiguration) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
-	var tmp InternalVersioningConfiguration
-	err := d.DecodeElement(&tmp, &start)
-	if err != nil {
-		return err
-	}
-
-	c.Type = tmp.Type
-	c.Params = make(map[string]string, len(tmp.Params))
-	for _, p := range tmp.Params {
-		c.Params[p.Key] = p.Val
-	}
-	return nil
-}
-
-type DeviceConfiguration struct {
-	DeviceID    protocol.DeviceID    `xml:"id,attr" json:"deviceID"`
-	Name        string               `xml:"name,attr,omitempty" json:"name"`
-	Addresses   []string             `xml:"address,omitempty" json:"addresses"`
-	Compression protocol.Compression `xml:"compression,attr" json:"compression"`
-	CertName    string               `xml:"certName,attr,omitempty" json:"certName"`
-	Introducer  bool                 `xml:"introducer,attr" json:"introducer"`
-}
-
-func (orig DeviceConfiguration) Copy() DeviceConfiguration {
-	c := orig
-	c.Addresses = make([]string, len(orig.Addresses))
-	copy(c.Addresses, orig.Addresses)
-	return c
-}
-
-type FolderDeviceConfiguration struct {
-	DeviceID protocol.DeviceID `xml:"id,attr" json:"deviceID"`
-}
-
-type OptionsConfiguration struct {
-	ListenAddress           []string `xml:"listenAddress" json:"listenAddress" default:"tcp://0.0.0.0:22000"`
-	GlobalAnnServers        []string `xml:"globalAnnounceServer" json:"globalAnnounceServers" json:"globalAnnounceServer" default:"default"`
-	GlobalAnnEnabled        bool     `xml:"globalAnnounceEnabled" json:"globalAnnounceEnabled" default:"true"`
-	LocalAnnEnabled         bool     `xml:"localAnnounceEnabled" json:"localAnnounceEnabled" default:"true"`
-	LocalAnnPort            int      `xml:"localAnnouncePort" json:"localAnnouncePort" default:"21027"`
-	LocalAnnMCAddr          string   `xml:"localAnnounceMCAddr" json:"localAnnounceMCAddr" default:"[ff12::8384]:21027"`
-	RelayServers            []string `xml:"relayServer" json:"relayServers" default:"dynamic+https://relays.syncthing.net"`
-	MaxSendKbps             int      `xml:"maxSendKbps" json:"maxSendKbps"`
-	MaxRecvKbps             int      `xml:"maxRecvKbps" json:"maxRecvKbps"`
-	ReconnectIntervalS      int      `xml:"reconnectionIntervalS" json:"reconnectionIntervalS" default:"60"`
-	RelaysEnabled           bool     `xml:"relaysEnabled" json:"relaysEnabled" default:"true"`
-	RelayReconnectIntervalM int      `xml:"relayReconnectIntervalM" json:"relayReconnectIntervalM" default:"10"`
-	RelayWithoutGlobalAnn   bool     `xml:"relayWithoutGlobalAnn" json:"relayWithoutGlobalAnn" default:"false"`
-	StartBrowser            bool     `xml:"startBrowser" json:"startBrowser" default:"true"`
-	UPnPEnabled             bool     `xml:"upnpEnabled" json:"upnpEnabled" default:"true"`
-	UPnPLeaseM              int      `xml:"upnpLeaseMinutes" json:"upnpLeaseMinutes" default:"60"`
-	UPnPRenewalM            int      `xml:"upnpRenewalMinutes" json:"upnpRenewalMinutes" default:"30"`
-	UPnPTimeoutS            int      `xml:"upnpTimeoutSeconds" json:"upnpTimeoutSeconds" default:"10"`
-	URAccepted              int      `xml:"urAccepted" json:"urAccepted"` // Accepted usage reporting version; 0 for off (undecided), -1 for off (permanently)
-	URUniqueID              string   `xml:"urUniqueID" json:"urUniqueId"` // Unique ID for reporting purposes, regenerated when UR is turned on.
-	URURL                   string   `xml:"urURL" json:"urURL" default:"https://data.syncthing.net/newdata"`
-	URPostInsecurely        bool     `xml:"urPostInsecurely" json:"urPostInsecurely" default:"false"` // For testing
-	URInitialDelayS         int      `xml:"urInitialDelayS" json:"urInitialDelayS" default:"1800"`
-	RestartOnWakeup         bool     `xml:"restartOnWakeup" json:"restartOnWakeup" default:"true"`
-	AutoUpgradeIntervalH    int      `xml:"autoUpgradeIntervalH" json:"autoUpgradeIntervalH" default:"12"` // 0 for off
-	KeepTemporariesH        int      `xml:"keepTemporariesH" json:"keepTemporariesH" default:"24"`         // 0 for off
-	CacheIgnoredFiles       bool     `xml:"cacheIgnoredFiles" json:"cacheIgnoredFiles" default:"true"`
-	ProgressUpdateIntervalS int      `xml:"progressUpdateIntervalS" json:"progressUpdateIntervalS" default:"5"`
-	SymlinksEnabled         bool     `xml:"symlinksEnabled" json:"symlinksEnabled" default:"true"`
-	LimitBandwidthInLan     bool     `xml:"limitBandwidthInLan" json:"limitBandwidthInLan" default:"false"`
-	DatabaseBlockCacheMiB   int      `xml:"databaseBlockCacheMiB" json:"databaseBlockCacheMiB" default:"0"`
-	MinHomeDiskFreePct      float64  `xml:"minHomeDiskFreePct" json:"minHomeDiskFreePct" default:"1"`
-	ReleasesURL             string   `xml:"releasesURL" json:"releasesURL" default:"https://api.github.com/repos/syncthing/syncthing/releases?per_page=30"`
-	AlwaysLocalNets         []string `xml:"alwaysLocalNet" json:"alwaysLocalNets"`
-}
-
-func (orig OptionsConfiguration) Copy() OptionsConfiguration {
-	c := orig
-	c.ListenAddress = make([]string, len(orig.ListenAddress))
-	copy(c.ListenAddress, orig.ListenAddress)
-	c.GlobalAnnServers = make([]string, len(orig.GlobalAnnServers))
-	copy(c.GlobalAnnServers, orig.GlobalAnnServers)
-	return c
-}
-
-type GUIConfiguration struct {
-	Enabled  bool   `xml:"enabled,attr" json:"enabled" default:"true"`
-	Address  string `xml:"address" json:"address" default:"127.0.0.1:8384"`
-	User     string `xml:"user,omitempty" json:"user"`
-	Password string `xml:"password,omitempty" json:"password"`
-	UseTLS   bool   `xml:"tls,attr" json:"useTLS"`
-	APIKey   string `xml:"apikey,omitempty" json:"apiKey"`
-}
-
-func New(myID protocol.DeviceID) Configuration {
-	var cfg Configuration
-	cfg.Version = CurrentVersion
-	cfg.OriginalVersion = CurrentVersion
-
-	setDefaults(&cfg)
-	setDefaults(&cfg.Options)
-	setDefaults(&cfg.GUI)
-
-	cfg.prepare(myID)
-
-	return cfg
-}
-
-func ReadXML(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
-	var cfg Configuration
-
-	setDefaults(&cfg)
-	setDefaults(&cfg.Options)
-	setDefaults(&cfg.GUI)
-
-	err := xml.NewDecoder(r).Decode(&cfg)
-	cfg.OriginalVersion = cfg.Version
-
-	cfg.prepare(myID)
-	return cfg, err
-}
-
 func (cfg *Configuration) WriteXML(w io.Writer) error {
 	e := xml.NewEncoder(w)
 	e.Indent("", "    ")
@@ -338,41 +146,22 @@ func (cfg *Configuration) WriteXML(w io.Writer) error {
 func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 	fillNilSlices(&cfg.Options)
 
-	// Initialize an empty slices
+	// Initialize any empty slices
 	if cfg.Folders == nil {
 		cfg.Folders = []FolderConfiguration{}
 	}
 	if cfg.IgnoredDevices == nil {
 		cfg.IgnoredDevices = []protocol.DeviceID{}
 	}
+	if cfg.Options.AlwaysLocalNets == nil {
+		cfg.Options.AlwaysLocalNets = []string{}
+	}
 
 	// Check for missing, bad or duplicate folder ID:s
 	var seenFolders = map[string]*FolderConfiguration{}
 	for i := range cfg.Folders {
 		folder := &cfg.Folders[i]
-
-		if len(folder.RawPath) == 0 {
-			folder.Invalid = "no directory configured"
-			continue
-		}
-
-		// The reason it's done like this:
-		// C:          ->  C:\            ->  C:\        (issue that this is trying to fix)
-		// C:\somedir  ->  C:\somedir\    ->  C:\somedir
-		// C:\somedir\ ->  C:\somedir\\   ->  C:\somedir
-		// This way in the tests, we get away without OS specific separators
-		// in the test configs.
-		folder.RawPath = filepath.Dir(folder.RawPath + string(filepath.Separator))
-
-		if folder.ID == "" {
-			folder.ID = "default"
-		}
-
-		if folder.RescanIntervalS > MaxRescanIntervalS {
-			folder.RescanIntervalS = MaxRescanIntervalS
-		} else if folder.RescanIntervalS < 0 {
-			folder.RescanIntervalS = 0
-		}
+		folder.prepare()
 
 		if seen, ok := seenFolders[folder.ID]; ok {
 			l.Warnf("Multiple folders with ID %q; disabling", folder.ID)
@@ -386,43 +175,18 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 	cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress)
 	cfg.Options.GlobalAnnServers = uniqueStrings(cfg.Options.GlobalAnnServers)
 
-	if cfg.Version < OldestHandledVersion {
+	if cfg.Version > 0 && cfg.Version < OldestHandledVersion {
 		l.Warnf("Configuration version %d is deprecated. Attempting best effort conversion, but please verify manually.", cfg.Version)
 	}
 
 	// Upgrade configuration versions as appropriate
-	if cfg.Version <= 5 {
-		convertV5V6(cfg)
-	}
-	if cfg.Version == 6 {
-		convertV6V7(cfg)
-	}
-	if cfg.Version == 7 {
-		convertV7V8(cfg)
-	}
-	if cfg.Version == 8 {
-		convertV8V9(cfg)
-	}
-	if cfg.Version == 9 {
-		convertV9V10(cfg)
-	}
-	if cfg.Version == 10 {
+	if cfg.Version <= 10 {
 		convertV10V11(cfg)
 	}
 	if cfg.Version == 11 {
 		convertV11V12(cfg)
 	}
 
-	// Hash old cleartext passwords
-	if len(cfg.GUI.Password) > 0 && cfg.GUI.Password[0] != '$' {
-		hash, err := bcrypt.GenerateFromPassword([]byte(cfg.GUI.Password), 0)
-		if err != nil {
-			l.Warnln("bcrypting password:", err)
-		} else {
-			cfg.GUI.Password = string(hash)
-		}
-	}
-
 	// Build a list of available devices
 	existingDevices := make(map[protocol.DeviceID]bool)
 	for _, device := range cfg.Devices {
@@ -463,62 +227,23 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 		cfg.Options.ReconnectIntervalS = 5
 	}
 
-	if cfg.GUI.APIKey == "" {
-		cfg.GUI.APIKey = randomString(32)
+	if cfg.GUI.RawAPIKey == "" {
+		cfg.GUI.RawAPIKey = randomString(32)
 	}
 }
 
-// ChangeRequiresRestart returns true if updating the configuration requires a
-// complete restart.
-func ChangeRequiresRestart(from, to Configuration) bool {
-	// Adding, removing or changing folders requires restart
-	if !reflect.DeepEqual(from.Folders, to.Folders) {
-		return true
-	}
-
-	// Removing a device requres restart
-	toDevs := make(map[protocol.DeviceID]bool, len(from.Devices))
-	for _, dev := range to.Devices {
-		toDevs[dev.DeviceID] = true
-	}
-	for _, dev := range from.Devices {
-		if _, ok := toDevs[dev.DeviceID]; !ok {
-			return true
-		}
-	}
-
-	// Changing usage reporting to on or off does not require a restart.
-	to.Options.URAccepted = from.Options.URAccepted
-	to.Options.URUniqueID = from.Options.URUniqueID
-
-	// All of the generic options require restart
-	if !reflect.DeepEqual(from.Options, to.Options) || !reflect.DeepEqual(from.GUI, to.GUI) {
-		return true
-	}
-
-	return false
-}
-
-func convertV10V11(cfg *Configuration) {
-	// Set minimum disk free of existing folders to 1%
-	for i := range cfg.Folders {
-		cfg.Folders[i].MinDiskFreePct = 1
-	}
-	cfg.Version = 11
-}
-
 func convertV11V12(cfg *Configuration) {
 	// Change listen address schema
 	for i, addr := range cfg.Options.ListenAddress {
 		if len(addr) > 0 && !strings.HasPrefix(addr, "tcp://") {
-			cfg.Options.ListenAddress[i] = fmt.Sprintf("tcp://%s", addr)
+			cfg.Options.ListenAddress[i] = tcpAddr(addr)
 		}
 	}
 
 	for i, device := range cfg.Devices {
 		for j, addr := range device.Addresses {
 			if addr != "dynamic" && addr != "" {
-				cfg.Devices[i].Addresses[j] = fmt.Sprintf("tcp://%s", addr)
+				cfg.Devices[i].Addresses[j] = tcpAddr(addr)
 			}
 		}
 	}
@@ -550,53 +275,20 @@ func convertV11V12(cfg *Configuration) {
 		cfg.Options.LocalAnnPort = 21027
 	}
 
+	// Set MaxConflicts to unlimited
+	for i := range cfg.Folders {
+		cfg.Folders[i].MaxConflicts = -1
+	}
+
 	cfg.Version = 12
 }
 
-func convertV9V10(cfg *Configuration) {
-	// Enable auto normalization on existing folders.
+func convertV10V11(cfg *Configuration) {
+	// Set minimum disk free of existing folders to 1%
 	for i := range cfg.Folders {
-		cfg.Folders[i].AutoNormalize = true
+		cfg.Folders[i].MinDiskFreePct = 1
 	}
-	cfg.Version = 10
-}
-
-func convertV8V9(cfg *Configuration) {
-	// Compression is interpreted and serialized differently, but no enforced
-	// changes. Still need a new version number since the compression stuff
-	// isn't understandable by earlier versions.
-	cfg.Version = 9
-}
-
-func convertV7V8(cfg *Configuration) {
-	// Add IPv6 announce server
-	if len(cfg.Options.GlobalAnnServers) == 1 && cfg.Options.GlobalAnnServers[0] == "udp4://announce.syncthing.net:22026" {
-		cfg.Options.GlobalAnnServers = append(cfg.Options.GlobalAnnServers, "udp6://announce-v6.syncthing.net:22026")
-	}
-
-	cfg.Version = 8
-}
-
-func convertV6V7(cfg *Configuration) {
-	// Migrate announce server addresses to the new URL based format
-	for i := range cfg.Options.GlobalAnnServers {
-		cfg.Options.GlobalAnnServers[i] = "udp4://" + cfg.Options.GlobalAnnServers[i]
-	}
-
-	cfg.Version = 7
-}
-
-func convertV5V6(cfg *Configuration) {
-	// Added ".stfolder" file at folder roots to identify mount issues
-	// Doesn't affect the config itself, but uses config migrations to identify
-	// the migration point.
-	for _, folder := range Wrap("", *cfg).Folders() {
-		// Best attempt, if it fails, it fails, the user will have to fix
-		// it up manually, as the repo will not get started.
-		folder.CreateMarker()
-	}
-
-	cfg.Version = 6
+	cfg.Version = 11
 }
 
 func setDefaults(data interface{}) error {
@@ -738,30 +430,6 @@ loop:
 	return devices[0:count]
 }
 
-type DeviceConfigurationList []DeviceConfiguration
-
-func (l DeviceConfigurationList) Less(a, b int) bool {
-	return l[a].DeviceID.Compare(l[b].DeviceID) == -1
-}
-func (l DeviceConfigurationList) Swap(a, b int) {
-	l[a], l[b] = l[b], l[a]
-}
-func (l DeviceConfigurationList) Len() int {
-	return len(l)
-}
-
-type FolderDeviceConfigurationList []FolderDeviceConfiguration
-
-func (l FolderDeviceConfigurationList) Less(a, b int) bool {
-	return l[a].DeviceID.Compare(l[b].DeviceID) == -1
-}
-func (l FolderDeviceConfigurationList) Swap(a, b int) {
-	l[a], l[b] = l[b], l[a]
-}
-func (l FolderDeviceConfigurationList) Len() int {
-	return len(l)
-}
-
 // randomCharset contains the characters that can make up a randomString().
 const randomCharset = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
 
@@ -775,56 +443,10 @@ func randomString(l int) string {
 	return string(bs)
 }
 
-type PullOrder int
-
-const (
-	OrderRandom PullOrder = iota // default is random
-	OrderAlphabetic
-	OrderSmallestFirst
-	OrderLargestFirst
-	OrderOldestFirst
-	OrderNewestFirst
-)
-
-func (o PullOrder) String() string {
-	switch o {
-	case OrderRandom:
-		return "random"
-	case OrderAlphabetic:
-		return "alphabetic"
-	case OrderSmallestFirst:
-		return "smallestFirst"
-	case OrderLargestFirst:
-		return "largestFirst"
-	case OrderOldestFirst:
-		return "oldestFirst"
-	case OrderNewestFirst:
-		return "newestFirst"
-	default:
-		return "unknown"
+func tcpAddr(host string) string {
+	u := url.URL{
+		Scheme: "tcp",
+		Host:   host,
 	}
-}
-
-func (o PullOrder) MarshalText() ([]byte, error) {
-	return []byte(o.String()), nil
-}
-
-func (o *PullOrder) UnmarshalText(bs []byte) error {
-	switch string(bs) {
-	case "random":
-		*o = OrderRandom
-	case "alphabetic":
-		*o = OrderAlphabetic
-	case "smallestFirst":
-		*o = OrderSmallestFirst
-	case "largestFirst":
-		*o = OrderLargestFirst
-	case "oldestFirst":
-		*o = OrderOldestFirst
-	case "newestFirst":
-		*o = OrderNewestFirst
-	default:
-		*o = OrderRandom
-	}
-	return nil
+	return u.String()
 }

lib/config/config_test.go

@@ -37,7 +37,7 @@ func TestDefaultValues(t *testing.T) {
 		LocalAnnEnabled:         true,
 		LocalAnnPort:            21027,
 		LocalAnnMCAddr:          "[ff12::8384]:21027",
-		RelayServers:            []string{"dynamic+https://relays.syncthing.net"},
+		RelayServers:            []string{"dynamic+https://relays.syncthing.net/endpoint"},
 		MaxSendKbps:             0,
 		MaxRecvKbps:             0,
 		ReconnectIntervalS:      60,
@@ -56,12 +56,12 @@ func TestDefaultValues(t *testing.T) {
 		ProgressUpdateIntervalS: 5,
 		SymlinksEnabled:         true,
 		LimitBandwidthInLan:     false,
-		DatabaseBlockCacheMiB:   0,
 		MinHomeDiskFreePct:      1,
 		URURL:                   "https://data.syncthing.net/newdata",
 		URInitialDelayS:         1800,
 		URPostInsecurely:        false,
 		ReleasesURL:             "https://api.github.com/repos/syncthing/syncthing/releases?per_page=30",
+		AlwaysLocalNets:         []string{},
 	}
 
 	cfg := New(device1)
@@ -100,8 +100,21 @@ func TestDeviceConfig(t *testing.T) {
 				Hashers:         0,
 				AutoNormalize:   true,
 				MinDiskFreePct:  1,
+				MaxConflicts:    -1,
 			},
 		}
+
+		// The cachedPath will have been resolved to an absolute path,
+		// depending on where the tests are running. Zero it out so we don't
+		// fail based on that.
+		for i := range cfg.Folders {
+			cfg.Folders[i].cachedPath = ""
+		}
+
+		if runtime.GOOS != "windows" {
+			expectedFolders[0].RawPath += string(filepath.Separator)
+		}
+
 		expectedDevices := []DeviceConfiguration{
 			{
 				DeviceID:    device1,
@@ -173,12 +186,12 @@ func TestOverriddenValues(t *testing.T) {
 		ProgressUpdateIntervalS: 10,
 		SymlinksEnabled:         false,
 		LimitBandwidthInLan:     true,
-		DatabaseBlockCacheMiB:   42,
 		MinHomeDiskFreePct:      5.2,
 		URURL:                   "https://localhost/newdata",
 		URInitialDelayS:         800,
 		URPostInsecurely:        true,
 		ReleasesURL:             "https://localhost/releases",
+		AlwaysLocalNets:         []string{},
 	}
 
 	cfg, err := Load("testdata/overridenvalues.xml", device1)
@@ -326,7 +339,7 @@ func TestIssue1262(t *testing.T) {
 	}
 
 	actual := cfg.Folders()["test"].RawPath
-	expected := "e:"
+	expected := "e:/"
 	if runtime.GOOS == "windows" {
 		expected = `e:\`
 	}
@@ -457,83 +470,6 @@ func TestPrepare(t *testing.T) {
 	}
 }
 
-func TestRequiresRestart(t *testing.T) {
-	wr, err := Load("testdata/v6.xml", device1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cfg := wr.cfg
-
-	if ChangeRequiresRestart(cfg, cfg) {
-		t.Error("No change does not require restart")
-	}
-
-	newCfg := cfg
-	newCfg.Devices = append(newCfg.Devices, DeviceConfiguration{
-		DeviceID: device3,
-	})
-	if ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Adding a device does not require restart")
-	}
-
-	newCfg = cfg
-	newCfg.Devices = newCfg.Devices[:len(newCfg.Devices)-1]
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Removing a device requires restart")
-	}
-
-	newCfg = cfg
-	newCfg.Folders = append(newCfg.Folders, FolderConfiguration{
-		ID:      "t1",
-		RawPath: "t1",
-	})
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Adding a folder requires restart")
-	}
-
-	newCfg = cfg
-	newCfg.Folders = newCfg.Folders[:len(newCfg.Folders)-1]
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Removing a folder requires restart")
-	}
-
-	newCfg = cfg
-	newFolders := make([]FolderConfiguration, len(cfg.Folders))
-	copy(newFolders, cfg.Folders)
-	newCfg.Folders = newFolders
-	if ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("No changes done yet")
-	}
-	newCfg.Folders[0].RawPath = "different"
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Changing a folder requires restart")
-	}
-
-	newCfg = cfg
-	newDevices := make([]DeviceConfiguration, len(cfg.Devices))
-	copy(newDevices, cfg.Devices)
-	newCfg.Devices = newDevices
-	if ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("No changes done yet")
-	}
-	newCfg.Devices[0].Name = "different"
-	if ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Changing a device does not require restart")
-	}
-
-	newCfg = cfg
-	newCfg.Options.GlobalAnnEnabled = !cfg.Options.GlobalAnnEnabled
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Changing general options requires restart")
-	}
-
-	newCfg = cfg
-	newCfg.GUI.UseTLS = !cfg.GUI.UseTLS
-	if !ChangeRequiresRestart(cfg, newCfg) {
-		t.Error("Changing GUI options requires restart")
-	}
-}
-
 func TestCopy(t *testing.T) {
 	wrapper, err := Load("testdata/example.xml", device1)
 	if err != nil {
@@ -551,7 +487,7 @@ func TestCopy(t *testing.T) {
 	cfg.Devices[0].Addresses[0] = "wrong"
 	cfg.Folders[0].Devices[0].DeviceID = protocol.DeviceID{0, 1, 2, 3}
 	cfg.Options.ListenAddress[0] = "wrong"
-	cfg.GUI.APIKey = "wrong"
+	cfg.GUI.RawAPIKey = "wrong"
 
 	bsChanged, err := json.MarshalIndent(cfg, "", "  ")
 	if err != nil {
@@ -634,3 +570,25 @@ func TestLargeRescanInterval(t *testing.T) {
 		t.Error("negative rescan interval should become zero")
 	}
 }
+
+func TestGUIConfigURL(t *testing.T) {
+	testcases := [][2]string{
+		{"192.0.2.42:8080", "http://192.0.2.42:8080/"},
+		{":8080", "http://127.0.0.1:8080/"},
+		{"0.0.0.0:8080", "http://127.0.0.1:8080/"},
+		{"127.0.0.1:8080", "http://127.0.0.1:8080/"},
+		{"127.0.0.2:8080", "http://127.0.0.2:8080/"},
+		{"[::]:8080", "http://[::1]:8080/"},
+		{"[2001::42]:8080", "http://[2001::42]:8080/"},
+	}
+
+	for _, tc := range testcases {
+		c := GUIConfiguration{
+			RawAddress: tc[0],
+		}
+		u := c.URL()
+		if u != tc[1] {
+			t.Errorf("Incorrect URL %s != %s for addr %s", u, tc[1], tc[0])
+		}
+	}
+}

lib/config/deviceconfiguration.go

@@ -0,0 +1,46 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+import "github.com/syncthing/syncthing/lib/protocol"
+
+type DeviceConfiguration struct {
+	DeviceID    protocol.DeviceID    `xml:"id,attr" json:"deviceID"`
+	Name        string               `xml:"name,attr,omitempty" json:"name"`
+	Addresses   []string             `xml:"address,omitempty" json:"addresses"`
+	Compression protocol.Compression `xml:"compression,attr" json:"compression"`
+	CertName    string               `xml:"certName,attr,omitempty" json:"certName"`
+	Introducer  bool                 `xml:"introducer,attr" json:"introducer"`
+}
+
+func NewDeviceConfiguration(id protocol.DeviceID, name string) DeviceConfiguration {
+	return DeviceConfiguration{
+		DeviceID: id,
+		Name:     name,
+	}
+}
+
+func (orig DeviceConfiguration) Copy() DeviceConfiguration {
+	c := orig
+	c.Addresses = make([]string, len(orig.Addresses))
+	copy(c.Addresses, orig.Addresses)
+	return c
+}
+
+type DeviceConfigurationList []DeviceConfiguration
+
+func (l DeviceConfigurationList) Less(a, b int) bool {
+	return l[a].DeviceID.Compare(l[b].DeviceID) == -1
+}
+
+func (l DeviceConfigurationList) Swap(a, b int) {
+	l[a], l[b] = l[b], l[a]
+}
+
+func (l DeviceConfigurationList) Len() int {
+	return len(l)
+}

lib/config/folderconfiguration.go

@@ -0,0 +1,177 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/syncthing/syncthing/lib/osutil"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+type FolderConfiguration struct {
+	ID                    string                      `xml:"id,attr" json:"id"`
+	RawPath               string                      `xml:"path,attr" json:"path"`
+	Devices               []FolderDeviceConfiguration `xml:"device" json:"devices"`
+	ReadOnly              bool                        `xml:"ro,attr" json:"readOnly"`
+	RescanIntervalS       int                         `xml:"rescanIntervalS,attr" json:"rescanIntervalS"`
+	IgnorePerms           bool                        `xml:"ignorePerms,attr" json:"ignorePerms"`
+	AutoNormalize         bool                        `xml:"autoNormalize,attr" json:"autoNormalize"`
+	MinDiskFreePct        float64                     `xml:"minDiskFreePct" json:"minDiskFreePct"`
+	Versioning            VersioningConfiguration     `xml:"versioning" json:"versioning"`
+	Copiers               int                         `xml:"copiers" json:"copiers"` // This defines how many files are handled concurrently.
+	Pullers               int                         `xml:"pullers" json:"pullers"` // Defines how many blocks are fetched at the same time, possibly between separate copier routines.
+	Hashers               int                         `xml:"hashers" json:"hashers"` // Less than one sets the value to the number of cores. These are CPU bound due to hashing.
+	Order                 PullOrder                   `xml:"order" json:"order"`
+	IgnoreDelete          bool                        `xml:"ignoreDelete" json:"ignoreDelete"`
+	ScanProgressIntervalS int                         `xml:"scanProgressIntervalS" json:"scanProgressIntervalS"` // Set to a negative value to disable. Value of 0 will get replaced with value of 2 (default value)
+	PullerSleepS          int                         `xml:"pullerSleepS" json:"pullerSleepS"`
+	PullerPauseS          int                         `xml:"pullerPauseS" json:"pullerPauseS"`
+	MaxConflicts          int                         `xml:"maxConflicts" json:"maxConflicts"`
+
+	Invalid    string `xml:"-" json:"invalid"` // Set at runtime when there is an error, not saved
+	cachedPath string
+}
+
+type FolderDeviceConfiguration struct {
+	DeviceID protocol.DeviceID `xml:"id,attr" json:"deviceID"`
+}
+
+func NewFolderConfiguration(id, path string) FolderConfiguration {
+	f := FolderConfiguration{
+		ID:      id,
+		RawPath: path,
+	}
+	f.prepare()
+	return f
+}
+
+func (f FolderConfiguration) Copy() FolderConfiguration {
+	c := f
+	c.Devices = make([]FolderDeviceConfiguration, len(f.Devices))
+	copy(c.Devices, f.Devices)
+	c.Versioning = f.Versioning.Copy()
+	return c
+}
+
+func (f FolderConfiguration) Path() string {
+	// This is intentionally not a pointer method, because things like
+	// cfg.Folders["default"].Path() should be valid.
+
+	if f.cachedPath == "" {
+		l.Infoln("bug: uncached path call (should only happen in tests)")
+		return f.cleanedPath()
+	}
+	return f.cachedPath
+}
+
+func (f *FolderConfiguration) CreateMarker() error {
+	if !f.HasMarker() {
+		marker := filepath.Join(f.Path(), ".stfolder")
+		fd, err := os.Create(marker)
+		if err != nil {
+			return err
+		}
+		fd.Close()
+		osutil.HideFile(marker)
+	}
+
+	return nil
+}
+
+func (f *FolderConfiguration) HasMarker() bool {
+	_, err := os.Stat(filepath.Join(f.Path(), ".stfolder"))
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+func (f *FolderConfiguration) DeviceIDs() []protocol.DeviceID {
+	deviceIDs := make([]protocol.DeviceID, len(f.Devices))
+	for i, n := range f.Devices {
+		deviceIDs[i] = n.DeviceID
+	}
+	return deviceIDs
+}
+
+func (f *FolderConfiguration) prepare() {
+	if len(f.RawPath) == 0 {
+		f.Invalid = "no directory configured"
+		return
+	}
+
+	// The reason it's done like this:
+	// C:          ->  C:\            ->  C:\        (issue that this is trying to fix)
+	// C:\somedir  ->  C:\somedir\    ->  C:\somedir
+	// C:\somedir\ ->  C:\somedir\\   ->  C:\somedir
+	// This way in the tests, we get away without OS specific separators
+	// in the test configs.
+	f.RawPath = filepath.Dir(f.RawPath + string(filepath.Separator))
+
+	// If we're not on Windows, we want the path to end with a slash to
+	// penetrate symlinks. On Windows, paths must not end with a slash.
+	if runtime.GOOS != "windows" && f.RawPath[len(f.RawPath)-1] != filepath.Separator {
+		f.RawPath = f.RawPath + string(filepath.Separator)
+	}
+
+	f.cachedPath = f.cleanedPath()
+
+	if f.ID == "" {
+		f.ID = "default"
+	}
+
+	if f.RescanIntervalS > MaxRescanIntervalS {
+		f.RescanIntervalS = MaxRescanIntervalS
+	} else if f.RescanIntervalS < 0 {
+		f.RescanIntervalS = 0
+	}
+}
+
+func (f *FolderConfiguration) cleanedPath() string {
+	cleaned := f.RawPath
+
+	// Attempt tilde expansion; leave unchanged in case of error
+	if path, err := osutil.ExpandTilde(cleaned); err == nil {
+		cleaned = path
+	}
+
+	// Attempt absolutification; leave unchanged in case of error
+	if !filepath.IsAbs(cleaned) {
+		// Abs() looks like a fairly expensive syscall on Windows, while
+		// IsAbs() is a whole bunch of string mangling. I think IsAbs() may be
+		// somewhat faster in the general case, hence the outer if...
+		if path, err := filepath.Abs(cleaned); err == nil {
+			cleaned = path
+		}
+	}
+
+	// Attempt to enable long filename support on Windows. We may still not
+	// have an absolute path here if the previous steps failed.
+	if runtime.GOOS == "windows" && filepath.IsAbs(cleaned) && !strings.HasPrefix(f.RawPath, `\\`) {
+		return `\\?\` + cleaned
+	}
+
+	return cleaned
+}
+
+type FolderDeviceConfigurationList []FolderDeviceConfiguration
+
+func (l FolderDeviceConfigurationList) Less(a, b int) bool {
+	return l[a].DeviceID.Compare(l[b].DeviceID) == -1
+}
+
+func (l FolderDeviceConfigurationList) Swap(a, b int) {
+	l[a], l[b] = l[b], l[a]
+}
+
+func (l FolderDeviceConfigurationList) Len() int {
+	return len(l)
+}

lib/config/guiconfiguration.go

@@ -0,0 +1,82 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+import (
+	"net/url"
+	"os"
+	"strings"
+)
+
+type GUIConfiguration struct {
+	Enabled    bool   `xml:"enabled,attr" json:"enabled" default:"true"`
+	RawAddress string `xml:"address" json:"address" default:"127.0.0.1:8384"`
+	User       string `xml:"user,omitempty" json:"user"`
+	Password   string `xml:"password,omitempty" json:"password"`
+	RawUseTLS  bool   `xml:"tls,attr" json:"useTLS"`
+	RawAPIKey  string `xml:"apikey,omitempty" json:"apiKey"`
+}
+
+func (c GUIConfiguration) Address() string {
+	if override := os.Getenv("STGUIADDRESS"); override != "" {
+		// This value may be of the form "scheme://address:port" or just
+		// "address:port". We need to chop off the scheme. We try to parse it as
+		// an URL if it contains a slash. If that fails, return it as is and let
+		// some other error handling handle it.
+
+		if strings.Contains(override, "/") {
+			url, err := url.Parse(override)
+			if err != nil {
+				return override
+			}
+			return url.Host
+		}
+
+		return override
+	}
+
+	return c.RawAddress
+}
+
+func (c GUIConfiguration) UseTLS() bool {
+	if override := os.Getenv("STGUIADDRESS"); override != "" {
+		return strings.HasPrefix(override, "https:")
+	}
+	return c.RawUseTLS
+}
+
+func (c GUIConfiguration) URL() string {
+	u := url.URL{
+		Scheme: "http",
+		Host:   c.Address(),
+		Path:   "/",
+	}
+
+	if c.UseTLS() {
+		u.Scheme = "https"
+	}
+
+	if strings.HasPrefix(u.Host, ":") {
+		// Empty host, i.e. ":port", use IPv4 localhost
+		u.Host = "127.0.0.1" + u.Host
+	} else if strings.HasPrefix(u.Host, "0.0.0.0:") {
+		// IPv4 all zeroes host, convert to IPv4 localhost
+		u.Host = "127.0.0.1" + u.Host[7:]
+	} else if strings.HasPrefix(u.Host, "[::]:") {
+		// IPv6 all zeroes host, convert to IPv6 localhost
+		u.Host = "[::1]" + u.Host[4:]
+	}
+
+	return u.String()
+}
+
+func (c GUIConfiguration) APIKey() string {
+	if override := os.Getenv("STGUIAPIKEY"); override != "" {
+		return override
+	}
+	return c.RawAPIKey
+}

lib/config/optionsconfiguration.go

@@ -0,0 +1,56 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+type OptionsConfiguration struct {
+	ListenAddress           []string `xml:"listenAddress" json:"listenAddress" default:"tcp://0.0.0.0:22000"`
+	GlobalAnnServers        []string `xml:"globalAnnounceServer" json:"globalAnnounceServers" json:"globalAnnounceServer" default:"default"`
+	GlobalAnnEnabled        bool     `xml:"globalAnnounceEnabled" json:"globalAnnounceEnabled" default:"true"`
+	LocalAnnEnabled         bool     `xml:"localAnnounceEnabled" json:"localAnnounceEnabled" default:"true"`
+	LocalAnnPort            int      `xml:"localAnnouncePort" json:"localAnnouncePort" default:"21027"`
+	LocalAnnMCAddr          string   `xml:"localAnnounceMCAddr" json:"localAnnounceMCAddr" default:"[ff12::8384]:21027"`
+	RelayServers            []string `xml:"relayServer" json:"relayServers" default:"dynamic+https://relays.syncthing.net/endpoint"`
+	MaxSendKbps             int      `xml:"maxSendKbps" json:"maxSendKbps"`
+	MaxRecvKbps             int      `xml:"maxRecvKbps" json:"maxRecvKbps"`
+	ReconnectIntervalS      int      `xml:"reconnectionIntervalS" json:"reconnectionIntervalS" default:"60"`
+	RelaysEnabled           bool     `xml:"relaysEnabled" json:"relaysEnabled" default:"true"`
+	RelayReconnectIntervalM int      `xml:"relayReconnectIntervalM" json:"relayReconnectIntervalM" default:"10"`
+	RelayWithoutGlobalAnn   bool     `xml:"relayWithoutGlobalAnn" json:"relayWithoutGlobalAnn" default:"false"`
+	StartBrowser            bool     `xml:"startBrowser" json:"startBrowser" default:"true"`
+	UPnPEnabled             bool     `xml:"upnpEnabled" json:"upnpEnabled" default:"true"`
+	UPnPLeaseM              int      `xml:"upnpLeaseMinutes" json:"upnpLeaseMinutes" default:"60"`
+	UPnPRenewalM            int      `xml:"upnpRenewalMinutes" json:"upnpRenewalMinutes" default:"30"`
+	UPnPTimeoutS            int      `xml:"upnpTimeoutSeconds" json:"upnpTimeoutSeconds" default:"10"`
+	URAccepted              int      `xml:"urAccepted" json:"urAccepted"` // Accepted usage reporting version; 0 for off (undecided), -1 for off (permanently)
+	URUniqueID              string   `xml:"urUniqueID" json:"urUniqueId"` // Unique ID for reporting purposes, regenerated when UR is turned on.
+	URURL                   string   `xml:"urURL" json:"urURL" default:"https://data.syncthing.net/newdata"`
+	URPostInsecurely        bool     `xml:"urPostInsecurely" json:"urPostInsecurely" default:"false"` // For testing
+	URInitialDelayS         int      `xml:"urInitialDelayS" json:"urInitialDelayS" default:"1800"`
+	RestartOnWakeup         bool     `xml:"restartOnWakeup" json:"restartOnWakeup" default:"true"`
+	AutoUpgradeIntervalH    int      `xml:"autoUpgradeIntervalH" json:"autoUpgradeIntervalH" default:"12"` // 0 for off
+	KeepTemporariesH        int      `xml:"keepTemporariesH" json:"keepTemporariesH" default:"24"`         // 0 for off
+	CacheIgnoredFiles       bool     `xml:"cacheIgnoredFiles" json:"cacheIgnoredFiles" default:"true"`
+	ProgressUpdateIntervalS int      `xml:"progressUpdateIntervalS" json:"progressUpdateIntervalS" default:"5"`
+	SymlinksEnabled         bool     `xml:"symlinksEnabled" json:"symlinksEnabled" default:"true"`
+	LimitBandwidthInLan     bool     `xml:"limitBandwidthInLan" json:"limitBandwidthInLan" default:"false"`
+	MinHomeDiskFreePct      float64  `xml:"minHomeDiskFreePct" json:"minHomeDiskFreePct" default:"1"`
+	ReleasesURL             string   `xml:"releasesURL" json:"releasesURL" default:"https://api.github.com/repos/syncthing/syncthing/releases?per_page=30"`
+	AlwaysLocalNets         []string `xml:"alwaysLocalNet" json:"alwaysLocalNets"`
+}
+
+func (orig OptionsConfiguration) Copy() OptionsConfiguration {
+	c := orig
+	c.ListenAddress = make([]string, len(orig.ListenAddress))
+	copy(c.ListenAddress, orig.ListenAddress)
+	c.GlobalAnnServers = make([]string, len(orig.GlobalAnnServers))
+	copy(c.GlobalAnnServers, orig.GlobalAnnServers)
+	c.RelayServers = make([]string, len(orig.RelayServers))
+	copy(c.RelayServers, orig.RelayServers)
+	c.AlwaysLocalNets = make([]string, len(orig.AlwaysLocalNets))
+	copy(c.AlwaysLocalNets, orig.AlwaysLocalNets)
+	return c
+}

lib/config/pullorder.go

@@ -0,0 +1,61 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+type PullOrder int
+
+const (
+	OrderRandom PullOrder = iota // default is random
+	OrderAlphabetic
+	OrderSmallestFirst
+	OrderLargestFirst
+	OrderOldestFirst
+	OrderNewestFirst
+)
+
+func (o PullOrder) String() string {
+	switch o {
+	case OrderRandom:
+		return "random"
+	case OrderAlphabetic:
+		return "alphabetic"
+	case OrderSmallestFirst:
+		return "smallestFirst"
+	case OrderLargestFirst:
+		return "largestFirst"
+	case OrderOldestFirst:
+		return "oldestFirst"
+	case OrderNewestFirst:
+		return "newestFirst"
+	default:
+		return "unknown"
+	}
+}
+
+func (o PullOrder) MarshalText() ([]byte, error) {
+	return []byte(o.String()), nil
+}
+
+func (o *PullOrder) UnmarshalText(bs []byte) error {
+	switch string(bs) {
+	case "random":
+		*o = OrderRandom
+	case "alphabetic":
+		*o = OrderAlphabetic
+	case "smallestFirst":
+		*o = OrderSmallestFirst
+	case "largestFirst":
+		*o = OrderLargestFirst
+	case "oldestFirst":
+		*o = OrderOldestFirst
+	case "newestFirst":
+		*o = OrderNewestFirst
+	default:
+		*o = OrderRandom
+	}
+	return nil
+}

lib/config/testdata/v12.xml

@@ -3,6 +3,7 @@
         <device id="AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR"></device>
         <device id="P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2"></device>
         <minDiskFreePct>1</minDiskFreePct>
+        <maxConflicts>-1</maxConflicts>
     </folder>
     <device id="AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR" name="node one" compression="metadata">
         <address>tcp://a</address>

lib/config/versioningconfiguration.go

@@ -0,0 +1,59 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package config
+
+import "encoding/xml"
+
+type VersioningConfiguration struct {
+	Type   string            `xml:"type,attr" json:"type"`
+	Params map[string]string `json:"params"`
+}
+
+type InternalVersioningConfiguration struct {
+	Type   string          `xml:"type,attr,omitempty"`
+	Params []InternalParam `xml:"param"`
+}
+
+type InternalParam struct {
+	Key string `xml:"key,attr"`
+	Val string `xml:"val,attr"`
+}
+
+func (c VersioningConfiguration) Copy() VersioningConfiguration {
+	cp := c
+	cp.Params = make(map[string]string, len(c.Params))
+	for k, v := range c.Params {
+		cp.Params[k] = v
+	}
+	return cp
+}
+
+func (c *VersioningConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	var tmp InternalVersioningConfiguration
+	tmp.Type = c.Type
+	for k, v := range c.Params {
+		tmp.Params = append(tmp.Params, InternalParam{k, v})
+	}
+
+	return e.EncodeElement(tmp, start)
+
+}
+
+func (c *VersioningConfiguration) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	var tmp InternalVersioningConfiguration
+	err := d.DecodeElement(&tmp, &start)
+	if err != nil {
+		return err
+	}
+
+	c.Type = tmp.Type
+	c.Params = make(map[string]string, len(tmp.Params))
+	for _, p := range tmp.Params {
+		c.Params[p.Key] = p.Val
+	}
+	return nil
+}

lib/connections/connections.go

@@ -20,7 +20,6 @@ import (
 	"github.com/syncthing/syncthing/lib/discover"
 	"github.com/syncthing/syncthing/lib/events"
 	"github.com/syncthing/syncthing/lib/model"
-	"github.com/syncthing/syncthing/lib/osutil"
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/relay"
 	"github.com/syncthing/syncthing/lib/relay/client"
@@ -368,11 +367,6 @@ func (s *connectionSvc) connect() {
 					l.Debugln("Sucessfully joined relay session", inv)
 				}
 
-				err = osutil.SetTCPOptions(conn.(*net.TCPConn))
-				if err != nil {
-					l.Infoln(err)
-				}
-
 				var tc *tls.Conn
 
 				if inv.ServerSocket {

lib/connections/connections_tcp.go

@@ -12,6 +12,7 @@ import (
 	"net/url"
 	"strings"
 
+	"github.com/syncthing/syncthing/lib/dialer"
 	"github.com/syncthing/syncthing/lib/model"
 	"github.com/syncthing/syncthing/lib/osutil"
 )
@@ -37,17 +38,12 @@ func tcpDialer(uri *url.URL, tlsCfg *tls.Config) (*tls.Conn, error) {
 		return nil, err
 	}
 
-	conn, err := net.DialTCP("tcp", nil, raddr)
+	conn, err := dialer.Dial(raddr.Network(), raddr.String())
 	if err != nil {
 		l.Debugln(err)
 		return nil, err
 	}
 
-	err = osutil.SetTCPOptions(conn)
-	if err != nil {
-		l.Infoln(err)
-	}
-
 	tc := tls.Client(conn, tlsCfg)
 	err = tc.Handshake()
 	if err != nil {

lib/db/benchmark_test.go

@@ -0,0 +1,186 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// +build benchmark
+
+package db_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+var files, oneFile, firstHalf, secondHalf []protocol.FileInfo
+var fs *db.FileSet
+
+func init() {
+	for i := 0; i < 1000; i++ {
+		files = append(files, protocol.FileInfo{
+			Name:    fmt.Sprintf("file%d", i),
+			Version: protocol.Vector{{ID: myID, Value: 1000}},
+			Blocks:  genBlocks(i),
+		})
+	}
+
+	middle := len(files) / 2
+	firstHalf = files[:middle]
+	secondHalf = files[middle:]
+	oneFile = firstHalf[middle-1 : middle]
+
+	ldb, _ := tempDB()
+	fs = db.NewFileSet("test", ldb)
+	fs.Replace(remoteDevice0, files)
+	fs.Replace(protocol.LocalDeviceID, firstHalf)
+}
+
+func tempDB() (*db.Instance, string) {
+	dir, err := ioutil.TempDir("", "syncthing")
+	if err != nil {
+		panic(err)
+	}
+	dbi, err := db.Open(filepath.Join(dir, "db"))
+	if err != nil {
+		panic(err)
+	}
+	return dbi, dir
+}
+
+func BenchmarkReplaceAll(b *testing.B) {
+	ldb, dir := tempDB()
+	defer func() {
+		ldb.Close()
+		os.RemoveAll(dir)
+	}()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		m := db.NewFileSet("test", ldb)
+		m.Replace(protocol.LocalDeviceID, files)
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkUpdateOneChanged(b *testing.B) {
+	changed := make([]protocol.FileInfo, 1)
+	changed[0] = oneFile[0]
+	changed[0].Version = changed[0].Version.Update(myID)
+	changed[0].Blocks = genBlocks(len(changed[0].Blocks))
+
+	for i := 0; i < b.N; i++ {
+		if i%1 == 0 {
+			fs.Update(protocol.LocalDeviceID, changed)
+		} else {
+			fs.Update(protocol.LocalDeviceID, oneFile)
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkUpdateOneUnchanged(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		fs.Update(protocol.LocalDeviceID, oneFile)
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkNeedHalf(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithNeed(protocol.LocalDeviceID, func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(secondHalf) {
+			b.Errorf("wrong length %d != %d", count, len(secondHalf))
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkHave(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithHave(protocol.LocalDeviceID, func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(firstHalf) {
+			b.Errorf("wrong length %d != %d", count, len(firstHalf))
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkGlobal(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithGlobal(func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(files) {
+			b.Errorf("wrong length %d != %d", count, len(files))
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkNeedHalfTruncated(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithNeedTruncated(protocol.LocalDeviceID, func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(secondHalf) {
+			b.Errorf("wrong length %d != %d", count, len(secondHalf))
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkHaveTruncated(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithHaveTruncated(protocol.LocalDeviceID, func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(firstHalf) {
+			b.Errorf("wrong length %d != %d", count, len(firstHalf))
+		}
+	}
+
+	b.ReportAllocs()
+}
+
+func BenchmarkGlobalTruncated(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		count := 0
+		fs.WithGlobalTruncated(func(fi db.FileIntf) bool {
+			count++
+			return true
+		})
+		if count != len(files) {
+			b.Errorf("wrong length %d != %d", count, len(files))
+		}
+	}
+
+	b.ReportAllocs()
+}

lib/db/blockmap.go

@@ -26,12 +26,14 @@ import (
 
 var blockFinder *BlockFinder
 
+const maxBatchSize = 256 << 10
+
 type BlockMap struct {
-	db     *leveldb.DB
+	db     *Instance
 	folder string
 }
 
-func NewBlockMap(db *leveldb.DB, folder string) *BlockMap {
+func NewBlockMap(db *Instance, folder string) *BlockMap {
 	return &BlockMap{
 		db:     db,
 		folder: folder,
@@ -42,14 +44,23 @@ func NewBlockMap(db *leveldb.DB, folder string) *BlockMap {
 func (m *BlockMap) Add(files []protocol.FileInfo) error {
 	batch := new(leveldb.Batch)
 	buf := make([]byte, 4)
+	var key []byte
 	for _, file := range files {
+		if batch.Len() > maxBatchSize {
+			if err := m.db.Write(batch, nil); err != nil {
+				return err
+			}
+			batch.Reset()
+		}
+
 		if file.IsDirectory() || file.IsDeleted() || file.IsInvalid() {
 			continue
 		}
 
 		for i, block := range file.Blocks {
 			binary.BigEndian.PutUint32(buf, uint32(i))
-			batch.Put(m.blockKey(block.Hash, file.Name), buf)
+			key = m.blockKeyInto(key, block.Hash, file.Name)
+			batch.Put(key, buf)
 		}
 	}
 	return m.db.Write(batch, nil)
@@ -59,21 +70,31 @@ func (m *BlockMap) Add(files []protocol.FileInfo) error {
 func (m *BlockMap) Update(files []protocol.FileInfo) error {
 	batch := new(leveldb.Batch)
 	buf := make([]byte, 4)
+	var key []byte
 	for _, file := range files {
+		if batch.Len() > maxBatchSize {
+			if err := m.db.Write(batch, nil); err != nil {
+				return err
+			}
+			batch.Reset()
+		}
+
 		if file.IsDirectory() {
 			continue
 		}
 
 		if file.IsDeleted() || file.IsInvalid() {
 			for _, block := range file.Blocks {
-				batch.Delete(m.blockKey(block.Hash, file.Name))
+				key = m.blockKeyInto(key, block.Hash, file.Name)
+				batch.Delete(key)
 			}
 			continue
 		}
 
 		for i, block := range file.Blocks {
 			binary.BigEndian.PutUint32(buf, uint32(i))
-			batch.Put(m.blockKey(block.Hash, file.Name), buf)
+			key = m.blockKeyInto(key, block.Hash, file.Name)
+			batch.Put(key, buf)
 		}
 	}
 	return m.db.Write(batch, nil)
@@ -82,9 +103,18 @@ func (m *BlockMap) Update(files []protocol.FileInfo) error {
 // Discard block map state, removing the given files
 func (m *BlockMap) Discard(files []protocol.FileInfo) error {
 	batch := new(leveldb.Batch)
+	var key []byte
 	for _, file := range files {
+		if batch.Len() > maxBatchSize {
+			if err := m.db.Write(batch, nil); err != nil {
+				return err
+			}
+			batch.Reset()
+		}
+
 		for _, block := range file.Blocks {
-			batch.Delete(m.blockKey(block.Hash, file.Name))
+			key = m.blockKeyInto(key, block.Hash, file.Name)
+			batch.Delete(key)
 		}
 	}
 	return m.db.Write(batch, nil)
@@ -93,9 +123,16 @@ func (m *BlockMap) Discard(files []protocol.FileInfo) error {
 // Drop block map, removing all entries related to this block map from the db.
 func (m *BlockMap) Drop() error {
 	batch := new(leveldb.Batch)
-	iter := m.db.NewIterator(util.BytesPrefix(m.blockKey(nil, "")[:1+64]), nil)
+	iter := m.db.NewIterator(util.BytesPrefix(m.blockKeyInto(nil, nil, "")[:1+64]), nil)
 	defer iter.Release()
 	for iter.Next() {
+		if batch.Len() > maxBatchSize {
+			if err := m.db.Write(batch, nil); err != nil {
+				return err
+			}
+			batch.Reset()
+		}
+
 		batch.Delete(iter.Key())
 	}
 	if iter.Error() != nil {
@@ -104,15 +141,15 @@ func (m *BlockMap) Drop() error {
 	return m.db.Write(batch, nil)
 }
 
-func (m *BlockMap) blockKey(hash []byte, file string) []byte {
-	return toBlockKey(hash, m.folder, file)
+func (m *BlockMap) blockKeyInto(o, hash []byte, file string) []byte {
+	return blockKeyInto(o, hash, m.folder, file)
 }
 
 type BlockFinder struct {
-	db *leveldb.DB
+	db *Instance
 }
 
-func NewBlockFinder(db *leveldb.DB) *BlockFinder {
+func NewBlockFinder(db *Instance) *BlockFinder {
 	if blockFinder != nil {
 		return blockFinder
 	}
@@ -134,8 +171,9 @@ func (f *BlockFinder) String() string {
 // reason. The iterator finally returns the result, whether or not a
 // satisfying block was eventually found.
 func (f *BlockFinder) Iterate(folders []string, hash []byte, iterFn func(string, string, int32) bool) bool {
+	var key []byte
 	for _, folder := range folders {
-		key := toBlockKey(hash, folder, "")
+		key = blockKeyInto(key, hash, folder, "")
 		iter := f.db.NewIterator(util.BytesPrefix(key), nil)
 		defer iter.Release()
 
@@ -157,8 +195,8 @@ func (f *BlockFinder) Fix(folder, file string, index int32, oldHash, newHash []b
 	binary.BigEndian.PutUint32(buf, uint32(index))
 
 	batch := new(leveldb.Batch)
-	batch.Delete(toBlockKey(oldHash, folder, file))
-	batch.Put(toBlockKey(newHash, folder, file), buf)
+	batch.Delete(blockKeyInto(nil, oldHash, folder, file))
+	batch.Put(blockKeyInto(nil, newHash, folder, file), buf)
 	return f.db.Write(batch, nil)
 }
 
@@ -167,8 +205,13 @@ func (f *BlockFinder) Fix(folder, file string, index int32, oldHash, newHash []b
 //	   folder (64 bytes)
 //	   block hash (32 bytes)
 //	   file name (variable size)
-func toBlockKey(hash []byte, folder, file string) []byte {
-	o := make([]byte, 1+64+32+len(file))
+func blockKeyInto(o, hash []byte, folder, file string) []byte {
+	reqLen := 1 + 64 + 32 + len(file)
+	if cap(o) < reqLen {
+		o = make([]byte, reqLen)
+	} else {
+		o = o[:reqLen]
+	}
 	o[0] = KeyTypeBlock
 	copy(o[1:], []byte(folder))
 	copy(o[1+64:], []byte(hash))

lib/db/blockmap_test.go

@@ -10,9 +10,6 @@ import (
 	"testing"
 
 	"github.com/syncthing/syncthing/lib/protocol"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 func genBlocks(n int) []protocol.BlockInfo {
@@ -50,17 +47,14 @@ func init() {
 	}
 }
 
-func setup() (*leveldb.DB, *BlockFinder) {
+func setup() (*Instance, *BlockFinder) {
 	// Setup
 
-	db, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		panic(err)
-	}
+	db := OpenMemory()
 	return db, NewBlockFinder(db)
 }
 
-func dbEmpty(db *leveldb.DB) bool {
+func dbEmpty(db *Instance) bool {
 	iter := db.NewIterator(nil, nil)
 	defer iter.Release()
 	if iter.Next() {

lib/db/leveldb.go

@@ -12,15 +12,11 @@ package db
 import (
 	"bytes"
 	"fmt"
-	"runtime"
-	"sort"
 
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/sync"
 	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/iterator"
 	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
 var (
@@ -90,496 +86,11 @@ type dbReader interface {
 	Get([]byte, *opt.ReadOptions) ([]byte, error)
 }
 
-type dbWriter interface {
-	Put([]byte, []byte)
-	Delete([]byte)
-}
-
 // Flush batches to disk when they contain this many records.
 const batchFlushSize = 64
 
-// deviceKey returns a byte slice encoding the following information:
-//	   keyTypeDevice (1 byte)
-//	   folder (64 bytes)
-//	   device (32 bytes)
-//	   name (variable size)
-func deviceKey(folder, device, file []byte) []byte {
-	return deviceKeyInto(nil, folder, device, file)
-}
-
-func deviceKeyInto(k []byte, folder, device, file []byte) []byte {
-	reqLen := 1 + 64 + 32 + len(file)
-	if len(k) < reqLen {
-		k = make([]byte, reqLen)
-	}
-	k[0] = KeyTypeDevice
-	if len(folder) > 64 {
-		panic("folder name too long")
-	}
-	copy(k[1:], []byte(folder))
-	copy(k[1+64:], device[:])
-	copy(k[1+64+32:], []byte(file))
-	return k[:reqLen]
-}
-
-func deviceKeyName(key []byte) []byte {
-	return key[1+64+32:]
-}
-
-func deviceKeyFolder(key []byte) []byte {
-	folder := key[1 : 1+64]
-	izero := bytes.IndexByte(folder, 0)
-	if izero < 0 {
-		return folder
-	}
-	return folder[:izero]
-}
-
-func deviceKeyDevice(key []byte) []byte {
-	return key[1+64 : 1+64+32]
-}
-
-// globalKey returns a byte slice encoding the following information:
-//	   keyTypeGlobal (1 byte)
-//	   folder (64 bytes)
-//	   name (variable size)
-func globalKey(folder, file []byte) []byte {
-	k := make([]byte, 1+64+len(file))
-	k[0] = KeyTypeGlobal
-	if len(folder) > 64 {
-		panic("folder name too long")
-	}
-	copy(k[1:], []byte(folder))
-	copy(k[1+64:], []byte(file))
-	return k
-}
-
-func globalKeyName(key []byte) []byte {
-	return key[1+64:]
-}
-
-func globalKeyFolder(key []byte) []byte {
-	folder := key[1 : 1+64]
-	izero := bytes.IndexByte(folder, 0)
-	if izero < 0 {
-		return folder
-	}
-	return folder[:izero]
-}
-
-type deletionHandler func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64
-
-func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, deleteFn deletionHandler) int64 {
-	runtime.GC()
-
-	sort.Sort(fileList(fs)) // sort list on name, same as in the database
-
-	start := deviceKey(folder, device, nil)                            // before all folder/device files
-	limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
-
-	batch := new(leveldb.Batch)
-	l.Debugf("new batch %p", batch)
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
-	defer dbi.Release()
-
-	moreDb := dbi.Next()
-	fsi := 0
-	var maxLocalVer int64
-
-	for {
-		var newName, oldName []byte
-		moreFs := fsi < len(fs)
-
-		if !moreDb && !moreFs {
-			break
-		}
-
-		if moreFs {
-			newName = []byte(fs[fsi].Name)
-		}
-
-		if moreDb {
-			oldName = deviceKeyName(dbi.Key())
-		}
-
-		cmp := bytes.Compare(newName, oldName)
-
-		l.Debugf("generic replace; folder=%q device=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", folder, protocol.DeviceIDFromBytes(device), moreFs, moreDb, cmp, newName, oldName)
-
-		switch {
-		case moreFs && (!moreDb || cmp == -1):
-			l.Debugln("generic replace; missing - insert")
-			// Database is missing this file. Insert it.
-			if lv := ldbInsert(batch, folder, device, fs[fsi]); lv > maxLocalVer {
-				maxLocalVer = lv
-			}
-			if fs[fsi].IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, folder, device, newName)
-			} else {
-				ldbUpdateGlobal(snap, batch, folder, device, fs[fsi])
-			}
-			fsi++
-
-		case moreFs && moreDb && cmp == 0:
-			// File exists on both sides - compare versions. We might get an
-			// update with the same version and different flags if a device has
-			// marked a file as invalid, so handle that too.
-			l.Debugln("generic replace; exists - compare")
-			var ef FileInfoTruncated
-			ef.UnmarshalXDR(dbi.Value())
-			if !fs[fsi].Version.Equal(ef.Version) || fs[fsi].Flags != ef.Flags {
-				l.Debugln("generic replace; differs - insert")
-				if lv := ldbInsert(batch, folder, device, fs[fsi]); lv > maxLocalVer {
-					maxLocalVer = lv
-				}
-				if fs[fsi].IsInvalid() {
-					ldbRemoveFromGlobal(snap, batch, folder, device, newName)
-				} else {
-					ldbUpdateGlobal(snap, batch, folder, device, fs[fsi])
-				}
-			} else {
-				l.Debugln("generic replace; equal - ignore")
-			}
-
-			fsi++
-			moreDb = dbi.Next()
-
-		case moreDb && (!moreFs || cmp == 1):
-			l.Debugln("generic replace; exists - remove")
-			if lv := deleteFn(snap, batch, folder, device, oldName, dbi); lv > maxLocalVer {
-				maxLocalVer = lv
-			}
-			moreDb = dbi.Next()
-		}
-
-		// Write out and reuse the batch every few records, to avoid the batch
-		// growing too large and thus allocating unnecessarily much memory.
-		if batch.Len() > batchFlushSize {
-			l.Debugf("db.Write %p", batch)
-
-			err = db.Write(batch, nil)
-			if err != nil {
-				panic(err)
-			}
-
-			batch.Reset()
-		}
-	}
-
-	l.Debugf("db.Write %p", batch)
-	err = db.Write(batch, nil)
-	if err != nil {
-		panic(err)
-	}
-
-	return maxLocalVer
-}
-
-func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) int64 {
-	// TODO: Return the remaining maxLocalVer?
-	return ldbGenericReplace(db, folder, device, fs, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64 {
-		// Database has a file that we are missing. Remove it.
-		l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name)
-		ldbRemoveFromGlobal(db, batch, folder, device, name)
-		l.Debugf("batch.Delete %p %x", batch, dbi.Key())
-		batch.Delete(dbi.Key())
-		return 0
-	})
-}
-
-func ldbUpdate(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) int64 {
-	runtime.GC()
-
-	batch := new(leveldb.Batch)
-	l.Debugf("new batch %p", batch)
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	var maxLocalVer int64
-	var fk []byte
-	for _, f := range fs {
-		name := []byte(f.Name)
-		fk = deviceKeyInto(fk[:cap(fk)], folder, device, name)
-		l.Debugf("snap.Get %p %x", snap, fk)
-		bs, err := snap.Get(fk, nil)
-		if err == leveldb.ErrNotFound {
-			if lv := ldbInsert(batch, folder, device, f); lv > maxLocalVer {
-				maxLocalVer = lv
-			}
-			if f.IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, folder, device, name)
-			} else {
-				ldbUpdateGlobal(snap, batch, folder, device, f)
-			}
-			continue
-		}
-
-		var ef FileInfoTruncated
-		err = ef.UnmarshalXDR(bs)
-		if err != nil {
-			panic(err)
-		}
-		// Flags might change without the version being bumped when we set the
-		// invalid flag on an existing file.
-		if !ef.Version.Equal(f.Version) || ef.Flags != f.Flags {
-			if lv := ldbInsert(batch, folder, device, f); lv > maxLocalVer {
-				maxLocalVer = lv
-			}
-			if f.IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, folder, device, name)
-			} else {
-				ldbUpdateGlobal(snap, batch, folder, device, f)
-			}
-		}
-
-		// Write out and reuse the batch every few records, to avoid the batch
-		// growing too large and thus allocating unnecessarily much memory.
-		if batch.Len() > batchFlushSize {
-			l.Debugf("db.Write %p", batch)
-
-			err = db.Write(batch, nil)
-			if err != nil {
-				panic(err)
-			}
-
-			batch.Reset()
-		}
-	}
-
-	l.Debugf("db.Write %p", batch)
-	err = db.Write(batch, nil)
-	if err != nil {
-		panic(err)
-	}
-
-	return maxLocalVer
-}
-
-func ldbInsert(batch dbWriter, folder, device []byte, file protocol.FileInfo) int64 {
-	l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file)
-
-	if file.LocalVersion == 0 {
-		file.LocalVersion = clock(0)
-	}
-
-	name := []byte(file.Name)
-	nk := deviceKey(folder, device, name)
-	l.Debugf("batch.Put %p %x", batch, nk)
-	batch.Put(nk, file.MustMarshalXDR())
-
-	return file.LocalVersion
-}
-
-// ldbUpdateGlobal adds this device+version to the version list for the given
-// file. If the device is already present in the list, the version is updated.
-// If the file does not have an entry in the global list, it is created.
-func ldbUpdateGlobal(db dbReader, batch dbWriter, folder, device []byte, file protocol.FileInfo) bool {
-	l.Debugf("update global; folder=%q device=%v file=%q version=%d", folder, protocol.DeviceIDFromBytes(device), file.Name, file.Version)
-	name := []byte(file.Name)
-	gk := globalKey(folder, name)
-	svl, err := db.Get(gk, nil)
-	if err != nil && err != leveldb.ErrNotFound {
-		panic(err)
-	}
-
-	var fl versionList
-
-	// Remove the device from the current version list
-	if svl != nil {
-		err = fl.UnmarshalXDR(svl)
-		if err != nil {
-			panic(err)
-		}
-
-		for i := range fl.versions {
-			if bytes.Compare(fl.versions[i].device, device) == 0 {
-				if fl.versions[i].version.Equal(file.Version) {
-					// No need to do anything
-					return false
-				}
-				fl.versions = append(fl.versions[:i], fl.versions[i+1:]...)
-				break
-			}
-		}
-	}
-
-	nv := fileVersion{
-		device:  device,
-		version: file.Version,
-	}
-
-	// Find a position in the list to insert this file. The file at the front
-	// of the list is the newer, the "global".
-	for i := range fl.versions {
-		switch fl.versions[i].version.Compare(file.Version) {
-		case protocol.Equal, protocol.Lesser:
-			// The version at this point in the list is equal to or lesser
-			// ("older") than us. We insert ourselves in front of it.
-			fl.versions = insertVersion(fl.versions, i, nv)
-			goto done
-
-		case protocol.ConcurrentLesser, protocol.ConcurrentGreater:
-			// The version at this point is in conflict with us. We must pull
-			// the actual file metadata to determine who wins. If we win, we
-			// insert ourselves in front of the loser here. (The "Lesser" and
-			// "Greater" in the condition above is just based on the device
-			// IDs in the version vector, which is not the only thing we use
-			// to determine the winner.)
-			of, ok := ldbGet(db, folder, fl.versions[i].device, name)
-			if !ok {
-				panic("file referenced in version list does not exist")
-			}
-			if file.WinsConflict(of) {
-				fl.versions = insertVersion(fl.versions, i, nv)
-				goto done
-			}
-		}
-	}
-
-	// We didn't find a position for an insert above, so append to the end.
-	fl.versions = append(fl.versions, nv)
-
-done:
-	l.Debugf("batch.Put %p %x", batch, gk)
-	l.Debugf("new global after update: %v", fl)
-	batch.Put(gk, fl.MustMarshalXDR())
-
-	return true
-}
-
-func insertVersion(vl []fileVersion, i int, v fileVersion) []fileVersion {
-	t := append(vl, fileVersion{})
-	copy(t[i+1:], t[i:])
-	t[i] = v
-	return t
-}
-
-// ldbRemoveFromGlobal removes the device from the global version list for the
-// given file. If the version list is empty after this, the file entry is
-// removed entirely.
-func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byte) {
-	l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file)
-
-	gk := globalKey(folder, file)
-	svl, err := db.Get(gk, nil)
-	if err != nil {
-		// We might be called to "remove" a global version that doesn't exist
-		// if the first update for the file is already marked invalid.
-		return
-	}
-
-	var fl versionList
-	err = fl.UnmarshalXDR(svl)
-	if err != nil {
-		panic(err)
-	}
-
-	for i := range fl.versions {
-		if bytes.Compare(fl.versions[i].device, device) == 0 {
-			fl.versions = append(fl.versions[:i], fl.versions[i+1:]...)
-			break
-		}
-	}
-
-	if len(fl.versions) == 0 {
-		l.Debugf("batch.Delete %p %x", batch, gk)
-		batch.Delete(gk)
-	} else {
-		l.Debugf("batch.Put %p %x", batch, gk)
-		l.Debugf("new global after remove: %v", fl)
-		batch.Put(gk, fl.MustMarshalXDR())
-	}
-}
-
-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()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
-	defer dbi.Release()
-
-	for dbi.Next() {
-		f, err := unmarshalTrunc(dbi.Value(), truncate)
-		if err != nil {
-			panic(err)
-		}
-		if cont := fn(f); !cont {
-			return
-		}
-	}
-}
-
-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
-	limit := deviceKey(folder, protocol.LocalDeviceID[:], []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
-	defer dbi.Release()
-
-	for dbi.Next() {
-		device := deviceKeyDevice(dbi.Key())
-		var f FileInfoTruncated
-		err := f.UnmarshalXDR(dbi.Value())
-		if err != nil {
-			panic(err)
-		}
-
-		switch f.Name {
-		case "", ".", "..", "/": // A few obviously invalid filenames
-			l.Infof("Dropping invalid filename %q from database", f.Name)
-			batch := new(leveldb.Batch)
-			ldbRemoveFromGlobal(db, batch, folder, device, nil)
-			batch.Delete(dbi.Key())
-			db.Write(batch, nil)
-			continue
-		}
-
-		if cont := fn(device, f); !cont {
-			return
-		}
-	}
-}
-
-func ldbGet(db dbReader, folder, device, file []byte) (protocol.FileInfo, bool) {
-	nk := deviceKey(folder, device, file)
-	bs, err := db.Get(nk, nil)
+func getFile(db dbReader, key []byte) (protocol.FileInfo, bool) {
+	bs, err := db.Get(key, nil)
 	if err == leveldb.ErrNotFound {
 		return protocol.FileInfo{}, false
 	}
@@ -594,367 +105,3 @@ func ldbGet(db dbReader, folder, device, file []byte) (protocol.FileInfo, bool)
 	}
 	return f, true
 }
-
-func ldbGetGlobal(db *leveldb.DB, folder, file []byte, truncate bool) (FileIntf, bool) {
-	k := globalKey(folder, file)
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	l.Debugf("snap.Get %p %x", snap, k)
-	bs, err := snap.Get(k, nil)
-	if err == leveldb.ErrNotFound {
-		return nil, false
-	}
-	if err != nil {
-		panic(err)
-	}
-
-	var vl versionList
-	err = vl.UnmarshalXDR(bs)
-	if err != nil {
-		panic(err)
-	}
-	if len(vl.versions) == 0 {
-		l.Debugln(k)
-		panic("no versions?")
-	}
-
-	k = deviceKey(folder, vl.versions[0].device, file)
-	l.Debugf("snap.Get %p %x", snap, k)
-	bs, err = snap.Get(k, nil)
-	if err != nil {
-		panic(err)
-	}
-
-	fi, err := unmarshalTrunc(bs, truncate)
-	if err != nil {
-		panic(err)
-	}
-	return fi, true
-}
-
-func ldbWithGlobal(db *leveldb.DB, folder, prefix []byte, truncate bool, fn Iterator) {
-	runtime.GC()
-
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(util.BytesPrefix(globalKey(folder, prefix)), nil)
-	defer dbi.Release()
-
-	var fk []byte
-	for dbi.Next() {
-		var vl versionList
-		err := vl.UnmarshalXDR(dbi.Value())
-		if err != nil {
-			panic(err)
-		}
-		if len(vl.versions) == 0 {
-			l.Debugln(dbi.Key())
-			panic("no versions?")
-		}
-		name := globalKeyName(dbi.Key())
-		fk = deviceKeyInto(fk[:cap(fk)], folder, vl.versions[0].device, name)
-		l.Debugf("snap.Get %p %x", snap, fk)
-		bs, err := snap.Get(fk, nil)
-		if err != nil {
-			l.Debugf("folder: %q (%x)", folder, folder)
-			l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key())
-			l.Debugf("vl: %v", vl)
-			l.Debugf("vl.versions[0].device: %x", vl.versions[0].device)
-			l.Debugf("name: %q (%x)", name, name)
-			l.Debugf("fk: %q", fk)
-			l.Debugf("fk: %x %x %x", fk[1:1+64], fk[1+64:1+64+32], fk[1+64+32:])
-			panic(err)
-		}
-
-		f, err := unmarshalTrunc(bs, truncate)
-		if err != nil {
-			panic(err)
-		}
-
-		if cont := fn(f); !cont {
-			return
-		}
-	}
-}
-
-func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID {
-	k := globalKey(folder, file)
-	bs, err := db.Get(k, nil)
-	if err == leveldb.ErrNotFound {
-		return nil
-	}
-	if err != nil {
-		panic(err)
-	}
-
-	var vl versionList
-	err = vl.UnmarshalXDR(bs)
-	if err != nil {
-		panic(err)
-	}
-
-	var devices []protocol.DeviceID
-	for _, v := range vl.versions {
-		if !v.version.Equal(vl.versions[0].version) {
-			break
-		}
-		n := protocol.DeviceIDFromBytes(v.device)
-		devices = append(devices, n)
-	}
-
-	return devices
-}
-
-func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) {
-	runtime.GC()
-
-	start := globalKey(folder, nil)
-	limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
-	defer dbi.Release()
-
-	var fk []byte
-nextFile:
-	for dbi.Next() {
-		var vl versionList
-		err := vl.UnmarshalXDR(dbi.Value())
-		if err != nil {
-			panic(err)
-		}
-		if len(vl.versions) == 0 {
-			l.Debugln(dbi.Key())
-			panic("no versions?")
-		}
-
-		have := false // If we have the file, any version
-		need := false // If we have a lower version of the file
-		var haveVersion protocol.Vector
-		for _, v := range vl.versions {
-			if bytes.Compare(v.device, device) == 0 {
-				have = true
-				haveVersion = v.version
-				// XXX: This marks Concurrent (i.e. conflicting) changes as
-				// needs. Maybe we should do that, but it needs special
-				// handling in the puller.
-				need = !v.version.GreaterEqual(vl.versions[0].version)
-				break
-			}
-		}
-
-		if need || !have {
-			name := globalKeyName(dbi.Key())
-			needVersion := vl.versions[0].version
-
-		nextVersion:
-			for i := range vl.versions {
-				if !vl.versions[i].version.Equal(needVersion) {
-					// We haven't found a valid copy of the file with the needed version.
-					continue nextFile
-				}
-				fk = deviceKeyInto(fk[:cap(fk)], folder, vl.versions[i].device, name)
-				l.Debugf("snap.Get %p %x", snap, fk)
-				bs, err := snap.Get(fk, nil)
-				if err != nil {
-					var id protocol.DeviceID
-					copy(id[:], device)
-					l.Debugf("device: %v", id)
-					l.Debugf("need: %v, have: %v", need, have)
-					l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key())
-					l.Debugf("vl: %v", vl)
-					l.Debugf("i: %v", i)
-					l.Debugf("fk: %q (%x)", fk, fk)
-					l.Debugf("name: %q (%x)", name, name)
-					panic(err)
-				}
-
-				gf, err := unmarshalTrunc(bs, truncate)
-				if err != nil {
-					panic(err)
-				}
-
-				if gf.IsInvalid() {
-					// The file is marked invalid for whatever reason, don't use it.
-					continue nextVersion
-				}
-
-				if gf.IsDeleted() && !have {
-					// We don't need deleted files that we don't have
-					continue nextFile
-				}
-
-				l.Debugf("need folder=%q device=%v name=%q need=%v have=%v haveV=%d globalV=%d", folder, protocol.DeviceIDFromBytes(device), name, need, have, haveVersion, vl.versions[0].version)
-
-				if cont := fn(gf); !cont {
-					return
-				}
-
-				// This file is handled, no need to look further in the version list
-				continue nextFile
-			}
-		}
-	}
-}
-
-func ldbListFolders(db *leveldb.DB) []string {
-	runtime.GC()
-
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	dbi := snap.NewIterator(util.BytesPrefix([]byte{KeyTypeGlobal}), nil)
-	defer dbi.Release()
-
-	folderExists := make(map[string]bool)
-	for dbi.Next() {
-		folder := string(globalKeyFolder(dbi.Key()))
-		if !folderExists[folder] {
-			folderExists[folder] = true
-		}
-	}
-
-	folders := make([]string, 0, len(folderExists))
-	for k := range folderExists {
-		folders = append(folders, k)
-	}
-
-	sort.Strings(folders)
-	return folders
-}
-
-func ldbDropFolder(db *leveldb.DB, folder []byte) {
-	runtime.GC()
-
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	// Remove all items related to the given folder from the device->file bucket
-	dbi := snap.NewIterator(util.BytesPrefix([]byte{KeyTypeDevice}), nil)
-	for dbi.Next() {
-		itemFolder := deviceKeyFolder(dbi.Key())
-		if bytes.Compare(folder, itemFolder) == 0 {
-			db.Delete(dbi.Key(), nil)
-		}
-	}
-	dbi.Release()
-
-	// Remove all items related to the given folder from the global bucket
-	dbi = snap.NewIterator(util.BytesPrefix([]byte{KeyTypeGlobal}), nil)
-	for dbi.Next() {
-		itemFolder := globalKeyFolder(dbi.Key())
-		if bytes.Compare(folder, itemFolder) == 0 {
-			db.Delete(dbi.Key(), nil)
-		}
-	}
-	dbi.Release()
-}
-
-func unmarshalTrunc(bs []byte, truncate bool) (FileIntf, error) {
-	if truncate {
-		var tf FileInfoTruncated
-		err := tf.UnmarshalXDR(bs)
-		return tf, err
-	}
-
-	var tf protocol.FileInfo
-	err := tf.UnmarshalXDR(bs)
-	return tf, err
-}
-
-func ldbCheckGlobals(db *leveldb.DB, folder []byte) {
-	defer runtime.GC()
-
-	snap, err := db.GetSnapshot()
-	if err != nil {
-		panic(err)
-	}
-	l.Debugf("created snapshot %p", snap)
-	defer func() {
-		l.Debugf("close snapshot %p", snap)
-		snap.Release()
-	}()
-
-	start := globalKey(folder, nil)
-	limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
-	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
-	defer dbi.Release()
-
-	batch := new(leveldb.Batch)
-	l.Debugf("new batch %p", batch)
-
-	var fk []byte
-	for dbi.Next() {
-		gk := dbi.Key()
-		var vl versionList
-		err := vl.UnmarshalXDR(dbi.Value())
-		if err != nil {
-			panic(err)
-		}
-
-		// Check the global version list for consistency. An issue in previous
-		// versions of goleveldb could result in reordered writes so that
-		// there are global entries pointing to no longer existing files. Here
-		// we find those and clear them out.
-
-		name := globalKeyName(gk)
-		var newVL versionList
-		for _, version := range vl.versions {
-			fk = deviceKeyInto(fk[:cap(fk)], folder, version.device, name)
-			l.Debugf("snap.Get %p %x", snap, fk)
-			_, err := snap.Get(fk, nil)
-			if err == leveldb.ErrNotFound {
-				continue
-			}
-			if err != nil {
-				panic(err)
-			}
-			newVL.versions = append(newVL.versions, version)
-		}
-
-		if len(newVL.versions) != len(vl.versions) {
-			l.Infof("db repair: rewriting global version list for %x %x", gk[1:1+64], gk[1+64:])
-			batch.Put(dbi.Key(), newVL.MustMarshalXDR())
-		}
-	}
-	l.Debugf("db check completed for %q", folder)
-	db.Write(batch, nil)
-}

lib/db/leveldb_dbinstance.go

@@ -0,0 +1,690 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package db
+
+import (
+	"bytes"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type deletionHandler func(t readWriteTransaction, folder, device, name []byte, dbi iterator.Iterator) int64
+
+type Instance struct {
+	*leveldb.DB
+}
+
+func Open(file string) (*Instance, error) {
+	opts := &opt.Options{
+		OpenFilesCacheCapacity: 100,
+		WriteBuffer:            4 << 20,
+	}
+
+	db, err := leveldb.OpenFile(file, opts)
+	if leveldbIsCorrupted(err) {
+		db, err = leveldb.RecoverFile(file, opts)
+	}
+	if leveldbIsCorrupted(err) {
+		// The database is corrupted, and we've tried to recover it but it
+		// didn't work. At this point there isn't much to do beyond dropping
+		// the database and reindexing...
+		l.Infoln("Database corruption detected, unable to recover. Reinitializing...")
+		if err := os.RemoveAll(file); err != nil {
+			return nil, err
+		}
+		db, err = leveldb.OpenFile(file, opts)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return newDBInstance(db), nil
+}
+
+func OpenMemory() *Instance {
+	db, _ := leveldb.Open(storage.NewMemStorage(), nil)
+	return newDBInstance(db)
+}
+
+func newDBInstance(db *leveldb.DB) *Instance {
+	return &Instance{
+		DB: db,
+	}
+}
+
+func (db *Instance) genericReplace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker, deleteFn deletionHandler) int64 {
+	sort.Sort(fileList(fs)) // sort list on name, same as in the database
+
+	start := db.deviceKey(folder, device, nil)                            // before all folder/device files
+	limit := db.deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
+
+	t := db.newReadWriteTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
+	defer dbi.Release()
+
+	moreDb := dbi.Next()
+	fsi := 0
+	var maxLocalVer int64
+
+	isLocalDevice := bytes.Equal(device, protocol.LocalDeviceID[:])
+	for {
+		var newName, oldName []byte
+		moreFs := fsi < len(fs)
+
+		if !moreDb && !moreFs {
+			break
+		}
+
+		if moreFs {
+			newName = []byte(fs[fsi].Name)
+		}
+
+		if moreDb {
+			oldName = db.deviceKeyName(dbi.Key())
+		}
+
+		cmp := bytes.Compare(newName, oldName)
+
+		l.Debugf("generic replace; folder=%q device=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", folder, protocol.DeviceIDFromBytes(device), moreFs, moreDb, cmp, newName, oldName)
+
+		switch {
+		case moreFs && (!moreDb || cmp == -1):
+			l.Debugln("generic replace; missing - insert")
+			// Database is missing this file. Insert it.
+			if lv := t.insertFile(folder, device, fs[fsi]); lv > maxLocalVer {
+				maxLocalVer = lv
+			}
+			if isLocalDevice {
+				localSize.addFile(fs[fsi])
+			}
+			if fs[fsi].IsInvalid() {
+				t.removeFromGlobal(folder, device, newName, globalSize)
+			} else {
+				t.updateGlobal(folder, device, fs[fsi], globalSize)
+			}
+			fsi++
+
+		case moreFs && moreDb && cmp == 0:
+			// File exists on both sides - compare versions. We might get an
+			// update with the same version and different flags if a device has
+			// marked a file as invalid, so handle that too.
+			l.Debugln("generic replace; exists - compare")
+			var ef FileInfoTruncated
+			ef.UnmarshalXDR(dbi.Value())
+			if !fs[fsi].Version.Equal(ef.Version) || fs[fsi].Flags != ef.Flags {
+				l.Debugln("generic replace; differs - insert")
+				if lv := t.insertFile(folder, device, fs[fsi]); lv > maxLocalVer {
+					maxLocalVer = lv
+				}
+				if isLocalDevice {
+					localSize.removeFile(ef)
+					localSize.addFile(fs[fsi])
+				}
+				if fs[fsi].IsInvalid() {
+					t.removeFromGlobal(folder, device, newName, globalSize)
+				} else {
+					t.updateGlobal(folder, device, fs[fsi], globalSize)
+				}
+			} else {
+				l.Debugln("generic replace; equal - ignore")
+			}
+
+			fsi++
+			moreDb = dbi.Next()
+
+		case moreDb && (!moreFs || cmp == 1):
+			l.Debugln("generic replace; exists - remove")
+			if lv := deleteFn(t, folder, device, oldName, dbi); lv > maxLocalVer {
+				maxLocalVer = lv
+			}
+			moreDb = dbi.Next()
+		}
+
+		// Write out and reuse the batch every few records, to avoid the batch
+		// growing too large and thus allocating unnecessarily much memory.
+		t.checkFlush()
+	}
+
+	return maxLocalVer
+}
+
+func (db *Instance) replace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 {
+	// TODO: Return the remaining maxLocalVer?
+	return db.genericReplace(folder, device, fs, localSize, globalSize, func(t readWriteTransaction, folder, device, name []byte, dbi iterator.Iterator) int64 {
+		// Database has a file that we are missing. Remove it.
+		l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name)
+		t.removeFromGlobal(folder, device, name, globalSize)
+		t.Delete(dbi.Key())
+		return 0
+	})
+}
+
+func (db *Instance) updateFiles(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 {
+	t := db.newReadWriteTransaction()
+	defer t.close()
+
+	var maxLocalVer int64
+	var fk []byte
+	isLocalDevice := bytes.Equal(device, protocol.LocalDeviceID[:])
+	for _, f := range fs {
+		name := []byte(f.Name)
+		fk = db.deviceKeyInto(fk[:cap(fk)], folder, device, name)
+		bs, err := t.Get(fk, nil)
+		if err == leveldb.ErrNotFound {
+			if isLocalDevice {
+				localSize.addFile(f)
+			}
+
+			if lv := t.insertFile(folder, device, f); lv > maxLocalVer {
+				maxLocalVer = lv
+			}
+			if f.IsInvalid() {
+				t.removeFromGlobal(folder, device, name, globalSize)
+			} else {
+				t.updateGlobal(folder, device, f, globalSize)
+			}
+			continue
+		}
+
+		var ef FileInfoTruncated
+		err = ef.UnmarshalXDR(bs)
+		if err != nil {
+			panic(err)
+		}
+		// Flags might change without the version being bumped when we set the
+		// invalid flag on an existing file.
+		if !ef.Version.Equal(f.Version) || ef.Flags != f.Flags {
+			if isLocalDevice {
+				localSize.removeFile(ef)
+				localSize.addFile(f)
+			}
+
+			if lv := t.insertFile(folder, device, f); lv > maxLocalVer {
+				maxLocalVer = lv
+			}
+			if f.IsInvalid() {
+				t.removeFromGlobal(folder, device, name, globalSize)
+			} else {
+				t.updateGlobal(folder, device, f, globalSize)
+			}
+		}
+
+		// Write out and reuse the batch every few records, to avoid the batch
+		// growing too large and thus allocating unnecessarily much memory.
+		t.checkFlush()
+	}
+
+	return maxLocalVer
+}
+
+func (db *Instance) withHave(folder, device []byte, truncate bool, fn Iterator) {
+	start := db.deviceKey(folder, device, nil)                            // before all folder/device files
+	limit := db.deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
+
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
+	defer dbi.Release()
+
+	for dbi.Next() {
+		f, err := unmarshalTrunc(dbi.Value(), truncate)
+		if err != nil {
+			panic(err)
+		}
+		if cont := fn(f); !cont {
+			return
+		}
+	}
+}
+
+func (db *Instance) withAllFolderTruncated(folder []byte, fn func(device []byte, f FileInfoTruncated) bool) {
+	start := db.deviceKey(folder, nil, nil)                                                  // before all folder/device files
+	limit := db.deviceKey(folder, protocol.LocalDeviceID[:], []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
+
+	t := db.newReadWriteTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
+	defer dbi.Release()
+
+	for dbi.Next() {
+		device := db.deviceKeyDevice(dbi.Key())
+		var f FileInfoTruncated
+		err := f.UnmarshalXDR(dbi.Value())
+		if err != nil {
+			panic(err)
+		}
+
+		switch f.Name {
+		case "", ".", "..", "/": // A few obviously invalid filenames
+			l.Infof("Dropping invalid filename %q from database", f.Name)
+			t.removeFromGlobal(folder, device, nil, nil)
+			t.Delete(dbi.Key())
+			t.checkFlush()
+			continue
+		}
+
+		if cont := fn(device, f); !cont {
+			return
+		}
+	}
+}
+
+func (db *Instance) getFile(folder, device, file []byte) (protocol.FileInfo, bool) {
+	return getFile(db, db.deviceKey(folder, device, file))
+}
+
+func (db *Instance) getGlobal(folder, file []byte, truncate bool) (FileIntf, bool) {
+	k := db.globalKey(folder, file)
+
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	bs, err := t.Get(k, nil)
+	if err == leveldb.ErrNotFound {
+		return nil, false
+	}
+	if err != nil {
+		panic(err)
+	}
+
+	var vl versionList
+	err = vl.UnmarshalXDR(bs)
+	if err != nil {
+		panic(err)
+	}
+	if len(vl.versions) == 0 {
+		l.Debugln(k)
+		panic("no versions?")
+	}
+
+	k = db.deviceKey(folder, vl.versions[0].device, file)
+	bs, err = t.Get(k, nil)
+	if err != nil {
+		panic(err)
+	}
+
+	fi, err := unmarshalTrunc(bs, truncate)
+	if err != nil {
+		panic(err)
+	}
+	return fi, true
+}
+
+func (db *Instance) withGlobal(folder, prefix []byte, truncate bool, fn Iterator) {
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(util.BytesPrefix(db.globalKey(folder, prefix)), nil)
+	defer dbi.Release()
+
+	var fk []byte
+	for dbi.Next() {
+		var vl versionList
+		err := vl.UnmarshalXDR(dbi.Value())
+		if err != nil {
+			panic(err)
+		}
+		if len(vl.versions) == 0 {
+			l.Debugln(dbi.Key())
+			panic("no versions?")
+		}
+		name := db.globalKeyName(dbi.Key())
+		fk = db.deviceKeyInto(fk[:cap(fk)], folder, vl.versions[0].device, name)
+		bs, err := t.Get(fk, nil)
+		if err != nil {
+			l.Debugf("folder: %q (%x)", folder, folder)
+			l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key())
+			l.Debugf("vl: %v", vl)
+			l.Debugf("vl.versions[0].device: %x", vl.versions[0].device)
+			l.Debugf("name: %q (%x)", name, name)
+			l.Debugf("fk: %q", fk)
+			l.Debugf("fk: %x %x %x", fk[1:1+64], fk[1+64:1+64+32], fk[1+64+32:])
+			panic(err)
+		}
+
+		f, err := unmarshalTrunc(bs, truncate)
+		if err != nil {
+			panic(err)
+		}
+
+		if cont := fn(f); !cont {
+			return
+		}
+	}
+}
+
+func (db *Instance) availability(folder, file []byte) []protocol.DeviceID {
+	k := db.globalKey(folder, file)
+	bs, err := db.Get(k, nil)
+	if err == leveldb.ErrNotFound {
+		return nil
+	}
+	if err != nil {
+		panic(err)
+	}
+
+	var vl versionList
+	err = vl.UnmarshalXDR(bs)
+	if err != nil {
+		panic(err)
+	}
+
+	var devices []protocol.DeviceID
+	for _, v := range vl.versions {
+		if !v.version.Equal(vl.versions[0].version) {
+			break
+		}
+		n := protocol.DeviceIDFromBytes(v.device)
+		devices = append(devices, n)
+	}
+
+	return devices
+}
+
+func (db *Instance) withNeed(folder, device []byte, truncate bool, fn Iterator) {
+	start := db.globalKey(folder, nil)
+	limit := db.globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
+
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
+	defer dbi.Release()
+
+	var fk []byte
+nextFile:
+	for dbi.Next() {
+		var vl versionList
+		err := vl.UnmarshalXDR(dbi.Value())
+		if err != nil {
+			panic(err)
+		}
+		if len(vl.versions) == 0 {
+			l.Debugln(dbi.Key())
+			panic("no versions?")
+		}
+
+		have := false // If we have the file, any version
+		need := false // If we have a lower version of the file
+		var haveVersion protocol.Vector
+		for _, v := range vl.versions {
+			if bytes.Compare(v.device, device) == 0 {
+				have = true
+				haveVersion = v.version
+				// XXX: This marks Concurrent (i.e. conflicting) changes as
+				// needs. Maybe we should do that, but it needs special
+				// handling in the puller.
+				need = !v.version.GreaterEqual(vl.versions[0].version)
+				break
+			}
+		}
+
+		if need || !have {
+			name := db.globalKeyName(dbi.Key())
+			needVersion := vl.versions[0].version
+
+		nextVersion:
+			for i := range vl.versions {
+				if !vl.versions[i].version.Equal(needVersion) {
+					// We haven't found a valid copy of the file with the needed version.
+					continue nextFile
+				}
+				fk = db.deviceKeyInto(fk[:cap(fk)], folder, vl.versions[i].device, name)
+				bs, err := t.Get(fk, nil)
+				if err != nil {
+					var id protocol.DeviceID
+					copy(id[:], device)
+					l.Debugf("device: %v", id)
+					l.Debugf("need: %v, have: %v", need, have)
+					l.Debugf("key: %q (%x)", dbi.Key(), dbi.Key())
+					l.Debugf("vl: %v", vl)
+					l.Debugf("i: %v", i)
+					l.Debugf("fk: %q (%x)", fk, fk)
+					l.Debugf("name: %q (%x)", name, name)
+					panic(err)
+				}
+
+				gf, err := unmarshalTrunc(bs, truncate)
+				if err != nil {
+					panic(err)
+				}
+
+				if gf.IsInvalid() {
+					// The file is marked invalid for whatever reason, don't use it.
+					continue nextVersion
+				}
+
+				if gf.IsDeleted() && !have {
+					// We don't need deleted files that we don't have
+					continue nextFile
+				}
+
+				l.Debugf("need folder=%q device=%v name=%q need=%v have=%v haveV=%d globalV=%d", folder, protocol.DeviceIDFromBytes(device), name, need, have, haveVersion, vl.versions[0].version)
+
+				if cont := fn(gf); !cont {
+					return
+				}
+
+				// This file is handled, no need to look further in the version list
+				continue nextFile
+			}
+		}
+	}
+}
+
+func (db *Instance) ListFolders() []string {
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	dbi := t.NewIterator(util.BytesPrefix([]byte{KeyTypeGlobal}), nil)
+	defer dbi.Release()
+
+	folderExists := make(map[string]bool)
+	for dbi.Next() {
+		folder := string(db.globalKeyFolder(dbi.Key()))
+		if !folderExists[folder] {
+			folderExists[folder] = true
+		}
+	}
+
+	folders := make([]string, 0, len(folderExists))
+	for k := range folderExists {
+		folders = append(folders, k)
+	}
+
+	sort.Strings(folders)
+	return folders
+}
+
+func (db *Instance) dropFolder(folder []byte) {
+	t := db.newReadOnlyTransaction()
+	defer t.close()
+
+	// Remove all items related to the given folder from the device->file bucket
+	dbi := t.NewIterator(util.BytesPrefix([]byte{KeyTypeDevice}), nil)
+	for dbi.Next() {
+		itemFolder := db.deviceKeyFolder(dbi.Key())
+		if bytes.Compare(folder, itemFolder) == 0 {
+			db.Delete(dbi.Key(), nil)
+		}
+	}
+	dbi.Release()
+
+	// Remove all items related to the given folder from the global bucket
+	dbi = t.NewIterator(util.BytesPrefix([]byte{KeyTypeGlobal}), nil)
+	for dbi.Next() {
+		itemFolder := db.globalKeyFolder(dbi.Key())
+		if bytes.Compare(folder, itemFolder) == 0 {
+			db.Delete(dbi.Key(), nil)
+		}
+	}
+	dbi.Release()
+}
+
+func (db *Instance) checkGlobals(folder []byte, globalSize *sizeTracker) {
+	t := db.newReadWriteTransaction()
+	defer t.close()
+
+	start := db.globalKey(folder, nil)
+	limit := db.globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
+	dbi := t.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
+	defer dbi.Release()
+
+	var fk []byte
+	for dbi.Next() {
+		gk := dbi.Key()
+		var vl versionList
+		err := vl.UnmarshalXDR(dbi.Value())
+		if err != nil {
+			panic(err)
+		}
+
+		// Check the global version list for consistency. An issue in previous
+		// versions of goleveldb could result in reordered writes so that
+		// there are global entries pointing to no longer existing files. Here
+		// we find those and clear them out.
+
+		name := db.globalKeyName(gk)
+		var newVL versionList
+		for i, version := range vl.versions {
+			fk = db.deviceKeyInto(fk[:cap(fk)], folder, version.device, name)
+
+			_, err := t.Get(fk, nil)
+			if err == leveldb.ErrNotFound {
+				continue
+			}
+			if err != nil {
+				panic(err)
+			}
+			newVL.versions = append(newVL.versions, version)
+
+			if i == 0 {
+				fi, ok := t.getFile(folder, version.device, name)
+				if !ok {
+					panic("nonexistent global master file")
+				}
+				globalSize.addFile(fi)
+			}
+		}
+
+		if len(newVL.versions) != len(vl.versions) {
+			t.Put(dbi.Key(), newVL.MustMarshalXDR())
+			t.checkFlush()
+		}
+	}
+	l.Debugf("db check completed for %q", folder)
+}
+
+// deviceKey returns a byte slice encoding the following information:
+//	   keyTypeDevice (1 byte)
+//	   folder (64 bytes)
+//	   device (32 bytes)
+//	   name (variable size)
+func (db *Instance) deviceKey(folder, device, file []byte) []byte {
+	return db.deviceKeyInto(nil, folder, device, file)
+}
+
+func (db *Instance) deviceKeyInto(k []byte, folder, device, file []byte) []byte {
+	reqLen := 1 + 64 + 32 + len(file)
+	if len(k) < reqLen {
+		k = make([]byte, reqLen)
+	}
+	k[0] = KeyTypeDevice
+	if len(folder) > 64 {
+		panic("folder name too long")
+	}
+	copy(k[1:], []byte(folder))
+	copy(k[1+64:], device[:])
+	copy(k[1+64+32:], []byte(file))
+	return k[:reqLen]
+}
+
+func (db *Instance) deviceKeyName(key []byte) []byte {
+	return key[1+64+32:]
+}
+
+func (db *Instance) deviceKeyFolder(key []byte) []byte {
+	folder := key[1 : 1+64]
+	izero := bytes.IndexByte(folder, 0)
+	if izero < 0 {
+		return folder
+	}
+	return folder[:izero]
+}
+
+func (db *Instance) deviceKeyDevice(key []byte) []byte {
+	return key[1+64 : 1+64+32]
+}
+
+// globalKey returns a byte slice encoding the following information:
+//	   keyTypeGlobal (1 byte)
+//	   folder (64 bytes)
+//	   name (variable size)
+func (db *Instance) globalKey(folder, file []byte) []byte {
+	k := make([]byte, 1+64+len(file))
+	k[0] = KeyTypeGlobal
+	if len(folder) > 64 {
+		panic("folder name too long")
+	}
+	copy(k[1:], []byte(folder))
+	copy(k[1+64:], []byte(file))
+	return k
+}
+
+func (db *Instance) globalKeyName(key []byte) []byte {
+	return key[1+64:]
+}
+
+func (db *Instance) globalKeyFolder(key []byte) []byte {
+	folder := key[1 : 1+64]
+	izero := bytes.IndexByte(folder, 0)
+	if izero < 0 {
+		return folder
+	}
+	return folder[:izero]
+}
+
+func unmarshalTrunc(bs []byte, truncate bool) (FileIntf, error) {
+	if truncate {
+		var tf FileInfoTruncated
+		err := tf.UnmarshalXDR(bs)
+		return tf, err
+	}
+
+	var tf protocol.FileInfo
+	err := tf.UnmarshalXDR(bs)
+	return tf, err
+}
+
+// A "better" version of leveldb's errors.IsCorrupted.
+func leveldbIsCorrupted(err error) bool {
+	switch {
+	case err == nil:
+		return false
+
+	case errors.IsCorrupted(err):
+		return true
+
+	case strings.Contains(err.Error(), "corrupted"):
+		return true
+	}
+
+	return false
+}

lib/db/leveldb_test.go

@@ -16,17 +16,19 @@ func TestDeviceKey(t *testing.T) {
 	dev := []byte("device67890123456789012345678901")
 	name := []byte("name")
 
-	key := deviceKey(fld, dev, name)
+	db := &Instance{}
 
-	fld2 := deviceKeyFolder(key)
+	key := db.deviceKey(fld, dev, name)
+
+	fld2 := db.deviceKeyFolder(key)
 	if bytes.Compare(fld2, fld) != 0 {
 		t.Errorf("wrong folder %q != %q", fld2, fld)
 	}
-	dev2 := deviceKeyDevice(key)
+	dev2 := db.deviceKeyDevice(key)
 	if bytes.Compare(dev2, dev) != 0 {
 		t.Errorf("wrong device %q != %q", dev2, dev)
 	}
-	name2 := deviceKeyName(key)
+	name2 := db.deviceKeyName(key)
 	if bytes.Compare(name2, name) != 0 {
 		t.Errorf("wrong name %q != %q", name2, name)
 	}
@@ -36,13 +38,15 @@ func TestGlobalKey(t *testing.T) {
 	fld := []byte("folder6789012345678901234567890123456789012345678901234567890123")
 	name := []byte("name")
 
-	key := globalKey(fld, name)
+	db := &Instance{}
 
-	fld2 := globalKeyFolder(key)
+	key := db.globalKey(fld, name)
+
+	fld2 := db.globalKeyFolder(key)
 	if bytes.Compare(fld2, fld) != 0 {
 		t.Errorf("wrong folder %q != %q", fld2, fld)
 	}
-	name2 := globalKeyName(key)
+	name2 := db.globalKeyName(key)
 	if bytes.Compare(name2, name) != 0 {
 		t.Errorf("wrong name %q != %q", name2, name)
 	}

lib/db/leveldb_transactions.go

@@ -0,0 +1,250 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package db
+
+import (
+	"bytes"
+
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+// A readOnlyTransaction represents a database snapshot.
+type readOnlyTransaction struct {
+	*leveldb.Snapshot
+	db *Instance
+}
+
+func (db *Instance) newReadOnlyTransaction() readOnlyTransaction {
+	snap, err := db.GetSnapshot()
+	if err != nil {
+		panic(err)
+	}
+	return readOnlyTransaction{
+		Snapshot: snap,
+		db:       db,
+	}
+}
+
+func (t readOnlyTransaction) close() {
+	t.Release()
+}
+
+func (t readOnlyTransaction) getFile(folder, device, file []byte) (protocol.FileInfo, bool) {
+	return getFile(t, t.db.deviceKey(folder, device, file))
+}
+
+// A readWriteTransaction is a readOnlyTransaction plus a batch for writes.
+// The batch will be committed on close() or by checkFlush() if it exceeds the
+// batch size.
+type readWriteTransaction struct {
+	readOnlyTransaction
+	*leveldb.Batch
+}
+
+func (db *Instance) newReadWriteTransaction() readWriteTransaction {
+	t := db.newReadOnlyTransaction()
+	return readWriteTransaction{
+		readOnlyTransaction: t,
+		Batch:               new(leveldb.Batch),
+	}
+}
+
+func (t readWriteTransaction) close() {
+	if err := t.db.Write(t.Batch, nil); err != nil {
+		panic(err)
+	}
+	t.readOnlyTransaction.close()
+}
+
+func (t readWriteTransaction) checkFlush() {
+	if t.Batch.Len() > batchFlushSize {
+		if err := t.db.Write(t.Batch, nil); err != nil {
+			panic(err)
+		}
+		t.Batch.Reset()
+	}
+}
+
+func (t readWriteTransaction) insertFile(folder, device []byte, file protocol.FileInfo) int64 {
+	l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file)
+
+	if file.LocalVersion == 0 {
+		file.LocalVersion = clock(0)
+	}
+
+	name := []byte(file.Name)
+	nk := t.db.deviceKey(folder, device, name)
+	t.Put(nk, file.MustMarshalXDR())
+
+	return file.LocalVersion
+}
+
+// updateGlobal adds this device+version to the version list for the given
+// file. If the device is already present in the list, the version is updated.
+// If the file does not have an entry in the global list, it is created.
+func (t readWriteTransaction) updateGlobal(folder, device []byte, file protocol.FileInfo, globalSize *sizeTracker) bool {
+	l.Debugf("update global; folder=%q device=%v file=%q version=%d", folder, protocol.DeviceIDFromBytes(device), file.Name, file.Version)
+	name := []byte(file.Name)
+	gk := t.db.globalKey(folder, name)
+	svl, err := t.Get(gk, nil)
+	if err != nil && err != leveldb.ErrNotFound {
+		panic(err)
+	}
+
+	var fl versionList
+	var oldFile protocol.FileInfo
+	var hasOldFile bool
+	// Remove the device from the current version list
+	if svl != nil {
+		err = fl.UnmarshalXDR(svl)
+		if err != nil {
+			panic(err)
+		}
+
+		for i := range fl.versions {
+			if bytes.Compare(fl.versions[i].device, device) == 0 {
+				if fl.versions[i].version.Equal(file.Version) {
+					// No need to do anything
+					return false
+				}
+
+				if i == 0 {
+					// Keep the current newest file around so we can subtract it from
+					// the globalSize if we replace it.
+					oldFile, hasOldFile = t.getFile(folder, fl.versions[0].device, name)
+				}
+
+				fl.versions = append(fl.versions[:i], fl.versions[i+1:]...)
+				break
+			}
+		}
+	}
+
+	nv := fileVersion{
+		device:  device,
+		version: file.Version,
+	}
+
+	insertedAt := -1
+	// Find a position in the list to insert this file. The file at the front
+	// of the list is the newer, the "global".
+	for i := range fl.versions {
+		switch fl.versions[i].version.Compare(file.Version) {
+		case protocol.Equal, protocol.Lesser:
+			// The version at this point in the list is equal to or lesser
+			// ("older") than us. We insert ourselves in front of it.
+			fl.versions = insertVersion(fl.versions, i, nv)
+			insertedAt = i
+			goto done
+
+		case protocol.ConcurrentLesser, protocol.ConcurrentGreater:
+			// The version at this point is in conflict with us. We must pull
+			// the actual file metadata to determine who wins. If we win, we
+			// insert ourselves in front of the loser here. (The "Lesser" and
+			// "Greater" in the condition above is just based on the device
+			// IDs in the version vector, which is not the only thing we use
+			// to determine the winner.)
+			of, ok := t.getFile(folder, fl.versions[i].device, name)
+			if !ok {
+				panic("file referenced in version list does not exist")
+			}
+			if file.WinsConflict(of) {
+				fl.versions = insertVersion(fl.versions, i, nv)
+				insertedAt = i
+				goto done
+			}
+		}
+	}
+
+	// We didn't find a position for an insert above, so append to the end.
+	fl.versions = append(fl.versions, nv)
+	insertedAt = len(fl.versions) - 1
+
+done:
+	if insertedAt == 0 {
+		// We just inserted a new newest version. Fixup the global size
+		// calculation.
+		if !file.Version.Equal(oldFile.Version) {
+			globalSize.addFile(file)
+			if hasOldFile {
+				// We have the old file that was removed at the head of the list.
+				globalSize.removeFile(oldFile)
+			} else if len(fl.versions) > 1 {
+				// The previous newest version is now at index 1, grab it from there.
+				oldFile, ok := t.getFile(folder, fl.versions[1].device, name)
+				if !ok {
+					panic("file referenced in version list does not exist")
+				}
+				globalSize.removeFile(oldFile)
+			}
+		}
+	}
+
+	l.Debugf("new global after update: %v", fl)
+	t.Put(gk, fl.MustMarshalXDR())
+
+	return true
+}
+
+// removeFromGlobal removes the device from the global version list for the
+// given file. If the version list is empty after this, the file entry is
+// removed entirely.
+func (t readWriteTransaction) removeFromGlobal(folder, device, file []byte, globalSize *sizeTracker) {
+	l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file)
+
+	gk := t.db.globalKey(folder, file)
+	svl, err := t.Get(gk, nil)
+	if err != nil {
+		// We might be called to "remove" a global version that doesn't exist
+		// if the first update for the file is already marked invalid.
+		return
+	}
+
+	var fl versionList
+	err = fl.UnmarshalXDR(svl)
+	if err != nil {
+		panic(err)
+	}
+
+	removed := false
+	for i := range fl.versions {
+		if bytes.Compare(fl.versions[i].device, device) == 0 {
+			if i == 0 && globalSize != nil {
+				f, ok := t.getFile(folder, device, file)
+				if !ok {
+					panic("removing nonexistent file")
+				}
+				globalSize.removeFile(f)
+				removed = true
+			}
+			fl.versions = append(fl.versions[:i], fl.versions[i+1:]...)
+			break
+		}
+	}
+
+	if len(fl.versions) == 0 {
+		t.Delete(gk)
+	} else {
+		l.Debugf("new global after remove: %v", fl)
+		t.Put(gk, fl.MustMarshalXDR())
+		if removed {
+			f, ok := t.getFile(folder, fl.versions[0].device, file)
+			if !ok {
+				panic("new global is nonexistent file")
+			}
+			globalSize.addFile(f)
+		}
+	}
+}
+
+func insertVersion(vl []fileVersion, i int, v fileVersion) []fileVersion {
+	t := append(vl, fileVersion{})
+	copy(t[i+1:], t[i:])
+	t[i] = v
+	return t
+}

lib/db/namespaced.go

@@ -17,13 +17,13 @@ import (
 // NamespacedKV is a simple key-value store using a specific namespace within
 // a leveldb.
 type NamespacedKV struct {
-	db     *leveldb.DB
+	db     *Instance
 	prefix []byte
 }
 
 // NewNamespacedKV returns a new NamespacedKV that lives in the namespace
 // specified by the prefix.
-func NewNamespacedKV(db *leveldb.DB, prefix string) *NamespacedKV {
+func NewNamespacedKV(db *Instance, prefix string) *NamespacedKV {
 	return &NamespacedKV{
 		db:     db,
 		prefix: []byte(prefix),

lib/db/namespaced_test.go

@@ -9,16 +9,10 @@ package db
 import (
 	"testing"
 	"time"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 func TestNamespacedInt(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := OpenMemory()
 
 	n1 := NewNamespacedKV(ldb, "foo")
 	n2 := NewNamespacedKV(ldb, "bar")
@@ -53,10 +47,7 @@ func TestNamespacedInt(t *testing.T) {
 }
 
 func TestNamespacedTime(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := OpenMemory()
 
 	n1 := NewNamespacedKV(ldb, "foo")
 
@@ -73,10 +64,7 @@ func TestNamespacedTime(t *testing.T) {
 }
 
 func TestNamespacedString(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := OpenMemory()
 
 	n1 := NewNamespacedKV(ldb, "foo")
 
@@ -92,10 +80,7 @@ func TestNamespacedString(t *testing.T) {
 }
 
 func TestNamespacedReset(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := OpenMemory()
 
 	n1 := NewNamespacedKV(ldb, "foo")
 

lib/db/set.go

@@ -13,18 +13,21 @@
 package db
 
 import (
+	stdsync "sync"
+
 	"github.com/syncthing/syncthing/lib/osutil"
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/sync"
-	"github.com/syndtr/goleveldb/leveldb"
 )
 
 type FileSet struct {
 	localVersion map[protocol.DeviceID]int64
 	mutex        sync.Mutex
 	folder       string
-	db           *leveldb.DB
+	db           *Instance
 	blockmap     *BlockMap
+	localSize    sizeTracker
+	globalSize   sizeTracker
 }
 
 // FileIntf is the set of methods implemented by both protocol.FileInfo and
@@ -43,7 +46,53 @@ type FileIntf interface {
 // continue iteration, false to stop.
 type Iterator func(f FileIntf) bool
 
-func NewFileSet(folder string, db *leveldb.DB) *FileSet {
+type sizeTracker struct {
+	files   int
+	deleted int
+	bytes   int64
+	mut     stdsync.Mutex
+}
+
+func (s *sizeTracker) addFile(f FileIntf) {
+	if f.IsInvalid() {
+		return
+	}
+
+	s.mut.Lock()
+	if f.IsDeleted() {
+		s.deleted++
+	} else {
+		s.files++
+	}
+	s.bytes += f.Size()
+	s.mut.Unlock()
+}
+
+func (s *sizeTracker) removeFile(f FileIntf) {
+	if f.IsInvalid() {
+		return
+	}
+
+	s.mut.Lock()
+	if f.IsDeleted() {
+		s.deleted--
+	} else {
+		s.files--
+	}
+	s.bytes -= f.Size()
+	if s.deleted < 0 || s.files < 0 {
+		panic("bug: removed more than added")
+	}
+	s.mut.Unlock()
+}
+
+func (s *sizeTracker) Size() (files, deleted int, bytes int64) {
+	s.mut.Lock()
+	defer s.mut.Unlock()
+	return s.files, s.deleted, s.bytes
+}
+
+func NewFileSet(folder string, db *Instance) *FileSet {
 	var s = FileSet{
 		localVersion: make(map[protocol.DeviceID]int64),
 		folder:       folder,
@@ -52,14 +101,17 @@ func NewFileSet(folder string, db *leveldb.DB) *FileSet {
 		mutex:        sync.NewMutex(),
 	}
 
-	ldbCheckGlobals(db, []byte(folder))
+	s.db.checkGlobals([]byte(folder), &s.globalSize)
 
 	var deviceID protocol.DeviceID
-	ldbWithAllFolderTruncated(db, []byte(folder), func(device []byte, f FileInfoTruncated) bool {
+	s.db.withAllFolderTruncated([]byte(folder), func(device []byte, f FileInfoTruncated) bool {
 		copy(deviceID[:], device)
 		if f.LocalVersion > s.localVersion[deviceID] {
 			s.localVersion[deviceID] = f.LocalVersion
 		}
+		if deviceID == protocol.LocalDeviceID {
+			s.localSize.addFile(f)
+		}
 		return true
 	})
 	l.Debugf("loaded localVersion for %q: %#v", folder, s.localVersion)
@@ -73,7 +125,7 @@ func (s *FileSet) Replace(device protocol.DeviceID, fs []protocol.FileInfo) {
 	normalizeFilenames(fs)
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	s.localVersion[device] = ldbReplace(s.db, []byte(s.folder), device[:], fs)
+	s.localVersion[device] = s.db.replace([]byte(s.folder), device[:], fs, &s.localSize, &s.globalSize)
 	if len(fs) == 0 {
 		// Reset the local version if all files were removed.
 		s.localVersion[device] = 0
@@ -93,7 +145,7 @@ func (s *FileSet) 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, ok := ldbGet(s.db, []byte(s.folder), device[:], []byte(newFile.Name))
+			existingFile, ok := s.db.getFile([]byte(s.folder), device[:], []byte(newFile.Name))
 			if !ok || !existingFile.Version.Equal(newFile.Version) {
 				discards = append(discards, existingFile)
 				updates = append(updates, newFile)
@@ -102,54 +154,54 @@ func (s *FileSet) Update(device protocol.DeviceID, fs []protocol.FileInfo) {
 		s.blockmap.Discard(discards)
 		s.blockmap.Update(updates)
 	}
-	if lv := ldbUpdate(s.db, []byte(s.folder), device[:], fs); lv > s.localVersion[device] {
+	if lv := s.db.updateFiles([]byte(s.folder), device[:], fs, &s.localSize, &s.globalSize); lv > s.localVersion[device] {
 		s.localVersion[device] = lv
 	}
 }
 
 func (s *FileSet) WithNeed(device protocol.DeviceID, fn Iterator) {
 	l.Debugf("%s WithNeed(%v)", s.folder, device)
-	ldbWithNeed(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
+	s.db.withNeed([]byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithNeedTruncated(device protocol.DeviceID, fn Iterator) {
 	l.Debugf("%s WithNeedTruncated(%v)", s.folder, device)
-	ldbWithNeed(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
+	s.db.withNeed([]byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithHave(device protocol.DeviceID, fn Iterator) {
 	l.Debugf("%s WithHave(%v)", s.folder, device)
-	ldbWithHave(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
+	s.db.withHave([]byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithHaveTruncated(device protocol.DeviceID, fn Iterator) {
 	l.Debugf("%s WithHaveTruncated(%v)", s.folder, device)
-	ldbWithHave(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
+	s.db.withHave([]byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithGlobal(fn Iterator) {
 	l.Debugf("%s WithGlobal()", s.folder)
-	ldbWithGlobal(s.db, []byte(s.folder), nil, false, nativeFileIterator(fn))
+	s.db.withGlobal([]byte(s.folder), nil, false, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithGlobalTruncated(fn Iterator) {
 	l.Debugf("%s WithGlobalTruncated()", s.folder)
-	ldbWithGlobal(s.db, []byte(s.folder), nil, true, nativeFileIterator(fn))
+	s.db.withGlobal([]byte(s.folder), nil, true, nativeFileIterator(fn))
 }
 
 func (s *FileSet) WithPrefixedGlobalTruncated(prefix string, fn Iterator) {
 	l.Debugf("%s WithPrefixedGlobalTruncated()", s.folder, prefix)
-	ldbWithGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(prefix)), true, nativeFileIterator(fn))
+	s.db.withGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(prefix)), true, nativeFileIterator(fn))
 }
 
 func (s *FileSet) Get(device protocol.DeviceID, file string) (protocol.FileInfo, bool) {
-	f, ok := ldbGet(s.db, []byte(s.folder), device[:], []byte(osutil.NormalizedFilename(file)))
+	f, ok := s.db.getFile([]byte(s.folder), device[:], []byte(osutil.NormalizedFilename(file)))
 	f.Name = osutil.NativeFilename(f.Name)
 	return f, ok
 }
 
 func (s *FileSet) GetGlobal(file string) (protocol.FileInfo, bool) {
-	fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), false)
+	fi, ok := s.db.getGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(file)), false)
 	if !ok {
 		return protocol.FileInfo{}, false
 	}
@@ -159,7 +211,7 @@ func (s *FileSet) GetGlobal(file string) (protocol.FileInfo, bool) {
 }
 
 func (s *FileSet) GetGlobalTruncated(file string) (FileInfoTruncated, bool) {
-	fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), true)
+	fi, ok := s.db.getGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(file)), true)
 	if !ok {
 		return FileInfoTruncated{}, false
 	}
@@ -169,7 +221,7 @@ func (s *FileSet) GetGlobalTruncated(file string) (FileInfoTruncated, bool) {
 }
 
 func (s *FileSet) Availability(file string) []protocol.DeviceID {
-	return ldbAvailability(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)))
+	return s.db.availability([]byte(s.folder), []byte(osutil.NormalizedFilename(file)))
 }
 
 func (s *FileSet) LocalVersion(device protocol.DeviceID) int64 {
@@ -178,15 +230,18 @@ func (s *FileSet) LocalVersion(device protocol.DeviceID) int64 {
 	return s.localVersion[device]
 }
 
-// ListFolders returns the folder IDs seen in the database.
-func ListFolders(db *leveldb.DB) []string {
-	return ldbListFolders(db)
+func (s *FileSet) LocalSize() (files, deleted int, bytes int64) {
+	return s.localSize.Size()
+}
+
+func (s *FileSet) GlobalSize() (files, deleted int, bytes int64) {
+	return s.globalSize.Size()
 }
 
 // DropFolder clears out all information related to the given folder from the
 // database.
-func DropFolder(db *leveldb.DB, folder string) {
-	ldbDropFolder(db, []byte(folder))
+func DropFolder(db *Instance, folder string) {
+	db.dropFolder([]byte(folder))
 	bm := &BlockMap{
 		db:     db,
 		folder: folder,

lib/db/set_test.go

@@ -15,8 +15,6 @@ import (
 
 	"github.com/syncthing/syncthing/lib/db"
 	"github.com/syncthing/syncthing/lib/protocol"
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 var remoteDevice0, remoteDevice1 protocol.DeviceID
@@ -96,11 +94,7 @@ func (l fileList) String() string {
 }
 
 func TestGlobalSet(t *testing.T) {
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	m := db.NewFileSet("test", ldb)
 
@@ -173,6 +167,29 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal)
 	}
 
+	globalFiles, globalDeleted, globalBytes := 0, 0, int64(0)
+	for _, f := range g {
+		if f.IsInvalid() {
+			continue
+		}
+		if f.IsDeleted() {
+			globalDeleted++
+		} else {
+			globalFiles++
+		}
+		globalBytes += f.Size()
+	}
+	gsFiles, gsDeleted, gsBytes := m.GlobalSize()
+	if gsFiles != globalFiles {
+		t.Errorf("Incorrect GlobalSize files; %d != %d", gsFiles, globalFiles)
+	}
+	if gsDeleted != globalDeleted {
+		t.Errorf("Incorrect GlobalSize deleted; %d != %d", gsDeleted, globalDeleted)
+	}
+	if gsBytes != globalBytes {
+		t.Errorf("Incorrect GlobalSize bytes; %d != %d", gsBytes, globalBytes)
+	}
+
 	h := fileList(haveList(m, protocol.LocalDeviceID))
 	sort.Sort(h)
 
@@ -180,6 +197,29 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("Have incorrect;\n A: %v !=\n E: %v", h, localTot)
 	}
 
+	haveFiles, haveDeleted, haveBytes := 0, 0, int64(0)
+	for _, f := range h {
+		if f.IsInvalid() {
+			continue
+		}
+		if f.IsDeleted() {
+			haveDeleted++
+		} else {
+			haveFiles++
+		}
+		haveBytes += f.Size()
+	}
+	lsFiles, lsDeleted, lsBytes := m.LocalSize()
+	if lsFiles != haveFiles {
+		t.Errorf("Incorrect LocalSize files; %d != %d", lsFiles, haveFiles)
+	}
+	if lsDeleted != haveDeleted {
+		t.Errorf("Incorrect LocalSize deleted; %d != %d", lsDeleted, haveDeleted)
+	}
+	if lsBytes != haveBytes {
+		t.Errorf("Incorrect LocalSize bytes; %d != %d", lsBytes, haveBytes)
+	}
+
 	h = fileList(haveList(m, remoteDevice0))
 	sort.Sort(h)
 
@@ -257,10 +297,7 @@ func TestGlobalSet(t *testing.T) {
 }
 
 func TestNeedWithInvalid(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s := db.NewFileSet("test", ldb)
 
@@ -297,10 +334,7 @@ func TestNeedWithInvalid(t *testing.T) {
 }
 
 func TestUpdateToInvalid(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s := db.NewFileSet("test", ldb)
 
@@ -332,10 +366,7 @@ func TestUpdateToInvalid(t *testing.T) {
 }
 
 func TestInvalidAvailability(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s := db.NewFileSet("test", ldb)
 
@@ -371,186 +402,9 @@ func TestInvalidAvailability(t *testing.T) {
 		t.Error("Incorrect availability for 'none':", av)
 	}
 }
-func Benchmark10kReplace(b *testing.B) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	var local []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m := db.NewFileSet("test", ldb)
-		m.Replace(protocol.LocalDeviceID, local)
-	}
-}
-
-func Benchmark10kUpdateChg(b *testing.B) {
-	var remote []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	m := db.NewFileSet("test", ldb)
-	m.Replace(remoteDevice0, remote)
-
-	var local []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	m.Replace(protocol.LocalDeviceID, local)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		for j := range local {
-			local[j].Version = local[j].Version.Update(myID)
-		}
-		b.StartTimer()
-		m.Update(protocol.LocalDeviceID, local)
-	}
-}
-
-func Benchmark10kUpdateSme(b *testing.B) {
-	var remote []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	m := db.NewFileSet("test", ldb)
-	m.Replace(remoteDevice0, remote)
-
-	var local []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	m.Replace(protocol.LocalDeviceID, local)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.Update(protocol.LocalDeviceID, local)
-	}
-}
-
-func Benchmark10kNeed2k(b *testing.B) {
-	var remote []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	m := db.NewFileSet("test", ldb)
-	m.Replace(remoteDevice0, remote)
-
-	var local []protocol.FileInfo
-	for i := 0; i < 8000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-	for i := 8000; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{1, 980}}})
-	}
-
-	m.Replace(protocol.LocalDeviceID, local)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		fs := needList(m, protocol.LocalDeviceID)
-		if l := len(fs); l != 2000 {
-			b.Errorf("wrong length %d != 2k", l)
-		}
-	}
-}
-
-func Benchmark10kHaveFullList(b *testing.B) {
-	var remote []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	m := db.NewFileSet("test", ldb)
-	m.Replace(remoteDevice0, remote)
-
-	var local []protocol.FileInfo
-	for i := 0; i < 2000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-	for i := 2000; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{1, 980}}})
-	}
-
-	m.Replace(protocol.LocalDeviceID, local)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		fs := haveList(m, protocol.LocalDeviceID)
-		if l := len(fs); l != 10000 {
-			b.Errorf("wrong length %d != 10k", l)
-		}
-	}
-}
-
-func Benchmark10kGlobal(b *testing.B) {
-	var remote []protocol.FileInfo
-	for i := 0; i < 10000; i++ {
-		remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	m := db.NewFileSet("test", ldb)
-	m.Replace(remoteDevice0, remote)
-
-	var local []protocol.FileInfo
-	for i := 0; i < 2000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{ID: myID, Value: 1000}}})
-	}
-	for i := 2000; i < 10000; i++ {
-		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: protocol.Vector{{1, 980}}})
-	}
-
-	m.Replace(protocol.LocalDeviceID, local)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		fs := globalList(m)
-		if l := len(fs); l != 10000 {
-			b.Errorf("wrong length %d != 10k", l)
-		}
-	}
-}
 
 func TestGlobalReset(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	m := db.NewFileSet("test", ldb)
 
@@ -588,10 +442,7 @@ func TestGlobalReset(t *testing.T) {
 }
 
 func TestNeed(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	m := db.NewFileSet("test", ldb)
 
@@ -629,10 +480,7 @@ func TestNeed(t *testing.T) {
 }
 
 func TestLocalVersion(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	m := db.NewFileSet("test", ldb)
 
@@ -662,10 +510,7 @@ func TestLocalVersion(t *testing.T) {
 }
 
 func TestListDropFolder(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s0 := db.NewFileSet("test0", ldb)
 	local1 := []protocol.FileInfo{
@@ -686,7 +531,7 @@ func TestListDropFolder(t *testing.T) {
 	// Check that we have both folders and their data is in the global list
 
 	expectedFolderList := []string{"test0", "test1"}
-	if actualFolderList := db.ListFolders(ldb); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
+	if actualFolderList := ldb.ListFolders(); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
 		t.Fatalf("FolderList mismatch\nE: %v\nA: %v", expectedFolderList, actualFolderList)
 	}
 	if l := len(globalList(s0)); l != 3 {
@@ -701,7 +546,7 @@ func TestListDropFolder(t *testing.T) {
 	db.DropFolder(ldb, "test1")
 
 	expectedFolderList = []string{"test0"}
-	if actualFolderList := db.ListFolders(ldb); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
+	if actualFolderList := ldb.ListFolders(); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
 		t.Fatalf("FolderList mismatch\nE: %v\nA: %v", expectedFolderList, actualFolderList)
 	}
 	if l := len(globalList(s0)); l != 3 {
@@ -713,10 +558,7 @@ func TestListDropFolder(t *testing.T) {
 }
 
 func TestGlobalNeedWithInvalid(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s := db.NewFileSet("test1", ldb)
 
@@ -753,10 +595,7 @@ func TestGlobalNeedWithInvalid(t *testing.T) {
 }
 
 func TestLongPath(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := db.OpenMemory()
 
 	s := db.NewFileSet("test", ldb)
 

lib/db/truncated.go

@@ -6,22 +6,44 @@
 
 package db
 
-import "github.com/syncthing/syncthing/lib/protocol"
+import (
+	"bytes"
+
+	"github.com/calmh/xdr"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
 
 type FileInfoTruncated struct {
 	protocol.FileInfo
-	ActualSize int64
 }
 
-func (f *FileInfoTruncated) UnmarshalXDR(bs []byte) error {
-	err := f.FileInfo.UnmarshalXDR(bs)
-	f.ActualSize = f.FileInfo.Size()
-	f.FileInfo.Blocks = nil
-	return err
+func (o *FileInfoTruncated) UnmarshalXDR(bs []byte) error {
+	var br = bytes.NewReader(bs)
+	var xr = xdr.NewReader(br)
+	return o.DecodeXDRFrom(xr)
 }
 
-func (f FileInfoTruncated) Size() int64 {
-	return f.ActualSize
+func (o *FileInfoTruncated) DecodeXDRFrom(xr *xdr.Reader) error {
+	o.Name = xr.ReadStringMax(8192)
+	o.Flags = xr.ReadUint32()
+	o.Modified = int64(xr.ReadUint64())
+	(&o.Version).DecodeXDRFrom(xr)
+	o.LocalVersion = int64(xr.ReadUint64())
+	_BlocksSize := int(xr.ReadUint32())
+	if _BlocksSize < 0 {
+		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
+	}
+	if _BlocksSize > 1000000 {
+		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
+	}
+
+	buf := make([]byte, 64)
+	for i := 0; i < _BlocksSize; i++ {
+		size := xr.ReadUint32()
+		o.CachedSize += int64(size)
+		xr.ReadBytesMaxInto(64, buf)
+	}
+	return xr.Error()
 }
 
 func BlocksToSize(num int) int64 {

lib/db/virtualmtime.go

@@ -9,8 +9,6 @@ package db
 import (
 	"fmt"
 	"time"
-
-	"github.com/syndtr/goleveldb/leveldb"
 )
 
 // This type encapsulates a repository of mtimes for platforms where file mtimes
@@ -25,7 +23,7 @@ type VirtualMtimeRepo struct {
 	ns *NamespacedKV
 }
 
-func NewVirtualMtimeRepo(ldb *leveldb.DB, folder string) *VirtualMtimeRepo {
+func NewVirtualMtimeRepo(ldb *Instance, folder string) *VirtualMtimeRepo {
 	prefix := string(KeyTypeVirtualMtime) + folder
 
 	return &VirtualMtimeRepo{

lib/db/virtualmtime_test.go

@@ -9,16 +9,10 @@ package db
 import (
 	"testing"
 	"time"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 func TestVirtualMtimeRepo(t *testing.T) {
-	ldb, err := leveldb.Open(storage.NewMemStorage(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
+	ldb := OpenMemory()
 
 	// A few repos so we can ensure they don't pollute each other
 	repo1 := NewVirtualMtimeRepo(ldb, "folder1")

lib/dialer/dialer.go

@@ -0,0 +1,102 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dialer
+
+import (
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"golang.org/x/net/proxy"
+
+	"github.com/syncthing/syncthing/lib/logger"
+	"github.com/syncthing/syncthing/lib/osutil"
+)
+
+var (
+	l          = logger.DefaultLogger.NewFacility("dialer", "Dialing connections")
+	dialer     = proxy.FromEnvironment()
+	usingProxy = dialer != proxy.Direct
+)
+
+func init() {
+	l.SetDebug("dialer", strings.Contains(os.Getenv("STTRACE"), "dialer") || os.Getenv("STTRACE") == "all")
+	if usingProxy {
+		http.DefaultTransport = &http.Transport{
+			Dial:                Dial,
+			Proxy:               http.ProxyFromEnvironment,
+			TLSHandshakeTimeout: 10 * time.Second,
+		}
+
+		// Defer this, so that logging gets setup.
+		go func() {
+			time.Sleep(500 * time.Millisecond)
+			l.Infoln("Proxy settings detected")
+		}()
+	}
+}
+
+// Dial tries dialing via proxy if a proxy is configured, and falls back to
+// a direct connection if no proxy is defined, or connecting via proxy fails.
+func Dial(network, addr string) (net.Conn, error) {
+	if usingProxy {
+		conn, err := dialer.Dial(network, addr)
+		if err == nil {
+			l.Debugf("Dialing %s address %s via proxy - success, %s -> %s", network, addr, conn.LocalAddr(), conn.RemoteAddr())
+			if tcpconn, ok := conn.(*net.TCPConn); ok {
+				osutil.SetTCPOptions(tcpconn)
+			}
+			return dialerConn{
+				conn, newDialerAddr(network, addr),
+			}, nil
+		}
+		l.Debugf("Dialing %s address %s via proxy - error %s", network, addr, err)
+	}
+
+	conn, err := proxy.Direct.Dial(network, addr)
+	if err == nil {
+		l.Debugf("Dialing %s address %s directly - success, %s -> %s", network, addr, conn.LocalAddr(), conn.RemoteAddr())
+		if tcpconn, ok := conn.(*net.TCPConn); ok {
+			osutil.SetTCPOptions(tcpconn)
+		}
+	} else {
+		l.Debugf("Dialing %s address %s directly - error %s", network, addr, err)
+	}
+	return conn, err
+}
+
+type dialerConn struct {
+	net.Conn
+	addr net.Addr
+}
+
+func (c dialerConn) RemoteAddr() net.Addr {
+	return c.addr
+}
+
+func newDialerAddr(network, addr string) net.Addr {
+	netaddr, err := net.ResolveIPAddr(network, addr)
+	if err == nil {
+		return netaddr
+	}
+	return fallbackAddr{network, addr}
+}
+
+type fallbackAddr struct {
+	network string
+	addr    string
+}
+
+func (a fallbackAddr) Network() string {
+	return a.network
+}
+
+func (a fallbackAddr) String() string {
+	return a.addr
+}

lib/discover/cache.go

@@ -109,6 +109,12 @@ func (m *CachingMux) Lookup(deviceID protocol.DeviceID) (direct []string, relays
 				when:   time.Now(),
 				found:  len(td)+len(tr) > 0,
 			})
+		} else {
+			// Lookup returned error, add a negative cache entry.
+			m.caches[i].Set(deviceID, CacheEntry{
+				when:  time.Now(),
+				found: false,
+			})
 		}
 	}
 	m.mut.Unlock()

lib/discover/global.go

@@ -18,6 +18,7 @@ import (
 	stdsync "sync"
 	"time"
 
+	"github.com/syncthing/syncthing/lib/dialer"
 	"github.com/syncthing/syncthing/lib/events"
 	"github.com/syncthing/syncthing/lib/protocol"
 )
@@ -41,6 +42,7 @@ type httpClient interface {
 const (
 	defaultReannounceInterval  = 30 * time.Minute
 	announceErrorRetryInterval = 5 * time.Minute
+	requestTimeout             = 5 * time.Second
 )
 
 type announcement struct {
@@ -72,7 +74,10 @@ func NewGlobal(server string, cert tls.Certificate, addrList AddressLister, rela
 	// certificate to prove our identity, and may or may not verify the server
 	// certificate depending on the insecure setting.
 	var announceClient httpClient = &http.Client{
+		Timeout: requestTimeout,
 		Transport: &http.Transport{
+			Dial:  dialer.Dial,
+			Proxy: http.ProxyFromEnvironment,
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: opts.insecure,
 				Certificates:       []tls.Certificate{cert},
@@ -86,7 +91,10 @@ func NewGlobal(server string, cert tls.Certificate, addrList AddressLister, rela
 	// The http.Client used for queries. We don't need to present our
 	// certificate here, so lets not include it. May be insecure if requested.
 	var queryClient httpClient = &http.Client{
+		Timeout: requestTimeout,
 		Transport: &http.Transport{
+			Dial:  dialer.Dial,
+			Proxy: http.ProxyFromEnvironment,
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: opts.insecure,
 			},

lib/discover/global_test.go

@@ -79,11 +79,26 @@ func TestGlobalOverHTTP(t *testing.T) {
 	mux.HandleFunc("/", s.handler)
 	go http.Serve(list, mux)
 
+	// This should succeed
 	direct, relays, err := testLookup("http://" + list.Addr().String() + "?insecure&noannounce")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	if !testing.Short() {
+		// This should time out
+		_, _, err = testLookup("http://" + list.Addr().String() + "/block?insecure&noannounce")
+		if err == nil {
+			t.Fatalf("unexpected nil error, should have been a timeout")
+		}
+	}
+
+	// This should work again
+	_, _, err = testLookup("http://" + list.Addr().String() + "?insecure&noannounce")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
 	if len(direct) != 1 || direct[0] != "tcp://192.0.2.42::22000" {
 		t.Errorf("incorrect direct list: %+v", direct)
 	}
@@ -231,6 +246,11 @@ type fakeDiscoveryServer struct {
 }
 
 func (s *fakeDiscoveryServer) handler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path == "/block" {
+		// Never return for requests here
+		select {}
+	}
+
 	if r.Method == "POST" {
 		s.announce, _ = ioutil.ReadAll(r.Body)
 		w.WriteHeader(204)