gui: s/foldersendonly.html/foldertypes.html

Also rename and clarify the description of -reset-database (formerly
-reset).

AUTHORS

@@ -48,6 +48,7 @@ Felix Unterpaintner (bigbear2nd) <bigbear2nd@gmail.com>
 Francois-Xavier Gsell (zukoo) <fxgsell@gmail.com>
 Frank Isemann (fti7) <frank@isemann.name>
 Gilli Sigurdsson (gillisig) <gilli@vx.is>
+Heiko Zuerker (Smiley73) <heiko@zuerker.org>
 Jaakko Hannikainen (jgke) <jgke@jgke.fi>
 Jacek Szafarkiewicz (hadogenes) <szafar@linux.pl>
 Jake Peterson (acogdev) <jake@acogdev.com>

NICKS

@@ -101,6 +101,7 @@ sciurius <jvromans@squirrel.nl>
 seehuhn <voss@seehuhn.de>
 simplypeachy <aD@simplypeachy.co.uk>
 simplypeachy <simplypeachy@users.noreply.github.com>
+Smiley73 <heiko@zuerker.org>
 snnd <dw@risu.io>
 Stefan-Code <stefan.github@gmail.com>
 Stefan-Code <Stefan.github@gmail.com>

build.go

@@ -27,7 +27,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"syscall"
 	"text/template"
 	"time"
 )
@@ -154,6 +153,40 @@ var targets = map[string]target{
 	},
 }
 
+var (
+	// fast linters complete in a fraction of a second and might as well be
+	// run always as part of the build
+	fastLinters = []string{
+		"deadcode",
+		"golint",
+		"ineffassign",
+		"vet",
+	}
+
+	// slow linters take several seconds and are run only as part of the
+	// "metalint" command.
+	slowLinters = []string{
+		"gosimple",
+		"staticcheck",
+		"structcheck",
+		"unused",
+		"varcheck",
+	}
+
+	// Which parts of the tree to lint
+	lintDirs = []string{".", "./lib/...", "./cmd/..."}
+
+	// Messages to ignore
+	lintExcludes = []string{
+		".pb.go",
+		"should have comment",
+		"protocol.Vector composite literal uses unkeyed fields",
+		"cli.Requires composite literal uses unkeyed fields",
+		"Use DialContext instead",   // Go 1.7
+		"os.SEEK_SET is deprecated", // Go 1.7
+	}
+)
+
 func init() {
 	// The "syncthing" target includes a few more files found in the "etc"
 	// and "extra" dirs.
@@ -203,8 +236,6 @@ func main() {
 	// which is what you want for maximum error checking during development.
 	if flag.NArg() == 0 {
 		runCommand("install", targets["all"])
-		runCommand("vet", target{})
-		runCommand("lint", target{})
 	} else {
 		// with any command given but not a target, the target is
 		// "syncthing". So "go run build.go install" is "go run build.go install
@@ -242,6 +273,7 @@ func runCommand(cmd string, target target) {
 			tags = []string{"noupgrade"}
 		}
 		install(target, tags)
+		metalint(fastLinters, lintDirs)
 
 	case "build":
 		var tags []string
@@ -249,6 +281,7 @@ func runCommand(cmd string, target target) {
 			tags = []string{"noupgrade"}
 		}
 		build(target, tags)
+		metalint(fastLinters, lintDirs)
 
 	case "test":
 		test("./lib/...", "./cmd/...")
@@ -284,25 +317,14 @@ func runCommand(cmd string, target target) {
 		clean()
 
 	case "vet":
-		vet("build.go")
-		vet("cmd", "lib")
+		metalint(fastLinters, lintDirs)
 
 	case "lint":
-		lint(".")
-		lint("./cmd/...")
-		lint("./lib/...")
+		metalint(fastLinters, lintDirs)
 
 	case "metalint":
-		if isGometalinterInstalled() {
-			dirs := []string{".", "./cmd/...", "./lib/..."}
-			ok := gometalinter("deadcode", dirs, "test/util.go")
-			ok = gometalinter("structcheck", dirs) && ok
-			ok = gometalinter("varcheck", dirs) && ok
-			ok = gometalinter("ineffassign", dirs) && ok
-			if !ok {
-				os.Exit(1)
-			}
-		}
+		metalint(fastLinters, lintDirs)
+		metalint(slowLinters, lintDirs)
 
 	case "version":
 		fmt.Println(getVersion())
@@ -364,11 +386,15 @@ func setup() {
 		"github.com/FiloSottile/gvt",
 		"github.com/golang/lint/golint",
 		"github.com/gordonklaus/ineffassign",
+		"github.com/mdempsky/unconvert",
 		"github.com/mitchellh/go-wordwrap",
 		"github.com/opennota/check/cmd/...",
 		"github.com/tsenart/deadcode",
 		"golang.org/x/net/html",
 		"golang.org/x/tools/cmd/cover",
+		"honnef.co/go/simple/cmd/gosimple",
+		"honnef.co/go/staticcheck/cmd/staticcheck",
+		"honnef.co/go/unused/cmd/unused",
 	}
 	for _, pkg := range packages {
 		fmt.Println(pkg)
@@ -1003,48 +1029,6 @@ func zipFile(out string, files []archiveFile) {
 	}
 }
 
-func vet(dirs ...string) {
-	params := []string{"tool", "vet", "-all"}
-	params = append(params, dirs...)
-	bs, err := runError("go", params...)
-
-	if len(bs) > 0 {
-		log.Printf("%s", bs)
-	}
-
-	if err != nil {
-		if exitStatus(err) == 3 {
-			// Exit code 3, the "vet" tool is not installed
-			return
-		}
-
-		// A genuine error exit from the vet tool.
-		log.Fatal(err)
-	}
-}
-
-func lint(pkg string) {
-	bs, err := runError("golint", pkg)
-	if err != nil {
-		log.Println(`- No golint, not linting. Try "go get -u github.com/golang/lint/golint".`)
-		return
-	}
-
-	analCommentPolicy := regexp.MustCompile(`exported (function|method|const|type|var) [^\s]+ should have comment`)
-	for _, line := range strings.Split(string(bs), "\n") {
-		if line == "" {
-			continue
-		}
-		if analCommentPolicy.MatchString(line) {
-			continue
-		}
-		if strings.Contains(line, ".pb.go:") {
-			continue
-		}
-		log.Println(line)
-	}
-}
-
 func macosCodesign(file string) {
 	if pass := os.Getenv("CODESIGN_KEYCHAIN_PASS"); pass != "" {
 		bs, err := runError("security", "unlock-keychain", "-p", pass)
@@ -1064,14 +1048,16 @@ func macosCodesign(file string) {
 	}
 }
 
-func exitStatus(err error) int {
-	if err, ok := err.(*exec.ExitError); ok {
-		if ws, ok := err.ProcessState.Sys().(syscall.WaitStatus); ok {
-			return ws.ExitStatus()
+func metalint(linters []string, dirs []string) {
+	ok := true
+	if isGometalinterInstalled() {
+		if !gometalinter(linters, dirs, lintExcludes...) {
+			ok = false
 		}
 	}
-
-	return -1
+	if !ok {
+		log.Fatal("Build succeeded, but there were lint warnings")
+	}
 }
 
 func isGometalinterInstalled() bool {
@@ -1082,10 +1068,12 @@ func isGometalinterInstalled() bool {
 	return true
 }
 
-func gometalinter(linter string, dirs []string, excludes ...string) bool {
-	params := []string{"--disable-all"}
-	params = append(params, fmt.Sprintf("--deadline=%ds", 60))
-	params = append(params, "--enable="+linter)
+func gometalinter(linters []string, dirs []string, excludes ...string) bool {
+	params := []string{"--disable-all", "--concurrency=2", "--deadline=300s"}
+
+	for _, linter := range linters {
+		params = append(params, "--enable="+linter)
+	}
 
 	for _, exclude := range excludes {
 		params = append(params, "--exclude="+exclude)
@@ -1098,14 +1086,19 @@ func gometalinter(linter string, dirs []string, excludes ...string) bool {
 	bs, _ := runError("gometalinter", params...)
 
 	nerr := 0
+	lines := make(map[string]struct{})
 	for _, line := range strings.Split(string(bs), "\n") {
 		if line == "" {
 			continue
 		}
-		if strings.Contains(line, ".pb.go:") {
+		if _, ok := lines[line]; ok {
 			continue
 		}
 		log.Println(line)
+		if strings.Contains(line, "executable file not found") {
+			log.Println(` - Try "go run build.go setup" to install missing tools`)
+		}
+		lines[line] = struct{}{}
 		nerr++
 	}
 

cmd/stcli/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2014 Audrius Butkevičius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+- The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmd/stcli/README.md

@@ -0,0 +1,10 @@
+syncthing-cli
+=============
+
+[![Latest Build](http://img.shields.io/jenkins/s/http/build.syncthing.net/syncthing-cli.svg?style=flat-square)](http://build.syncthing.net/job/syncthing-cli/lastBuild/)
+
+A CLI that talks to the Syncthing REST interface.
+
+`go get github.com/syncthing/syncthing-cli`
+
+Or download the [latest build](http://build.syncthing.net/job/syncthing-cli/lastSuccessfulBuild/artifact/).

cmd/stcli/client.go

@@ -0,0 +1,115 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"bytes"
+	"crypto/tls"
+	"net/http"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+type APIClient struct {
+	httpClient http.Client
+	endpoint   string
+	apikey     string
+	username   string
+	password   string
+	id         string
+	csrf       string
+}
+
+var instance *APIClient
+
+func getClient(c *cli.Context) *APIClient {
+	if instance != nil {
+		return instance
+	}
+	endpoint := c.GlobalString("endpoint")
+	if !strings.HasPrefix(endpoint, "http") {
+		endpoint = "http://" + endpoint
+	}
+	httpClient := http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: c.GlobalBool("insecure"),
+			},
+		},
+	}
+	client := APIClient{
+		httpClient: httpClient,
+		endpoint:   endpoint,
+		apikey:     c.GlobalString("apikey"),
+		username:   c.GlobalString("username"),
+		password:   c.GlobalString("password"),
+	}
+
+	if client.apikey == "" {
+		request, err := http.NewRequest("GET", client.endpoint, nil)
+		die(err)
+		response := client.handleRequest(request)
+		client.id = response.Header.Get("X-Syncthing-ID")
+		if client.id == "" {
+			die("Failed to get device ID")
+		}
+		for _, item := range response.Cookies() {
+			if item.Name == "CSRF-Token-"+client.id[:5] {
+				client.csrf = item.Value
+				goto csrffound
+			}
+		}
+		die("Failed to get CSRF token")
+	csrffound:
+	}
+	instance = &client
+	return &client
+}
+
+func (client *APIClient) handleRequest(request *http.Request) *http.Response {
+	if client.apikey != "" {
+		request.Header.Set("X-API-Key", client.apikey)
+	}
+	if client.username != "" || client.password != "" {
+		request.SetBasicAuth(client.username, client.password)
+	}
+	if client.csrf != "" {
+		request.Header.Set("X-CSRF-Token-"+client.id[:5], client.csrf)
+	}
+
+	response, err := client.httpClient.Do(request)
+	die(err)
+
+	if response.StatusCode == 404 {
+		die("Invalid endpoint or API call")
+	} else if response.StatusCode == 401 {
+		die("Invalid username or password")
+	} else if response.StatusCode == 403 {
+		if client.apikey == "" {
+			die("Invalid CSRF token")
+		}
+		die("Invalid API key")
+	} else if response.StatusCode != 200 {
+		body := strings.TrimSpace(string(responseToBArray(response)))
+		if body != "" {
+			die(body)
+		}
+		die("Unknown HTTP status returned: " + response.Status)
+	}
+	return response
+}
+
+func httpGet(c *cli.Context, url string) *http.Response {
+	client := getClient(c)
+	request, err := http.NewRequest("GET", client.endpoint+"/rest/"+url, nil)
+	die(err)
+	return client.handleRequest(request)
+}
+
+func httpPost(c *cli.Context, url string, body string) *http.Response {
+	client := getClient(c)
+	request, err := http.NewRequest("POST", client.endpoint+"/rest/"+url, bytes.NewBufferString(body))
+	die(err)
+	return client.handleRequest(request)
+}

cmd/stcli/cmd_devices.go

@@ -0,0 +1,188 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+	"github.com/syncthing/syncthing/lib/config"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "devices",
+		HideHelp: true,
+		Usage:    "Device command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "list",
+				Usage:    "List registered devices",
+				Requires: &cli.Requires{},
+				Action:   devicesList,
+			},
+			{
+				Name:     "add",
+				Usage:    "Add a new device",
+				Requires: &cli.Requires{"device id", "device name?"},
+				Action:   devicesAdd,
+			},
+			{
+				Name:     "remove",
+				Usage:    "Remove an existing device",
+				Requires: &cli.Requires{"device id"},
+				Action:   devicesRemove,
+			},
+			{
+				Name:     "get",
+				Usage:    "Get a property of a device",
+				Requires: &cli.Requires{"device id", "property"},
+				Action:   devicesGet,
+			},
+			{
+				Name:     "set",
+				Usage:    "Set a property of a device",
+				Requires: &cli.Requires{"device id", "property", "value..."},
+				Action:   devicesSet,
+			},
+		},
+	})
+}
+
+func devicesList(c *cli.Context) {
+	cfg := getConfig(c)
+	first := true
+	writer := newTableWriter()
+	for _, device := range cfg.Devices {
+		if !first {
+			fmt.Fprintln(writer)
+		}
+		fmt.Fprintln(writer, "ID:\t", device.DeviceID, "\t")
+		fmt.Fprintln(writer, "Name:\t", device.Name, "\t(name)")
+		fmt.Fprintln(writer, "Address:\t", strings.Join(device.Addresses, " "), "\t(address)")
+		fmt.Fprintln(writer, "Compression:\t", device.Compression, "\t(compression)")
+		fmt.Fprintln(writer, "Certificate name:\t", device.CertName, "\t(certname)")
+		fmt.Fprintln(writer, "Introducer:\t", device.Introducer, "\t(introducer)")
+		first = false
+	}
+	writer.Flush()
+}
+
+func devicesAdd(c *cli.Context) {
+	nid := c.Args()[0]
+	id := parseDeviceID(nid)
+
+	newDevice := config.DeviceConfiguration{
+		DeviceID:  id,
+		Name:      nid,
+		Addresses: []string{"dynamic"},
+	}
+
+	if len(c.Args()) > 1 {
+		newDevice.Name = c.Args()[1]
+	}
+
+	if len(c.Args()) > 2 {
+		addresses := c.Args()[2:]
+		for _, item := range addresses {
+			if item == "dynamic" {
+				continue
+			}
+			validAddress(item)
+		}
+		newDevice.Addresses = addresses
+	}
+
+	cfg := getConfig(c)
+	for _, device := range cfg.Devices {
+		if device.DeviceID == id {
+			die("Device " + nid + " already exists")
+		}
+	}
+	cfg.Devices = append(cfg.Devices, newDevice)
+	setConfig(c, cfg)
+}
+
+func devicesRemove(c *cli.Context) {
+	nid := c.Args()[0]
+	id := parseDeviceID(nid)
+	if nid == getMyID(c) {
+		die("Cannot remove yourself")
+	}
+	cfg := getConfig(c)
+	for i, device := range cfg.Devices {
+		if device.DeviceID == id {
+			last := len(cfg.Devices) - 1
+			cfg.Devices[i] = cfg.Devices[last]
+			cfg.Devices = cfg.Devices[:last]
+			setConfig(c, cfg)
+			return
+		}
+	}
+	die("Device " + nid + " not found")
+}
+
+func devicesGet(c *cli.Context) {
+	nid := c.Args()[0]
+	id := parseDeviceID(nid)
+	arg := c.Args()[1]
+	cfg := getConfig(c)
+	for _, device := range cfg.Devices {
+		if device.DeviceID != id {
+			continue
+		}
+		switch strings.ToLower(arg) {
+		case "name":
+			fmt.Println(device.Name)
+		case "address":
+			fmt.Println(strings.Join(device.Addresses, "\n"))
+		case "compression":
+			fmt.Println(device.Compression.String())
+		case "certname":
+			fmt.Println(device.CertName)
+		case "introducer":
+			fmt.Println(device.Introducer)
+		default:
+			die("Invalid property: " + arg + "\nAvailable properties: name, address, compression, certname, introducer")
+		}
+		return
+	}
+	die("Device " + nid + " not found")
+}
+
+func devicesSet(c *cli.Context) {
+	nid := c.Args()[0]
+	id := parseDeviceID(nid)
+	arg := c.Args()[1]
+	config := getConfig(c)
+	for i, device := range config.Devices {
+		if device.DeviceID != id {
+			continue
+		}
+		switch strings.ToLower(arg) {
+		case "name":
+			config.Devices[i].Name = strings.Join(c.Args()[2:], " ")
+		case "address":
+			for _, item := range c.Args()[2:] {
+				if item == "dynamic" {
+					continue
+				}
+				validAddress(item)
+			}
+			config.Devices[i].Addresses = c.Args()[2:]
+		case "compression":
+			err := config.Devices[i].Compression.UnmarshalText([]byte(c.Args()[2]))
+			die(err)
+		case "certname":
+			config.Devices[i].CertName = strings.Join(c.Args()[2:], " ")
+		case "introducer":
+			config.Devices[i].Introducer = parseBool(c.Args()[2])
+		default:
+			die("Invalid property: " + arg + "\nAvailable properties: name, address, compression, certname, introducer")
+		}
+		setConfig(c, config)
+		return
+	}
+	die("Device " + nid + " not found")
+}

cmd/stcli/cmd_errors.go

@@ -0,0 +1,67 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "errors",
+		HideHelp: true,
+		Usage:    "Error command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "show",
+				Usage:    "Show pending errors",
+				Requires: &cli.Requires{},
+				Action:   errorsShow,
+			},
+			{
+				Name:     "push",
+				Usage:    "Push an error to active clients",
+				Requires: &cli.Requires{"error message..."},
+				Action:   errorsPush,
+			},
+			{
+				Name:     "clear",
+				Usage:    "Clear pending errors",
+				Requires: &cli.Requires{},
+				Action:   wrappedHTTPPost("system/error/clear"),
+			},
+		},
+	})
+}
+
+func errorsShow(c *cli.Context) {
+	response := httpGet(c, "system/error")
+	var data map[string][]map[string]interface{}
+	json.Unmarshal(responseToBArray(response), &data)
+	writer := newTableWriter()
+	for _, item := range data["errors"] {
+		time := item["time"].(string)[:19]
+		time = strings.Replace(time, "T", " ", 1)
+		err := item["error"].(string)
+		err = strings.TrimSpace(err)
+		fmt.Fprintln(writer, time+":\t"+err)
+	}
+	writer.Flush()
+}
+
+func errorsPush(c *cli.Context) {
+	err := strings.Join(c.Args(), " ")
+	response := httpPost(c, "system/error", strings.TrimSpace(err))
+	if response.StatusCode != 200 {
+		err = fmt.Sprint("Failed to push error\nStatus code: ", response.StatusCode)
+		body := string(responseToBArray(response))
+		if body != "" {
+			err += "\nBody: " + body
+		}
+		die(err)
+	}
+}

cmd/stcli/cmd_folders.go

@@ -0,0 +1,351 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+	"github.com/syncthing/syncthing/lib/config"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "folders",
+		HideHelp: true,
+		Usage:    "Folder command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "list",
+				Usage:    "List available folders",
+				Requires: &cli.Requires{},
+				Action:   foldersList,
+			},
+			{
+				Name:     "add",
+				Usage:    "Add a new folder",
+				Requires: &cli.Requires{"folder id", "directory"},
+				Action:   foldersAdd,
+			},
+			{
+				Name:     "remove",
+				Usage:    "Remove an existing folder",
+				Requires: &cli.Requires{"folder id"},
+				Action:   foldersRemove,
+			},
+			{
+				Name:     "override",
+				Usage:    "Override changes from other nodes for a master folder",
+				Requires: &cli.Requires{"folder id"},
+				Action:   foldersOverride,
+			},
+			{
+				Name:     "get",
+				Usage:    "Get a property of a folder",
+				Requires: &cli.Requires{"folder id", "property"},
+				Action:   foldersGet,
+			},
+			{
+				Name:     "set",
+				Usage:    "Set a property of a folder",
+				Requires: &cli.Requires{"folder id", "property", "value..."},
+				Action:   foldersSet,
+			},
+			{
+				Name:     "unset",
+				Usage:    "Unset a property of a folder",
+				Requires: &cli.Requires{"folder id", "property"},
+				Action:   foldersUnset,
+			},
+			{
+				Name:     "devices",
+				Usage:    "Folder devices command group",
+				HideHelp: true,
+				Subcommands: []cli.Command{
+					{
+						Name:     "list",
+						Usage:    "List of devices which the folder is shared with",
+						Requires: &cli.Requires{"folder id"},
+						Action:   foldersDevicesList,
+					},
+					{
+						Name:     "add",
+						Usage:    "Share a folder with a device",
+						Requires: &cli.Requires{"folder id", "device id"},
+						Action:   foldersDevicesAdd,
+					},
+					{
+						Name:     "remove",
+						Usage:    "Unshare a folder with a device",
+						Requires: &cli.Requires{"folder id", "device id"},
+						Action:   foldersDevicesRemove,
+					},
+					{
+						Name:     "clear",
+						Usage:    "Unshare a folder with all devices",
+						Requires: &cli.Requires{"folder id"},
+						Action:   foldersDevicesClear,
+					},
+				},
+			},
+		},
+	})
+}
+
+func foldersList(c *cli.Context) {
+	cfg := getConfig(c)
+	first := true
+	writer := newTableWriter()
+	for _, folder := range cfg.Folders {
+		if !first {
+			fmt.Fprintln(writer)
+		}
+		fmt.Fprintln(writer, "ID:\t", folder.ID, "\t")
+		fmt.Fprintln(writer, "Path:\t", folder.RawPath, "\t(directory)")
+		fmt.Fprintln(writer, "Folder type:\t", folder.Type, "\t(type)")
+		fmt.Fprintln(writer, "Ignore permissions:\t", folder.IgnorePerms, "\t(permissions)")
+		fmt.Fprintln(writer, "Rescan interval in seconds:\t", folder.RescanIntervalS, "\t(rescan)")
+
+		if folder.Versioning.Type != "" {
+			fmt.Fprintln(writer, "Versioning:\t", folder.Versioning.Type, "\t(versioning)")
+			for key, value := range folder.Versioning.Params {
+				fmt.Fprintf(writer, "Versioning %s:\t %s \t(versioning-%s)\n", key, value, key)
+			}
+		}
+		first = false
+	}
+	writer.Flush()
+}
+
+func foldersAdd(c *cli.Context) {
+	cfg := getConfig(c)
+	abs, err := filepath.Abs(c.Args()[1])
+	die(err)
+	folder := config.FolderConfiguration{
+		ID:      c.Args()[0],
+		RawPath: filepath.Clean(abs),
+	}
+	cfg.Folders = append(cfg.Folders, folder)
+	setConfig(c, cfg)
+}
+
+func foldersRemove(c *cli.Context) {
+	cfg := getConfig(c)
+	rid := c.Args()[0]
+	for i, folder := range cfg.Folders {
+		if folder.ID == rid {
+			last := len(cfg.Folders) - 1
+			cfg.Folders[i] = cfg.Folders[last]
+			cfg.Folders = cfg.Folders[:last]
+			setConfig(c, cfg)
+			return
+		}
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersOverride(c *cli.Context) {
+	cfg := getConfig(c)
+	rid := c.Args()[0]
+	for _, folder := range cfg.Folders {
+		if folder.ID == rid && folder.Type == config.FolderTypeSendOnly {
+			response := httpPost(c, "db/override", "")
+			if response.StatusCode != 200 {
+				err := fmt.Sprint("Failed to override changes\nStatus code: ", response.StatusCode)
+				body := string(responseToBArray(response))
+				if body != "" {
+					err += "\nBody: " + body
+				}
+				die(err)
+			}
+			return
+		}
+	}
+	die("Folder " + rid + " not found or folder not master")
+}
+
+func foldersGet(c *cli.Context) {
+	cfg := getConfig(c)
+	rid := c.Args()[0]
+	arg := strings.ToLower(c.Args()[1])
+	for _, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		if strings.HasPrefix(arg, "versioning-") {
+			arg = arg[11:]
+			value, ok := folder.Versioning.Params[arg]
+			if ok {
+				fmt.Println(value)
+				return
+			}
+			die("Versioning property " + c.Args()[1][11:] + " not found")
+		}
+		switch arg {
+		case "directory":
+			fmt.Println(folder.RawPath)
+		case "type":
+			fmt.Println(folder.Type)
+		case "permissions":
+			fmt.Println(folder.IgnorePerms)
+		case "rescan":
+			fmt.Println(folder.RescanIntervalS)
+		case "versioning":
+			if folder.Versioning.Type != "" {
+				fmt.Println(folder.Versioning.Type)
+			}
+		default:
+			die("Invalid property: " + c.Args()[1] + "\nAvailable properties: directory, type, permissions, versioning, versioning-<key>")
+		}
+		return
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersSet(c *cli.Context) {
+	rid := c.Args()[0]
+	arg := strings.ToLower(c.Args()[1])
+	val := strings.Join(c.Args()[2:], " ")
+	cfg := getConfig(c)
+	for i, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		if strings.HasPrefix(arg, "versioning-") {
+			cfg.Folders[i].Versioning.Params[arg[11:]] = val
+			setConfig(c, cfg)
+			return
+		}
+		switch arg {
+		case "directory":
+			cfg.Folders[i].RawPath = val
+		case "type":
+			var t config.FolderType
+			if err := t.UnmarshalText([]byte(val)); err != nil {
+				die("Invalid folder type: " + err.Error())
+			}
+			cfg.Folders[i].Type = t
+		case "permissions":
+			cfg.Folders[i].IgnorePerms = parseBool(val)
+		case "rescan":
+			cfg.Folders[i].RescanIntervalS = parseInt(val)
+		case "versioning":
+			cfg.Folders[i].Versioning.Type = val
+		default:
+			die("Invalid property: " + c.Args()[1] + "\nAvailable properties: directory, master, permissions, versioning, versioning-<key>")
+		}
+		setConfig(c, cfg)
+		return
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersUnset(c *cli.Context) {
+	rid := c.Args()[0]
+	arg := strings.ToLower(c.Args()[1])
+	cfg := getConfig(c)
+	for i, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		if strings.HasPrefix(arg, "versioning-") {
+			arg = arg[11:]
+			if _, ok := folder.Versioning.Params[arg]; ok {
+				delete(cfg.Folders[i].Versioning.Params, arg)
+				setConfig(c, cfg)
+				return
+			}
+			die("Versioning property " + c.Args()[1][11:] + " not found")
+		}
+		switch arg {
+		case "versioning":
+			cfg.Folders[i].Versioning.Type = ""
+			cfg.Folders[i].Versioning.Params = make(map[string]string)
+		default:
+			die("Invalid property: " + c.Args()[1] + "\nAvailable properties: versioning, versioning-<key>")
+		}
+		setConfig(c, cfg)
+		return
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersDevicesList(c *cli.Context) {
+	rid := c.Args()[0]
+	cfg := getConfig(c)
+	for _, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		for _, device := range folder.Devices {
+			fmt.Println(device.DeviceID)
+		}
+		return
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersDevicesAdd(c *cli.Context) {
+	rid := c.Args()[0]
+	nid := parseDeviceID(c.Args()[1])
+	cfg := getConfig(c)
+	for i, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		for _, device := range folder.Devices {
+			if device.DeviceID == nid {
+				die("Device " + c.Args()[1] + " is already part of this folder")
+			}
+		}
+		for _, device := range cfg.Devices {
+			if device.DeviceID == nid {
+				cfg.Folders[i].Devices = append(folder.Devices, config.FolderDeviceConfiguration{
+					DeviceID: device.DeviceID,
+				})
+				setConfig(c, cfg)
+				return
+			}
+		}
+		die("Device " + c.Args()[1] + " not found in device list")
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersDevicesRemove(c *cli.Context) {
+	rid := c.Args()[0]
+	nid := parseDeviceID(c.Args()[1])
+	cfg := getConfig(c)
+	for ri, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		for ni, device := range folder.Devices {
+			if device.DeviceID == nid {
+				last := len(folder.Devices) - 1
+				cfg.Folders[ri].Devices[ni] = folder.Devices[last]
+				cfg.Folders[ri].Devices = cfg.Folders[ri].Devices[:last]
+				setConfig(c, cfg)
+				return
+			}
+		}
+		die("Device " + c.Args()[1] + " not found")
+	}
+	die("Folder " + rid + " not found")
+}
+
+func foldersDevicesClear(c *cli.Context) {
+	rid := c.Args()[0]
+	cfg := getConfig(c)
+	for i, folder := range cfg.Folders {
+		if folder.ID != rid {
+			continue
+		}
+		cfg.Folders[i].Devices = []config.FolderDeviceConfiguration{}
+		setConfig(c, cfg)
+		return
+	}
+	die("Folder " + rid + " not found")
+}

cmd/stcli/cmd_general.go

@@ -0,0 +1,78 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+func init() {
+	cliCommands = append(cliCommands, []cli.Command{
+		{
+			Name:     "id",
+			Usage:    "Get ID of the Syncthing client",
+			Requires: &cli.Requires{},
+			Action:   generalID,
+		},
+		{
+			Name:     "status",
+			Usage:    "Configuration status, whether or not a restart is required for changes to take effect",
+			Requires: &cli.Requires{},
+			Action:   generalStatus,
+		},
+		{
+			Name:     "restart",
+			Usage:    "Restart syncthing",
+			Requires: &cli.Requires{},
+			Action:   wrappedHTTPPost("system/restart"),
+		},
+		{
+			Name:     "shutdown",
+			Usage:    "Shutdown syncthing",
+			Requires: &cli.Requires{},
+			Action:   wrappedHTTPPost("system/shutdown"),
+		},
+		{
+			Name:     "reset",
+			Usage:    "Reset syncthing deleting all folders and devices",
+			Requires: &cli.Requires{},
+			Action:   wrappedHTTPPost("system/reset"),
+		},
+		{
+			Name:     "upgrade",
+			Usage:    "Upgrade syncthing (if a newer version is available)",
+			Requires: &cli.Requires{},
+			Action:   wrappedHTTPPost("system/upgrade"),
+		},
+		{
+			Name:     "version",
+			Usage:    "Syncthing client version",
+			Requires: &cli.Requires{},
+			Action:   generalVersion,
+		},
+	}...)
+}
+
+func generalID(c *cli.Context) {
+	fmt.Println(getMyID(c))
+}
+
+func generalStatus(c *cli.Context) {
+	response := httpGet(c, "system/config/insync")
+	var status struct{ ConfigInSync bool }
+	json.Unmarshal(responseToBArray(response), &status)
+	if !status.ConfigInSync {
+		die("Config out of sync")
+	}
+	fmt.Println("Config in sync")
+}
+
+func generalVersion(c *cli.Context) {
+	response := httpGet(c, "system/version")
+	version := make(map[string]interface{})
+	json.Unmarshal(responseToBArray(response), &version)
+	prettyPrintJSON(version)
+}

cmd/stcli/cmd_gui.go

@@ -0,0 +1,127 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "gui",
+		HideHelp: true,
+		Usage:    "GUI command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "dump",
+				Usage:    "Show all GUI configuration settings",
+				Requires: &cli.Requires{},
+				Action:   guiDump,
+			},
+			{
+				Name:     "get",
+				Usage:    "Get a GUI configuration setting",
+				Requires: &cli.Requires{"setting"},
+				Action:   guiGet,
+			},
+			{
+				Name:     "set",
+				Usage:    "Set a GUI configuration setting",
+				Requires: &cli.Requires{"setting", "value"},
+				Action:   guiSet,
+			},
+			{
+				Name:     "unset",
+				Usage:    "Unset a GUI configuration setting",
+				Requires: &cli.Requires{"setting"},
+				Action:   guiUnset,
+			},
+		},
+	})
+}
+
+func guiDump(c *cli.Context) {
+	cfg := getConfig(c).GUI
+	writer := newTableWriter()
+	fmt.Fprintln(writer, "Enabled:\t", cfg.Enabled, "\t(enabled)")
+	fmt.Fprintln(writer, "Use HTTPS:\t", cfg.UseTLS(), "\t(tls)")
+	fmt.Fprintln(writer, "Listen Addresses:\t", cfg.Address(), "\t(address)")
+	if cfg.User != "" {
+		fmt.Fprintln(writer, "Authentication User:\t", cfg.User, "\t(username)")
+		fmt.Fprintln(writer, "Authentication Password:\t", cfg.Password, "\t(password)")
+	}
+	if cfg.APIKey != "" {
+		fmt.Fprintln(writer, "API Key:\t", cfg.APIKey, "\t(apikey)")
+	}
+	writer.Flush()
+}
+
+func guiGet(c *cli.Context) {
+	cfg := getConfig(c).GUI
+	arg := c.Args()[0]
+	switch strings.ToLower(arg) {
+	case "enabled":
+		fmt.Println(cfg.Enabled)
+	case "tls":
+		fmt.Println(cfg.UseTLS())
+	case "address":
+		fmt.Println(cfg.Address())
+	case "user":
+		if cfg.User != "" {
+			fmt.Println(cfg.User)
+		}
+	case "password":
+		if cfg.User != "" {
+			fmt.Println(cfg.Password)
+		}
+	case "apikey":
+		if cfg.APIKey != "" {
+			fmt.Println(cfg.APIKey)
+		}
+	default:
+		die("Invalid setting: " + arg + "\nAvailable settings: enabled, tls, address, user, password, apikey")
+	}
+}
+
+func guiSet(c *cli.Context) {
+	cfg := getConfig(c)
+	arg := c.Args()[0]
+	val := c.Args()[1]
+	switch strings.ToLower(arg) {
+	case "enabled":
+		cfg.GUI.Enabled = parseBool(val)
+	case "tls":
+		cfg.GUI.RawUseTLS = parseBool(val)
+	case "address":
+		validAddress(val)
+		cfg.GUI.RawAddress = val
+	case "user":
+		cfg.GUI.User = val
+	case "password":
+		cfg.GUI.Password = val
+	case "apikey":
+		cfg.GUI.APIKey = val
+	default:
+		die("Invalid setting: " + arg + "\nAvailable settings: enabled, tls, address, user, password, apikey")
+	}
+	setConfig(c, cfg)
+}
+
+func guiUnset(c *cli.Context) {
+	cfg := getConfig(c)
+	arg := c.Args()[0]
+	switch strings.ToLower(arg) {
+	case "user":
+		cfg.GUI.User = ""
+	case "password":
+		cfg.GUI.Password = ""
+	case "apikey":
+		cfg.GUI.APIKey = ""
+	default:
+		die("Invalid setting: " + arg + "\nAvailable settings: user, password, apikey")
+	}
+	setConfig(c, cfg)
+}

cmd/stcli/cmd_options.go

@@ -0,0 +1,173 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "options",
+		HideHelp: true,
+		Usage:    "Options command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "dump",
+				Usage:    "Show all Syncthing option settings",
+				Requires: &cli.Requires{},
+				Action:   optionsDump,
+			},
+			{
+				Name:     "get",
+				Usage:    "Get a Syncthing option setting",
+				Requires: &cli.Requires{"setting"},
+				Action:   optionsGet,
+			},
+			{
+				Name:     "set",
+				Usage:    "Set a Syncthing option setting",
+				Requires: &cli.Requires{"setting", "value..."},
+				Action:   optionsSet,
+			},
+		},
+	})
+}
+
+func optionsDump(c *cli.Context) {
+	cfg := getConfig(c).Options
+	writer := newTableWriter()
+
+	fmt.Fprintln(writer, "Sync protocol listen addresses:\t", strings.Join(cfg.ListenAddresses, " "), "\t(addresses)")
+	fmt.Fprintln(writer, "Global discovery enabled:\t", cfg.GlobalAnnEnabled, "\t(globalannenabled)")
+	fmt.Fprintln(writer, "Global discovery servers:\t", strings.Join(cfg.GlobalAnnServers, " "), "\t(globalannserver)")
+
+	fmt.Fprintln(writer, "Local discovery enabled:\t", cfg.LocalAnnEnabled, "\t(localannenabled)")
+	fmt.Fprintln(writer, "Local discovery port:\t", cfg.LocalAnnPort, "\t(localannport)")
+
+	fmt.Fprintln(writer, "Outgoing rate limit in KiB/s:\t", cfg.MaxSendKbps, "\t(maxsend)")
+	fmt.Fprintln(writer, "Incoming rate limit in KiB/s:\t", cfg.MaxRecvKbps, "\t(maxrecv)")
+	fmt.Fprintln(writer, "Reconnect interval in seconds:\t", cfg.ReconnectIntervalS, "\t(reconnect)")
+	fmt.Fprintln(writer, "Start browser:\t", cfg.StartBrowser, "\t(browser)")
+	fmt.Fprintln(writer, "Enable UPnP:\t", cfg.NATEnabled, "\t(nat)")
+	fmt.Fprintln(writer, "UPnP Lease in minutes:\t", cfg.NATLeaseM, "\t(natlease)")
+	fmt.Fprintln(writer, "UPnP Renewal period in minutes:\t", cfg.NATRenewalM, "\t(natrenew)")
+	fmt.Fprintln(writer, "Restart on Wake Up:\t", cfg.RestartOnWakeup, "\t(wake)")
+
+	reporting := "unrecognized value"
+	switch cfg.URAccepted {
+	case -1:
+		reporting = "false"
+	case 0:
+		reporting = "undecided/false"
+	case 1:
+		reporting = "true"
+	}
+	fmt.Fprintln(writer, "Anonymous usage reporting:\t", reporting, "\t(reporting)")
+
+	writer.Flush()
+}
+
+func optionsGet(c *cli.Context) {
+	cfg := getConfig(c).Options
+	arg := c.Args()[0]
+	switch strings.ToLower(arg) {
+	case "address":
+		fmt.Println(strings.Join(cfg.ListenAddresses, "\n"))
+	case "globalannenabled":
+		fmt.Println(cfg.GlobalAnnEnabled)
+	case "globalannservers":
+		fmt.Println(strings.Join(cfg.GlobalAnnServers, "\n"))
+	case "localannenabled":
+		fmt.Println(cfg.LocalAnnEnabled)
+	case "localannport":
+		fmt.Println(cfg.LocalAnnPort)
+	case "maxsend":
+		fmt.Println(cfg.MaxSendKbps)
+	case "maxrecv":
+		fmt.Println(cfg.MaxRecvKbps)
+	case "reconnect":
+		fmt.Println(cfg.ReconnectIntervalS)
+	case "browser":
+		fmt.Println(cfg.StartBrowser)
+	case "nat":
+		fmt.Println(cfg.NATEnabled)
+	case "natlease":
+		fmt.Println(cfg.NATLeaseM)
+	case "natrenew":
+		fmt.Println(cfg.NATRenewalM)
+	case "reporting":
+		switch cfg.URAccepted {
+		case -1:
+			fmt.Println("false")
+		case 0:
+			fmt.Println("undecided/false")
+		case 1:
+			fmt.Println("true")
+		default:
+			fmt.Println("unknown")
+		}
+	case "wake":
+		fmt.Println(cfg.RestartOnWakeup)
+	default:
+		die("Invalid setting: " + arg + "\nAvailable settings: address, globalannenabled, globalannserver, localannenabled, localannport, maxsend, maxrecv, reconnect, browser, upnp, upnplease, upnprenew, reporting, wake")
+	}
+}
+
+func optionsSet(c *cli.Context) {
+	config := getConfig(c)
+	arg := c.Args()[0]
+	val := c.Args()[1]
+	switch strings.ToLower(arg) {
+	case "address":
+		for _, item := range c.Args().Tail() {
+			validAddress(item)
+		}
+		config.Options.ListenAddresses = c.Args().Tail()
+	case "globalannenabled":
+		config.Options.GlobalAnnEnabled = parseBool(val)
+	case "globalannserver":
+		for _, item := range c.Args().Tail() {
+			validAddress(item)
+		}
+		config.Options.GlobalAnnServers = c.Args().Tail()
+	case "localannenabled":
+		config.Options.LocalAnnEnabled = parseBool(val)
+	case "localannport":
+		config.Options.LocalAnnPort = parsePort(val)
+	case "maxsend":
+		config.Options.MaxSendKbps = parseUint(val)
+	case "maxrecv":
+		config.Options.MaxRecvKbps = parseUint(val)
+	case "reconnect":
+		config.Options.ReconnectIntervalS = parseUint(val)
+	case "browser":
+		config.Options.StartBrowser = parseBool(val)
+	case "nat":
+		config.Options.NATEnabled = parseBool(val)
+	case "natlease":
+		config.Options.NATLeaseM = parseUint(val)
+	case "natrenew":
+		config.Options.NATRenewalM = parseUint(val)
+	case "reporting":
+		switch strings.ToLower(val) {
+		case "u", "undecided", "unset":
+			config.Options.URAccepted = 0
+		default:
+			boolvalue := parseBool(val)
+			if boolvalue {
+				config.Options.URAccepted = 1
+			} else {
+				config.Options.URAccepted = -1
+			}
+		}
+	case "wake":
+		config.Options.RestartOnWakeup = parseBool(val)
+	default:
+		die("Invalid setting: " + arg + "\nAvailable settings: address, globalannenabled, globalannserver, localannenabled, localannport, maxsend, maxrecv, reconnect, browser, upnp, upnplease, upnprenew, reporting, wake")
+	}
+	setConfig(c, config)
+}

cmd/stcli/cmd_report.go

@@ -0,0 +1,72 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+func init() {
+	cliCommands = append(cliCommands, cli.Command{
+		Name:     "report",
+		HideHelp: true,
+		Usage:    "Reporting command group",
+		Subcommands: []cli.Command{
+			{
+				Name:     "system",
+				Usage:    "Report system state",
+				Requires: &cli.Requires{},
+				Action:   reportSystem,
+			},
+			{
+				Name:     "connections",
+				Usage:    "Report about connections to other devices",
+				Requires: &cli.Requires{},
+				Action:   reportConnections,
+			},
+			{
+				Name:     "usage",
+				Usage:    "Usage report",
+				Requires: &cli.Requires{},
+				Action:   reportUsage,
+			},
+		},
+	})
+}
+
+func reportSystem(c *cli.Context) {
+	response := httpGet(c, "system/status")
+	data := make(map[string]interface{})
+	json.Unmarshal(responseToBArray(response), &data)
+	prettyPrintJSON(data)
+}
+
+func reportConnections(c *cli.Context) {
+	response := httpGet(c, "system/connections")
+	data := make(map[string]map[string]interface{})
+	json.Unmarshal(responseToBArray(response), &data)
+	var overall map[string]interface{}
+	for key, value := range data {
+		if key == "total" {
+			overall = value
+			continue
+		}
+		value["Device ID"] = key
+		prettyPrintJSON(value)
+		fmt.Println()
+	}
+	if overall != nil {
+		fmt.Println("=== Overall statistics ===")
+		prettyPrintJSON(overall)
+	}
+}
+
+func reportUsage(c *cli.Context) {
+	response := httpGet(c, "svc/report")
+	report := make(map[string]interface{})
+	json.Unmarshal(responseToBArray(response), &report)
+	prettyPrintJSON(report)
+}

cmd/stcli/labels.go

@@ -0,0 +1,31 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+var jsonAttributeLabels = map[string]string{
+	"folderMaxMiB":   "Largest folder size in MiB",
+	"folderMaxFiles": "Largest folder file count",
+	"longVersion":    "Long version",
+	"totMiB":         "Total size in MiB",
+	"totFiles":       "Total files",
+	"uniqueID":       "Unique ID",
+	"numFolders":     "Folder count",
+	"numDevices":     "Device count",
+	"memoryUsageMiB": "Memory usage in MiB",
+	"memorySize":     "Total memory in MiB",
+	"sha256Perf":     "SHA256 Benchmark",
+	"At":             "Last contacted",
+	"Completion":     "Percent complete",
+	"InBytesTotal":   "Total bytes received",
+	"OutBytesTotal":  "Total bytes sent",
+	"ClientVersion":  "Client version",
+	"alloc":          "Memory allocated in bytes",
+	"sys":            "Memory using in bytes",
+	"cpuPercent":     "CPU load in percent",
+	"extAnnounceOK":  "External announcments working",
+	"goroutines":     "Number of Go routines",
+	"myID":           "Client ID",
+	"tilde":          "Tilde expands to",
+	"arch":           "Architecture",
+	"os":             "OS",
+}

cmd/stcli/main.go

@@ -0,0 +1,63 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"sort"
+
+	"github.com/AudriusButkevicius/cli"
+)
+
+type ByAlphabet []cli.Command
+
+func (a ByAlphabet) Len() int           { return len(a) }
+func (a ByAlphabet) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a ByAlphabet) Less(i, j int) bool { return a[i].Name < a[j].Name }
+
+var cliCommands []cli.Command
+
+func main() {
+	app := cli.NewApp()
+	app.Name = "syncthing-cli"
+	app.Author = "Audrius Butkevičius"
+	app.Email = "audrius.butkevicius@gmail.com"
+	app.Usage = "Syncthing command line interface"
+	app.Version = "0.1"
+	app.HideHelp = true
+
+	app.Flags = []cli.Flag{
+		cli.StringFlag{
+			Name:   "endpoint, e",
+			Value:  "http://127.0.0.1:8384",
+			Usage:  "End point to connect to",
+			EnvVar: "STENDPOINT",
+		},
+		cli.StringFlag{
+			Name:   "apikey, k",
+			Value:  "",
+			Usage:  "API Key",
+			EnvVar: "STAPIKEY",
+		},
+		cli.StringFlag{
+			Name:   "username, u",
+			Value:  "",
+			Usage:  "Username",
+			EnvVar: "STUSERNAME",
+		},
+		cli.StringFlag{
+			Name:   "password, p",
+			Value:  "",
+			Usage:  "Password",
+			EnvVar: "STPASSWORD",
+		},
+		cli.BoolFlag{
+			Name:   "insecure, i",
+			Usage:  "Do not verify SSL certificate",
+			EnvVar: "STINSECURE",
+		},
+	}
+
+	sort.Sort(ByAlphabet(cliCommands))
+	app.Commands = cliCommands
+	app.RunAndExitOnError()
+}

cmd/stcli/utils.go

@@ -0,0 +1,165 @@
+// Copyright (C) 2014 Audrius Butkevičius
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+	"unicode"
+
+	"github.com/AudriusButkevicius/cli"
+	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+func responseToBArray(response *http.Response) []byte {
+	defer response.Body.Close()
+	bytes, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		die(err)
+	}
+	return bytes
+}
+
+func die(vals ...interface{}) {
+	if len(vals) > 1 || vals[0] != nil {
+		os.Stderr.WriteString(fmt.Sprintln(vals...))
+		os.Exit(1)
+	}
+}
+
+func wrappedHTTPPost(url string) func(c *cli.Context) {
+	return func(c *cli.Context) {
+		httpPost(c, url, "")
+	}
+}
+
+func prettyPrintJSON(json map[string]interface{}) {
+	writer := newTableWriter()
+	remap := make(map[string]interface{})
+	for k, v := range json {
+		key, ok := jsonAttributeLabels[k]
+		if !ok {
+			key = firstUpper(k)
+		}
+		remap[key] = v
+	}
+
+	jsonKeys := make([]string, 0, len(remap))
+	for key := range remap {
+		jsonKeys = append(jsonKeys, key)
+	}
+	sort.Strings(jsonKeys)
+	for _, k := range jsonKeys {
+		var value string
+		rvalue := remap[k]
+		switch rvalue.(type) {
+		case int, int16, int32, int64, uint, uint16, uint32, uint64, float32, float64:
+			value = fmt.Sprintf("%.0f", rvalue)
+		default:
+			value = fmt.Sprint(rvalue)
+		}
+		if value == "" {
+			continue
+		}
+		fmt.Fprintln(writer, k+":\t"+value)
+	}
+	writer.Flush()
+}
+
+func firstUpper(str string) string {
+	for i, v := range str {
+		return string(unicode.ToUpper(v)) + str[i+1:]
+	}
+	return ""
+}
+
+func newTableWriter() *tabwriter.Writer {
+	writer := new(tabwriter.Writer)
+	writer.Init(os.Stdout, 0, 8, 0, '\t', 0)
+	return writer
+}
+
+func getMyID(c *cli.Context) string {
+	response := httpGet(c, "system/status")
+	data := make(map[string]interface{})
+	json.Unmarshal(responseToBArray(response), &data)
+	return data["myID"].(string)
+}
+
+func getConfig(c *cli.Context) config.Configuration {
+	response := httpGet(c, "system/config")
+	config := config.Configuration{}
+	json.Unmarshal(responseToBArray(response), &config)
+	return config
+}
+
+func setConfig(c *cli.Context, cfg config.Configuration) {
+	body, err := json.Marshal(cfg)
+	die(err)
+	response := httpPost(c, "system/config", string(body))
+	if response.StatusCode != 200 {
+		die("Unexpected status code", response.StatusCode)
+	}
+}
+
+func parseBool(input string) bool {
+	val, err := strconv.ParseBool(input)
+	if err != nil {
+		die(input + " is not a valid value for a boolean")
+	}
+	return val
+}
+
+func parseInt(input string) int {
+	val, err := strconv.ParseInt(input, 0, 64)
+	if err != nil {
+		die(input + " is not a valid value for an integer")
+	}
+	return int(val)
+}
+
+func parseUint(input string) int {
+	val, err := strconv.ParseUint(input, 0, 64)
+	if err != nil {
+		die(input + " is not a valid value for an unsigned integer")
+	}
+	return int(val)
+}
+
+func parsePort(input string) int {
+	port := parseUint(input)
+	if port < 1 || port > 65535 {
+		die(input + " is not a valid port\nExpected value between 1 and 65535")
+	}
+	return port
+}
+
+func validAddress(input string) {
+	tokens := strings.Split(input, ":")
+	if len(tokens) != 2 {
+		die(input + " is not a valid value for an address\nExpected format <ip or hostname>:<port>")
+	}
+	matched, err := regexp.MatchString("^[a-zA-Z0-9]+([-a-zA-Z0-9.]+[-a-zA-Z0-9]+)?$", tokens[0])
+	die(err)
+	if !matched {
+		die(input + " is not a valid value for an address\nExpected format <ip or hostname>:<port>")
+	}
+	parsePort(tokens[1])
+}
+
+func parseDeviceID(input string) protocol.DeviceID {
+	device, err := protocol.DeviceIDFromString(input)
+	if err != nil {
+		die(input + " is not a valid device id")
+	}
+	return device
+}

cmd/stgenfiles/main.go

@@ -66,7 +66,7 @@ func generateFiles(dir string, files, maxexp int, srcname string) error {
 }
 
 func generateOneFile(fd io.ReadSeeker, p1 string, s int64) error {
-	src := io.LimitReader(&inifiteReader{fd}, int64(s))
+	src := io.LimitReader(&inifiteReader{fd}, s)
 	dst, err := os.Create(p1)
 	if err != nil {
 		return err
@@ -85,12 +85,7 @@ func generateOneFile(fd io.ReadSeeker, p1 string, s int64) error {
 	_ = os.Chmod(p1, os.FileMode(rand.Intn(0777)|0400))
 
 	t := time.Now().Add(-time.Duration(rand.Intn(30*86400)) * time.Second)
-	err = os.Chtimes(p1, t, t)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return os.Chtimes(p1, t, t)
 }
 
 func randomName() string {

cmd/strelaypoolsrv/main.go

@@ -249,13 +249,13 @@ func handleRequest(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Access-Control-Allow-Origin", "*")
 	switch r.Method {
 	case "GET":
-		if limit(r.RemoteAddr, getLRUCache, getMut, getLimit, int64(getLimitBurst)) {
+		if limit(r.RemoteAddr, getLRUCache, getMut, getLimit, getLimitBurst) {
 			w.WriteHeader(429)
 			return
 		}
 		handleGetRequest(w, r)
 	case "POST":
-		if limit(r.RemoteAddr, postLRUCache, postMut, postLimit, int64(postLimitBurst)) {
+		if limit(r.RemoteAddr, postLRUCache, postMut, postLimit, postLimitBurst) {
 			w.WriteHeader(429)
 			return
 		}

cmd/strelaysrv/main.go

@@ -54,7 +54,6 @@ func init() {
 var (
 	listen string
 	debug  bool
-	proto  string
 
 	sessionAddress []byte
 	sessionPort    uint16

cmd/strelaysrv/session.go

@@ -216,7 +216,7 @@ done:
 func (s *session) GetClientInvitationMessage() protocol.SessionInvitation {
 	return protocol.SessionInvitation{
 		From:         s.serverid[:],
-		Key:          []byte(s.clientkey),
+		Key:          s.clientkey,
 		Address:      sessionAddress,
 		Port:         sessionPort,
 		ServerSocket: false,
@@ -226,7 +226,7 @@ func (s *session) GetClientInvitationMessage() protocol.SessionInvitation {
 func (s *session) GetServerInvitationMessage() protocol.SessionInvitation {
 	return protocol.SessionInvitation{
 		From:         s.clientid[:],
-		Key:          []byte(s.serverkey),
+		Key:          s.serverkey,
 		Address:      sessionAddress,
 		Port:         sessionPort,
 		ServerSocket: true,

cmd/strelaysrv/status.go

@@ -42,7 +42,7 @@ func getStatus(w http.ResponseWriter, r *http.Request) {
 	status["goMaxProcs"] = runtime.GOMAXPROCS(-1)
 	status["goNumRoutine"] = runtime.NumGoroutine()
 	status["kbps10s1m5m15m30m60m"] = []int64{
-		rc.rate(10/10) * 8 / 1000,
+		rc.rate(1) * 8 / 1000, // each interval is 10s
 		rc.rate(60/10) * 8 / 1000,
 		rc.rate(5*60/10) * 8 / 1000,
 		rc.rate(15*60/10) * 8 / 1000,

cmd/syncthing/gui.go

@@ -82,8 +82,6 @@ type modelIntf interface {
 	Availability(folder, file string, version protocol.Vector, block protocol.BlockInfo) []model.Availability
 	GetIgnores(folder string) ([]string, []string, error)
 	SetIgnores(folder string, content []string) error
-	PauseDevice(device protocol.DeviceID)
-	ResumeDevice(device protocol.DeviceID)
 	DelayScan(folder string, next time.Duration)
 	ScanFolder(folder string) error
 	ScanFolders() map[string]error
@@ -105,6 +103,7 @@ type configIntf interface {
 	Subscribe(c config.Committer)
 	Folders() map[string]config.FolderConfiguration
 	Devices() map[protocol.DeviceID]config.DeviceConfiguration
+	SetDevice(config.DeviceConfiguration) error
 	Save() error
 	ListenAddresses() []string
 	RequiresRestart() bool
@@ -258,21 +257,21 @@ func (s *apiService) Serve() {
 
 	// The POST handlers
 	postRestMux := http.NewServeMux()
-	postRestMux.HandleFunc("/rest/db/prio", s.postDBPrio)                      // folder file [perpage] [page]
-	postRestMux.HandleFunc("/rest/db/ignores", s.postDBIgnores)                // folder
-	postRestMux.HandleFunc("/rest/db/override", s.postDBOverride)              // folder
-	postRestMux.HandleFunc("/rest/db/scan", s.postDBScan)                      // folder [sub...] [delay]
-	postRestMux.HandleFunc("/rest/system/config", s.postSystemConfig)          // <body>
-	postRestMux.HandleFunc("/rest/system/error", s.postSystemError)            // <body>
-	postRestMux.HandleFunc("/rest/system/error/clear", s.postSystemErrorClear) // -
-	postRestMux.HandleFunc("/rest/system/ping", s.restPing)                    // -
-	postRestMux.HandleFunc("/rest/system/reset", s.postSystemReset)            // [folder]
-	postRestMux.HandleFunc("/rest/system/restart", s.postSystemRestart)        // -
-	postRestMux.HandleFunc("/rest/system/shutdown", s.postSystemShutdown)      // -
-	postRestMux.HandleFunc("/rest/system/upgrade", s.postSystemUpgrade)        // -
-	postRestMux.HandleFunc("/rest/system/pause", s.postSystemPause)            // device
-	postRestMux.HandleFunc("/rest/system/resume", s.postSystemResume)          // device
-	postRestMux.HandleFunc("/rest/system/debug", s.postSystemDebug)            // [enable] [disable]
+	postRestMux.HandleFunc("/rest/db/prio", s.postDBPrio)                          // folder file [perpage] [page]
+	postRestMux.HandleFunc("/rest/db/ignores", s.postDBIgnores)                    // folder
+	postRestMux.HandleFunc("/rest/db/override", s.postDBOverride)                  // folder
+	postRestMux.HandleFunc("/rest/db/scan", s.postDBScan)                          // folder [sub...] [delay]
+	postRestMux.HandleFunc("/rest/system/config", s.postSystemConfig)              // <body>
+	postRestMux.HandleFunc("/rest/system/error", s.postSystemError)                // <body>
+	postRestMux.HandleFunc("/rest/system/error/clear", s.postSystemErrorClear)     // -
+	postRestMux.HandleFunc("/rest/system/ping", s.restPing)                        // -
+	postRestMux.HandleFunc("/rest/system/reset", s.postSystemReset)                // [folder]
+	postRestMux.HandleFunc("/rest/system/restart", s.postSystemRestart)            // -
+	postRestMux.HandleFunc("/rest/system/shutdown", s.postSystemShutdown)          // -
+	postRestMux.HandleFunc("/rest/system/upgrade", s.postSystemUpgrade)            // -
+	postRestMux.HandleFunc("/rest/system/pause", s.makeDevicePauseHandler(true))   // device
+	postRestMux.HandleFunc("/rest/system/resume", s.makeDevicePauseHandler(false)) // device
+	postRestMux.HandleFunc("/rest/system/debug", s.postSystemDebug)                // [enable] [disable]
 
 	// Debug endpoints, not for general use
 	debugMux := http.NewServeMux()
@@ -381,10 +380,8 @@ func (s *apiService) String() string {
 }
 
 func (s *apiService) VerifyConfiguration(from, to config.Configuration) error {
-	if _, err := net.ResolveTCPAddr("tcp", to.GUI.Address()); err != nil {
-		return err
-	}
-	return nil
+	_, err := net.ResolveTCPAddr("tcp", to.GUI.Address())
+	return err
 }
 
 func (s *apiService) CommitConfiguration(from, to config.Configuration) bool {
@@ -1105,30 +1102,27 @@ func (s *apiService) postSystemUpgrade(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *apiService) postSystemPause(w http.ResponseWriter, r *http.Request) {
-	var qs = r.URL.Query()
-	var deviceStr = qs.Get("device")
+func (s *apiService) makeDevicePauseHandler(paused bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var qs = r.URL.Query()
+		var deviceStr = qs.Get("device")
 
-	device, err := protocol.DeviceIDFromString(deviceStr)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
+		device, err := protocol.DeviceIDFromString(deviceStr)
+		if err != nil {
+			http.Error(w, err.Error(), 500)
+			return
+		}
+
+		cfg, ok := s.cfg.Devices()[device]
+		if !ok {
+			http.Error(w, "not found", http.StatusNotFound)
+		}
+
+		cfg.Paused = paused
+		if err := s.cfg.SetDevice(cfg); err != nil {
+			http.Error(w, err.Error(), 500)
+		}
 	}
-
-	s.model.PauseDevice(device)
-}
-
-func (s *apiService) postSystemResume(w http.ResponseWriter, r *http.Request) {
-	var qs = r.URL.Query()
-	var deviceStr = qs.Get("device")
-
-	device, err := protocol.DeviceIDFromString(deviceStr)
-	if err != nil {
-		http.Error(w, err.Error(), 500)
-		return
-	}
-
-	s.model.ResumeDevice(device)
 }
 
 func (s *apiService) postDBScan(w http.ResponseWriter, r *http.Request) {

cmd/syncthing/main.go

@@ -199,7 +199,8 @@ var (
 
 type RuntimeOptions struct {
 	confDir        string
-	reset          bool
+	resetDatabase  bool
+	resetDeltaIdxs bool
 	showVersion    bool
 	showPaths      bool
 	doUpgrade      bool
@@ -212,6 +213,7 @@ type RuntimeOptions struct {
 	auditEnabled   bool
 	verbose        bool
 	paused         bool
+	unpaused       bool
 	guiAddress     string
 	guiAPIKey      string
 	generateDir    string
@@ -259,7 +261,8 @@ func parseCommandLineOptions() RuntimeOptions {
 	flag.BoolVar(&options.noBrowser, "no-browser", false, "Do not start browser")
 	flag.BoolVar(&options.browserOnly, "browser-only", false, "Open GUI in browser")
 	flag.BoolVar(&options.noRestart, "no-restart", options.noRestart, "Do not restart; just exit")
-	flag.BoolVar(&options.reset, "reset", false, "Reset the database")
+	flag.BoolVar(&options.resetDatabase, "reset-database", false, "Reset the database, forcing a full rescan and resync")
+	flag.BoolVar(&options.resetDeltaIdxs, "reset-deltas", false, "Reset delta index IDs, forcing a full index exchange")
 	flag.BoolVar(&options.doUpgrade, "upgrade", false, "Perform upgrade")
 	flag.BoolVar(&options.doUpgradeCheck, "upgrade-check", false, "Check for available upgrade")
 	flag.BoolVar(&options.showVersion, "version", false, "Show version")
@@ -267,7 +270,8 @@ func parseCommandLineOptions() RuntimeOptions {
 	flag.StringVar(&options.upgradeTo, "upgrade-to", options.upgradeTo, "Force upgrade directly from specified URL")
 	flag.BoolVar(&options.auditEnabled, "audit", false, "Write events to audit file")
 	flag.BoolVar(&options.verbose, "verbose", false, "Print verbose log output")
-	flag.BoolVar(&options.paused, "paused", false, "Start with all devices paused")
+	flag.BoolVar(&options.paused, "paused", false, "Start with all devices and folders paused")
+	flag.BoolVar(&options.unpaused, "unpaused", false, "Start with all devices and folders unpaused")
 	flag.StringVar(&options.logFile, "logfile", options.logFile, "Log file name (use \"-\" for stdout)")
 	if runtime.GOOS == "windows" {
 		// Allow user to hide the console window
@@ -367,7 +371,7 @@ func main() {
 		return
 	}
 
-	if options.reset {
+	if options.resetDatabase {
 		resetDB()
 		return
 	}
@@ -554,8 +558,8 @@ func syncthingMain(runtimeOptions RuntimeOptions) {
 	// Event subscription for the API; must start early to catch the early
 	// events. The LocalChangeDetected event might overwhelm the event
 	// receiver in some situations so we will not subscribe to it here.
-	apiSub := events.NewBufferedSubscription(events.Default.Subscribe(events.AllEvents&^events.LocalChangeDetected), 1000)
-	diskSub := events.NewBufferedSubscription(events.Default.Subscribe(events.LocalChangeDetected), 1000)
+	apiSub := events.NewBufferedSubscription(events.Default.Subscribe(events.AllEvents&^events.LocalChangeDetected&^events.RemoteChangeDetected), 1000)
+	diskSub := events.NewBufferedSubscription(events.Default.Subscribe(events.LocalChangeDetected|events.RemoteChangeDetected), 1000)
 
 	if len(os.Getenv("GOMAXPROCS")) == 0 {
 		runtime.GOMAXPROCS(runtime.NumCPU())
@@ -620,6 +624,10 @@ func syncthingMain(runtimeOptions RuntimeOptions) {
 		InsecureSkipVerify:     true,
 		MinVersion:             tls.VersionTLS12,
 		CipherSuites: []uint16{
+			0xCCA8, // TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305, Go 1.8
+			0xCCA9, // TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, Go 1.8
+			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
 			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
 			tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
@@ -663,6 +671,11 @@ func syncthingMain(runtimeOptions RuntimeOptions) {
 		l.Fatalln("Cannot open database:", err, "- Is another copy of Syncthing already running?")
 	}
 
+	if runtimeOptions.resetDeltaIdxs {
+		l.Infoln("Reinitializing delta index IDs")
+		ldb.DropDeltaIndexIDs()
+	}
+
 	protectedFiles := []string{
 		locations[locDatabase],
 		locations[locConfigFile],
@@ -697,14 +710,17 @@ func syncthingMain(runtimeOptions RuntimeOptions) {
 		m.StartDeadlockDetector(20 * time.Minute)
 	}
 
-	if runtimeOptions.paused {
-		for device := range cfg.Devices() {
-			m.PauseDevice(device)
-		}
+	if runtimeOptions.unpaused {
+		setPauseState(cfg, false)
+	} else if runtimeOptions.paused {
+		setPauseState(cfg, true)
 	}
 
 	// Add and start folders
 	for _, folderCfg := range cfg.Folders() {
+		if folderCfg.Paused {
+			continue
+		}
 		m.AddFolder(folderCfg)
 		m.StartFolder(folderCfg.ID)
 	}
@@ -1066,7 +1082,7 @@ func getFreePort(host string, ports ...int) (int, error) {
 }
 
 func standbyMonitor() {
-	restartDelay := time.Duration(60 * time.Second)
+	restartDelay := 60 * time.Second
 	now := time.Now()
 	for {
 		time.Sleep(10 * time.Second)
@@ -1199,3 +1215,16 @@ func showPaths() {
 	fmt.Printf("GUI override directory:\n\t%s\n\n", locations[locGUIAssets])
 	fmt.Printf("Default sync folder directory:\n\t%s\n\n", locations[locDefFolder])
 }
+
+func setPauseState(cfg *config.Wrapper, paused bool) {
+	raw := cfg.RawCopy()
+	for i := range raw.Devices {
+		raw.Devices[i].Paused = paused
+	}
+	for i := range raw.Folders {
+		raw.Folders[i].Paused = paused
+	}
+	if err := cfg.Replace(raw); err != nil {
+		l.Fatalln("Cannot adjust paused state:", err)
+	}
+}

cmd/syncthing/mocked_config_test.go

@@ -45,6 +45,10 @@ func (c *mockedConfig) Devices() map[protocol.DeviceID]config.DeviceConfiguratio
 	return nil
 }
 
+func (c *mockedConfig) SetDevice(config.DeviceConfiguration) error {
+	return nil
+}
+
 func (c *mockedConfig) Save() error {
 	return nil
 }

cmd/syncthing/monitor.go

@@ -202,8 +202,24 @@ func copyStderr(stderr io.Reader, dst io.Writer) {
 				}
 
 				l.Warnf("Panic detected, writing to \"%s\"", panicFd.Name())
-				l.Warnln("Please check for existing issues with similar panic message at https://github.com/syncthing/syncthing/issues/")
-				l.Warnln("If no issue with similar panic message exists, please create a new issue with the panic log attached")
+				if strings.Contains(line, "leveldb") && strings.Contains(line, "corrupt") {
+					l.Warnln(`
+*********************************************************************************
+* Crash due to corrupt database.                                                *
+*                                                                               *
+* This crash usually occurs due to one of the following reasons:                *
+*  - Syncthing being stopped abruptly (killed/loss of power)                    *
+*  - Bad hardware (memory/disk issues)                                          *
+*  - Software that affects disk writes (SSD caching software and simillar)      *
+*                                                                               *
+* Please see the following URL for instructions on how to recover:              *
+*   https://docs.syncthing.net/users/faq.html#my-syncthing-database-is-corrupt  *
+*********************************************************************************
+`)
+				} else {
+					l.Warnln("Please check for existing issues with similar panic message at https://github.com/syncthing/syncthing/issues/")
+					l.Warnln("If no issue with similar panic message exists, please create a new issue with the panic log attached")
+				}
 
 				stdoutMut.Lock()
 				for _, line := range stdoutFirstLines {

cmd/syncthing/usage_report.go

@@ -134,7 +134,7 @@ func reportData(cfg configIntf, m modelIntf) map[string]interface{} {
 	for _, cfg := range cfg.Folders() {
 		rescanIntvs = append(rescanIntvs, cfg.RescanIntervalS)
 
-		if cfg.Type == config.FolderTypeReadOnly {
+		if cfg.Type == config.FolderTypeSendOnly {
 			folderUses["readonly"]++
 		}
 		if cfg.IgnorePerms {

cmd/syncthing/verboseservice.go

@@ -94,9 +94,12 @@ func (s *verboseService) formatEvent(ev events.Event) string {
 
 	case events.LocalChangeDetected:
 		data := ev.Data.(map[string]string)
-		// Local change detected in folder "foo": modified file /Users/jb/whatever
 		return fmt.Sprintf("Local change detected in folder %q: %s %s %s", data["folder"], data["action"], data["type"], data["path"])
 
+	case events.RemoteChangeDetected:
+		data := ev.Data.(map[string]string)
+		return fmt.Sprintf("Remote change detected in folder %q: %s %s %s", data["folder"], data["action"], data["type"], data["path"])
+
 	case events.RemoteIndexUpdated:
 		data := ev.Data.(map[string]interface{})
 		return fmt.Sprintf("Device %v sent an index update for %q with %d items", data["device"], data["folder"], data["items"])
@@ -163,6 +166,18 @@ func (s *verboseService) formatEvent(ev events.Event) string {
 		device := data["device"]
 		return fmt.Sprintf("Device %v was resumed", device)
 
+	case events.FolderPaused:
+		data := ev.Data.(map[string]string)
+		id := data["id"]
+		label := data["label"]
+		return fmt.Sprintf("Folder %v (%v) was paused", id, label)
+
+	case events.FolderResumed:
+		data := ev.Data.(map[string]string)
+		id := data["id"]
+		label := data["label"]
+		return fmt.Sprintf("Folder %v (%v) was resumed", id, label)
+
 	case events.ListenAddressesChanged:
 		data := ev.Data.(map[string]interface{})
 		address := data["address"]

gui/default/assets/lang/lang-bg.json

@@ -52,6 +52,8 @@
     "Downloaded": "Изтеглен",
     "Downloading": "Изтегляне",
     "Edit": "Промени",
+    "Edit Device": "Промяна на устройството",
+    "Edit Folder": "Промяна на папката",
     "Editing": "Променяне",
     "Enable NAT traversal": "Разреши NAT traversal",
     "Enable Relaying": "Разреши препращане",
@@ -95,6 +97,7 @@
     "Last Scan": "Последно сканиран",
     "Last seen": "Последно видяно",
     "Later": "По-късно",
+    "Latest Change": "Последна промяна",
     "Listeners": "Синхронизиращи устройства",
     "Local Discovery": "Локално откриване",
     "Local State": "Локално състояние",
@@ -153,6 +156,8 @@
     "Scanning": "Сканиране",
     "Select the devices to share this folder with.": "Изберете устройствата, с които да споделите папката.",
     "Select the folders to share with this device.": "Изберете папките за споделяне с това устройство.",
+    "Send & Receive": "Изпращане & получаване",
+    "Send Only": "Само изпращане",
     "Settings": "Настройки",
     "Share": "Сподели",
     "Share Folder": "Сподели папка",

gui/default/assets/lang/lang-ca.json

@@ -52,6 +52,8 @@
     "Downloaded": "Descarregat",
     "Downloading": "Descarregant",
     "Edit": "Editar",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Modificant",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Enable Relaying",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "Vist per última vegada",
     "Later": "Després",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "Descobriment Local",
     "Local State": "Estat local",
@@ -153,6 +156,8 @@
     "Scanning": "Escanejant",
     "Select the devices to share this folder with.": "Selecciona els dispositius en els quals compartir aquesta carpeta.",
     "Select the folders to share with this device.": "Selecciona la carpeta per a compartir en aquest dispositiu.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Preferències",
     "Share": "Compartir",
     "Share Folder": "Compartir carpeta",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Descarregat",
     "Downloading": "Descarregant",
     "Edit": "Editar",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Editant",
     "Enable NAT traversal": "Permetre NAT transversal",
     "Enable Relaying": "Permetre Transmissions",
@@ -95,6 +97,7 @@
     "Last Scan": "Últim escaneig",
     "Last seen": "Vist per última vegada",
     "Later": "Més tard",
+    "Latest Change": "Latest Change",
     "Listeners": "Escoltants",
     "Local Discovery": "Descobriment local",
     "Local State": "Estat local",
@@ -153,6 +156,8 @@
     "Scanning": "Rastrejant",
     "Select the devices to share this folder with.": "Selecciona els dispositius amb els que compartir aquesta carpeta.",
     "Select the folders to share with this device.": "Selecciona les carpetes per a compartir amb aquest dispositiu.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Ajustos",
     "Share": "Compartir",
     "Share Folder": "Compartir carpeta",

gui/default/assets/lang/lang-cs.json

@@ -52,6 +52,8 @@
     "Downloaded": "Staženo",
     "Downloading": "Stahuji",
     "Edit": "Upravit",
+    "Edit Device": "Upravit zařízení",
+    "Edit Folder": "Upravit adresář",
     "Editing": "Upravuje se",
     "Enable NAT traversal": "Povolit NAT přenos",
     "Enable Relaying": "Povolit přenašeče",
@@ -95,6 +97,7 @@
     "Last Scan": "Poslední sken",
     "Last seen": "Naposledy spatřen",
     "Later": "Později",
+    "Latest Change": "Poslední změna",
     "Listeners": "Naslouchající",
     "Local Discovery": "Místní oznamování",
     "Local State": "Místní status",
@@ -153,6 +156,8 @@
     "Scanning": "Skenování",
     "Select the devices to share this folder with.": "Vybrat přístroje, se kterými sdílet tento adresář.",
     "Select the folders to share with this device.": "Vybrat adresáře sdílené s tímto přístrojem.",
+    "Send & Receive": "Odeslat a přijmout",
+    "Send Only": "Pouze odeslat",
     "Settings": "Nastavení",
     "Share": "Sdílet",
     "Share Folder": "Sdílet adresář",

gui/default/assets/lang/lang-da.json

@@ -52,6 +52,8 @@
     "Downloaded": "Downloadet",
     "Downloading": "Downloader",
     "Edit": "Rediger",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Redigerer",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Enable Relaying",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "Sidst set",
     "Later": "Senere",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "Lokal opslag",
     "Local State": "Lokal tilstand",
@@ -153,6 +156,8 @@
     "Scanning": "Opdaterer",
     "Select the devices to share this folder with.": "Vælg hvilke enheder du vil dele denne mappe med",
     "Select the folders to share with this device.": "Vælg hvilke mapper du vil dele med denne enhed.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Indstillinger",
     "Share": "Del",
     "Share Folder": "Delt mappe",

gui/default/assets/lang/lang-de.json

@@ -1,15 +1,15 @@
 {
-    "A device with that ID is already added.": "Ein Gerät mit dieser ID existiert bereits.",
+    "A device with that ID is already added.": "Ein Gerät mit dieser Kennung ist bereits hinzugefügt.",
     "A negative number of days doesn't make sense.": "Eine negative Anzahl von Tagen ergibt keinen Sinn.",
     "A new major version may not be compatible with previous versions.": "Die neue Hauptversion ist evtl. nicht mit vorherigen Versionen kompatibel.",
     "API Key": "API-Schlüssel",
-    "About": "Über Syncthing",
+    "About": "Über",
     "Actions": "Aktionen",
     "Add": "Hinzufügen",
     "Add Device": "Gerät hinzufügen",
-    "Add Folder": "Verzeichnis hinzufügen",
-    "Add Remote Device": "Remote-Gerät hinzufügen",
-    "Add new folder?": "Neues Verzeichnis hinzufügen?",
+    "Add Folder": "Ordner hinzufügen",
+    "Add Remote Device": "Fern-Gerät hinzufügen",
+    "Add new folder?": "Neuen Ordner hinzufügen?",
     "Address": "Adresse",
     "Addresses": "Adressen",
     "Advanced": "Erweitert",
@@ -18,7 +18,7 @@
     "All Data": "Alle Daten",
     "Allow Anonymous Usage Reporting?": "Übertragung von anonymen Nutzungsberichten erlauben?",
     "Alphabetic": "Alphabetisch",
-    "An external command handles the versioning. It has to remove the file from the synced folder.": "Ein externer Programmaufruf handhabt die Versionierung. Es muss die Datei aus dem zu synchronisierendem Verzeichnis entfernen.",
+    "An external command handles the versioning. It has to remove the file from the synced folder.": "Ein externer Programmaufruf handhabt die Versionierung. Es muss die Datei aus dem zu synchronisierendem Ordner entfernen.",
     "Anonymous Usage Reporting": "Anonymer Nutzungsbericht",
     "Any devices configured on an introducer device will be added to this device as well.": "Alle Geräte, die beim Verteiler eingetragen sind, werden auch bei diesem Gerät eingetragen",
     "Automatic upgrades": "Automatische Updates aktivieren",
@@ -40,8 +40,8 @@
     "Danger!": "Achtung!",
     "Deleted": "Gelöscht",
     "Device \"{%name%}\" ({%device%} at {%address%}) wants to connect. Add new device?": "Gerät \"{{name}}\" ({{device}} {{address}}) möchte sich verbinden. Gerät hinzufügen?",
-    "Device ID": "Geräte ID",
-    "Device Identification": "Geräte Identifikation",
+    "Device ID": "Gerätekennung",
+    "Device Identification": "Geräteidentifikation",
     "Device Name": "Gerätename",
     "Devices": "Geräte",
     "Disconnected": "Getrennt",
@@ -52,6 +52,8 @@
     "Downloaded": "Heruntergeladen",
     "Downloading": "Lädt herunter",
     "Edit": "Bearbeiten",
+    "Edit Device": "Gerät bearbeiten",
+    "Edit Folder": "Ordner bearbeiten",
     "Editing": "Bearbeitet",
     "Enable NAT traversal": "NAT-Durchdringung aktivieren",
     "Enable Relaying": "Weiterleitung aktivieren",
@@ -63,15 +65,15 @@
     "File Pull Order": "Dateiübertragungsreihenfolge",
     "File Versioning": "Dateiversionierung",
     "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Dateizugriffsrechte beim Suchen nach Veränderungen ignorieren. Bei FAT-Dateisystemen zu verwenden.",
-    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Wenn Syncthing Dateien ersetzt oder löscht, werden sie in das .stversions Verzeichnis verschoben.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Dateien werden, bevor Syncthing sie löscht oder ersetzt, datiert in das Verzeichnis .stversions verschoben.",
+    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Wenn Syncthing Dateien ersetzt oder löscht, werden sie in den Ordner .stversions verschoben.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Dateien werden, bevor Syncthing sie löscht oder ersetzt, datiert in den Ordner .stversions verschoben.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Dateien sind auf diesem Gerät schreibgeschützt. Auf diesem Gerät durchgeführte Veränderungen werden aber auf den Rest des Verbunds übertragen.",
-    "Folder": "Verzeichnis",
-    "Folder ID": "Verzeichnis ID",
-    "Folder Label": "Verzeichnisbezeichnung",
-    "Folder Path": "Verzeichnispfad",
-    "Folder Type": "Verzeichnistyp",
-    "Folders": "Verzeichnisse",
+    "Folder": "Ordner",
+    "Folder ID": "Ordnerkennung",
+    "Folder Label": "Ordnerbezeichnung",
+    "Folder Path": "Ordnerpfad",
+    "Folder Type": "Ordnertyp",
+    "Folders": "Ordner",
     "GUI": "GUI",
     "GUI Authentication Password": "Passwort für Zugang zur Benutzeroberfläche",
     "GUI Authentication User": "Nutzername für Zugang zur Benutzeroberfläche",
@@ -86,7 +88,7 @@
     "Ignore Patterns": "Ignoriermuster",
     "Ignore Permissions": "Berechtigungen ignorieren",
     "Incoming Rate Limit (KiB/s)": "Limit Datenrate (eingehend) (KB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Eine falsche Konfiguration kann den Verzeichnisinhalt beschädigen und Syncthing in einen unausführbaren Zustand versetzen.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Eine falsche Konfiguration kann den Ordnerinhalt beschädigen und Syncthing in einen unausführbaren Zustand versetzen.",
     "Introducer": "Verteilergerät",
     "Inversion of the given condition (i.e. do not exclude)": "Umkehrung der angegebenen Bedingung (z.B. schließe nicht aus)",
     "Keep Versions": "Versionen erhalten",
@@ -95,6 +97,7 @@
     "Last Scan": "Letzter Scan",
     "Last seen": "Zuletzt online",
     "Later": "Später",
+    "Latest Change": "Letzte Änderung",
     "Listeners": "Zuhörer",
     "Local Discovery": "Lokale Gerätesuche",
     "Local State": "Lokaler Status",
@@ -105,10 +108,10 @@
     "Metadata Only": "Nur Metadaten",
     "Minimum Free Disk Space": "Minimal freier Festplattenspeicher",
     "Move to top of queue": "An den Anfang der Warteschlange setzen",
-    "Multi level wildcard (matches multiple directory levels)": "Verschachteltes Maskenzeichen (wird für verschachtelte Verzeichnisse verwendet)",
+    "Multi level wildcard (matches multiple directory levels)": "Verschachteltes Maskenzeichen (wird für verschachtelte Ordner verwendet)",
     "Never": "Nie",
     "New Device": "Neues Gerät",
-    "New Folder": "Neues Verzeichnis",
+    "New Folder": "Neuer Ordner",
     "Newest First": "Neueste zuerst",
     "No": "Nein",
     "No File Versioning": "Keine Dateiversionierung",
@@ -117,14 +120,14 @@
     "OK": "OK",
     "Off": "Aus",
     "Oldest First": "Älteste zuerst",
-    "Optional descriptive label for the folder. Can be different on each device.": "Optionale beschreibende Bezeichnung des Verzeichnisses. Kann auf jedem Gerät unterschiedlich sein.",
+    "Optional descriptive label for the folder. Can be different on each device.": "Optionale beschreibende Bezeichnung des Ordners. Kann auf jedem Gerät unterschiedlich sein.",
     "Options": "Optionen",
     "Out of Sync": "Nicht synchronisiert",
     "Out of Sync Items": "Nicht synchronisierte Objekte",
     "Outgoing Rate Limit (KiB/s)": "Limit Datenrate (ausgehend) (KB/s)",
     "Override Changes": "Änderungen überschreiben",
-    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Pfad zum Verzeichnis auf dem lokalen Gerät. Verzeichnis wird erzeugt, wenn es nicht existiert. Das Tilden-Zeichen (~) kann als Abkürzung benutzt werden für",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Pfad in dem alte Dateiversionen gespeichert werden sollen (ohne Angabe wird das Verzeichnis .stversions im Verzeichnis verwendet).",
+    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Pfad zum Ordner auf dem lokalen Gerät. Ordner wird erzeugt, wenn er nicht existiert. Das Tilden-Zeichen (~) kann als Abkürzung benutzt werden für",
+    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Pfad in dem alte Dateiversionen gespeichert werden sollen (ohne Angabe wird der Ordner .stversions im Ordner verwendet).",
     "Pause": "Pause",
     "Paused": "Pausiert",
     "Please consult the release notes before performing a major upgrade.": "Bitte lesen Sie die Veröffentlichungsnotizen bevor Sie eine neue Hauptversion installieren.",
@@ -135,11 +138,11 @@
     "Quick guide to supported patterns": "Schnellanleitung zu den unterstützten Mustern",
     "RAM Utilization": "RAM Auslastung",
     "Random": "Zufall",
-    "Reduced by ignore patterns": "Beschränkt durch Ignoriermuster",
+    "Reduced by ignore patterns": "Durch Ignoriermuster reduziert",
     "Release Notes": "Veröffentlichungsnotizen",
-    "Remote Devices": "Remote-Geräte",
+    "Remote Devices": "Fern-Geräte",
     "Remove": "Entfernen",
-    "Required identifier for the folder. Must be the same on all cluster devices.": "Erforderliche ID für das Verzeichnis. Muss auf allen Verbund-Geräten gleich sein.",
+    "Required identifier for the folder. Must be the same on all cluster devices.": "Erforderlicher Bezeichner für den Ordner. Muss auf allen Verbund-Geräten gleich sein.",
     "Rescan": "Neu scannen",
     "Rescan All": "Alle neu scannen",
     "Rescan Interval": "Scanintervall",
@@ -151,23 +154,25 @@
     "Save": "Speichern",
     "Scan Time Remaining": "Zeit für Scan verbleibend",
     "Scanning": "Scannen",
-    "Select the devices to share this folder with.": "Wähle die Geräte aus, mit denen Du dieses Verzeichnis teilen willst.",
-    "Select the folders to share with this device.": "Wähle die Verzeichnisse aus, die du mit diesem Gerät teilen möchtest",
+    "Select the devices to share this folder with.": "Wähle die Geräte aus, mit denen Du diesen Ordner teilen willst.",
+    "Select the folders to share with this device.": "Wähle die Ordner aus, die Du mit diesem Gerät teilen möchtest",
+    "Send & Receive": "Senden & empfangen",
+    "Send Only": "Nur senden",
     "Settings": "Einstellungen",
     "Share": "Teilen",
-    "Share Folder": "Teile Verzeichnis",
-    "Share Folders With Device": "Teile Verzeichnisse mit diesem Gerät",
+    "Share Folder": "Ordner teilen",
+    "Share Folders With Device": "Ordner mit diesem Gerät teilen",
     "Share With Devices": "Teile mit diesen Geräten",
-    "Share this folder?": "Dieses Verzeichnis teilen?",
+    "Share this folder?": "Diesen Ordner teilen?",
     "Shared With": "Geteilt mit",
-    "Show ID": "ID anzeigen",
+    "Show ID": "Kennung anzeigen",
     "Show QR": "Zeige QR Code",
-    "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 advertised to other devices as an optional default name.": "Wird anstatt der Gerätekennung im Verbund-Status angezeigt. Wird als optionaler Standardname an andere Geräte bekannt gegeben.",
     "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",
-    "Single level wildcard (matches within a directory only)": "Einzelnes Maskenzeichen (wird für ein einzelnes Verzeichnis verwendet)",
+    "Single level wildcard (matches within a directory only)": "Einzelnes Maskenzeichen (wird für einen einzelnen Ordner verwendet)",
     "Smallest First": "Kleinstes zuerst",
     "Source Code": "Quellcode",
     "Staggered File Versioning": "Stufenweise Dateiversionierung",
@@ -186,14 +191,14 @@
     "The Syncthing admin interface is configured to allow remote access without a password.": "Die Syncthing-Oberfläche erlaubt mit den jetzigen Einstellungen einen Zugriff ohne Passwort.",
     "The aggregated statistics are publicly available at the URL below.": "Die gesammelten Statistiken sind öffentlich unter der nachfolgenden URL verfügbar.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Die Konfiguration wurde gespeichert, aber noch nicht aktiviert. Syncthing muss neugestartet werden, um die neue Konfiguration zu übernehmen.",
-    "The device ID cannot be blank.": "Die Geräte ID darf nicht leer sein.",
-    "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Die hier einzutragende Geräte ID kann im \"Aktionen > Zeige ID\"-Dialog auf dem anderen Gerät gefunden werden. Leerzeichen und Bindestriche sind optional (werden ignoriert).",
-    "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.": "Der verschlüsselte Nutzungsbericht wird täglich gesendet. Er wird verwendet, um Statistiken über verwendete Betriebssysteme, Verzeichnis-Größen und Programm-Versionen zu erstellen. Sollte der Bericht in Zukunft weitere Daten erfassen, wird dieses Fenster erneut angezeigt.",
-    "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.": "Die eingegebene Geräte ID scheint nicht gültig zu sein. Es sollte eine 52 oder 56 stellige Zeichenkette aus Buchstaben und Nummern sein. Leerzeichen und Bindestriche sind optional.",
-    "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "Der erste Kommandozeilenparameter ist der Verzeichnis-Pfad und der zweite Parameter ist der relative Pfad in diesem Verzeichnis.",
-    "The folder ID cannot be blank.": "Die Verzeichnis ID darf nicht leer sein.",
-    "The folder ID must be unique.": "Die Verzeichnis ID darf nur einmal existieren.",
-    "The folder path cannot be blank.": "Der Verzeichnispfad darf nicht leer sein.",
+    "The device ID cannot be blank.": "Die Gerätekennung darf nicht leer sein.",
+    "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Die hier einzutragende Gerätekennung kann im Dialog \"Aktionen > Kennung anzeigen\" auf dem anderen Gerät gefunden werden. Leerzeichen und Bindestriche sind optional (werden ignoriert).",
+    "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.": "Der verschlüsselte Nutzungsbericht wird täglich gesendet. Er wird verwendet, um Statistiken über verwendete Betriebssysteme, Ordnergrößen und Programmversionen zu erstellen. Sollte der Bericht in Zukunft weitere Daten erfassen, wird dieses Fenster erneut angezeigt.",
+    "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.": "Die eingegebene Gerätekennung scheint nicht gültig zu sein. Es sollte eine 52 oder 56 stellige Zeichenkette aus Buchstaben und Nummern sein. Leerzeichen und Bindestriche sind optional.",
+    "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "Der erste Kommandozeilenparameter ist der Ordnerpfad und der zweite Parameter ist der relative Pfad in diesem Ordner.",
+    "The folder ID cannot be blank.": "Die Ordnerkennung darf nicht leer sein.",
+    "The folder ID must be unique.": "Die Ordnerkennung muss eindeutig sein.",
+    "The folder path cannot be blank.": "Der Ordnerpfad darf nicht leer sein.",
     "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.": "Es wird in folgenden Abständen versioniert: In der ersten Stunde wird alle 30 Sekunden eine Version behalten, am ersten Tag eine jede Stunde, in den ersten 30 Tagen eine jeden Tag. Danach wird bis zum angegebenen Höchstalter eine Version pro Woche behalten.",
     "The following items could not be synchronized.": "Die folgenden Objekte konnten nicht synchronisiert werden.",
     "The maximum age must be a number and cannot be blank.": "Das Höchstalter muss angegeben werden und eine Zahl sein.",
@@ -225,16 +230,16 @@
     "Version": "Version",
     "Versions Path": "Versionierungspfad",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Alte Dateiversionen werden automatisch gelöscht, wenn sie älter als das angegebene Höchstalter sind oder die angegebene Höchstzahl an Dateien erreicht ist.",
-    "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Warnung, dieser Pfad ist ein Unterverzeichnis des existierenden Verzeichnisses \"{{otherFolder}}\".",
+    "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Warnung, dieser Pfad ist ein Unterordner des existierenden Ordners \"{{otherFolder}}\".",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "Beachte beim Hinzufügen eines neuen Gerätes, dass dieses Gerät auch auf den anderen Geräten hinzugefügt werden muss.",
-    "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.": "Beachte bitte beim Hinzufügen eines neuen Verzeichnisses, dass die Verzeichnis ID dazu verwendet wird, Verzeichnisse zwischen Geräten zu verbinden. Die ID muss also auf allen Geräten gleich sein, die Groß- und Kleinschreibung muss dabei beachtet werden.",
+    "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.": "Beachte bitte beim Hinzufügen eines neuen Ordners, dass die Ordnerkennung dazu verwendet wird, Ordner zwischen Geräten zu verbinden. Die Kennung muss also auf allen Geräten gleich sein, die Groß- und Kleinschreibung muss dabei beachtet werden.",
     "Yes": "Ja",
     "You must keep at least one version.": "Du musst mindestens eine Version behalten.",
     "days": "Tage",
-    "directories": "Verzeichnisse",
+    "directories": "Ordner",
     "files": "Dateien",
     "full documentation": "Komplette Dokumentation",
     "items": "Objekte",
-    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} möchte das Verzeichnis \"{{folder}}\" teilen.",
-    "{%device%} wants to share folder \"{%folderlabel%}\" ({%folder%}).": "{{device}} möchte das Verzeichnis \"{{folderlabel}}\" ({{folder}}) teilen."
+    "{%device%} wants to share folder \"{%folder%}\".": "{{device}} möchte den Ordner \"{{folder}}\" teilen.",
+    "{%device%} wants to share folder \"{%folderlabel%}\" ({%folder%}).": "{{device}} möchte den Ordner \"{{folderlabel}}\" ({{folder}}) teilen."
 }

gui/default/assets/lang/lang-el.json

@@ -52,6 +52,8 @@
     "Downloaded": "Έχει ληφθεί",
     "Downloading": "Λήψη",
     "Edit": "Επεξεργασία",
+    "Edit Device": "Επεξεργασία συσκευής",
+    "Edit Folder": "Επεξεργασία φακέλου",
     "Editing": "Επεξεργασία σε εξέλιξη",
     "Enable NAT traversal": "Ενεργοποίηση διάσχισης NAT",
     "Enable Relaying": "Ενεργοποίηση αναμετάδοσης",
@@ -95,6 +97,7 @@
     "Last Scan": "Τελευταία Σάρωση",
     "Last seen": "Τελευταία φορά συνδεδεμένος",
     "Later": "Αργότερα",
+    "Latest Change": "Τελευταία αλλαγή",
     "Listeners": "Ακροατές",
     "Local Discovery": "Τοπική ανεύρεση",
     "Local State": "Τοπική κατάσταση",
@@ -153,6 +156,8 @@
     "Scanning": "Έλεγχος για αλλαγές",
     "Select the devices to share this folder with.": "Διάλεξε τις συσκευές προς τις οποίες θα διαμοιράζεται αυτός ο φάκελος.",
     "Select the folders to share with this device.": "Διάλεξε ποιοι φάκελοι θα διαμοιράζονται προς αυτή τη συσκευή.",
+    "Send & Receive": "Αποστολή και λήψη",
+    "Send Only": "Μόνο αποστολή",
     "Settings": "Ρυθμίσεις",
     "Share": "Διαμοίραση",
     "Share Folder": "Διαμοίραση φακέλου",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Downloaded",
     "Downloading": "Downloading",
     "Edit": "Edit",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Editing",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Enable Relaying",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "Last seen",
     "Later": "Later",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "Local Discovery",
     "Local State": "Local State",
@@ -153,6 +156,8 @@
     "Scanning": "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.": "Select the folders to share with this device.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Settings",
     "Share": "Share",
     "Share Folder": "Share Folder",

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

@@ -52,6 +52,8 @@
    "Downloaded": "Downloaded",
    "Downloading": "Downloading",
    "Edit": "Edit",
+   "Edit Device": "Edit Device",
+   "Edit Folder": "Edit Folder",
    "Editing": "Editing",
    "Enable NAT traversal": "Enable NAT traversal",
    "Enable Relaying": "Enable Relaying",
@@ -95,6 +97,7 @@
    "Last Scan": "Last Scan",
    "Last seen": "Last seen",
    "Later": "Later",
+   "Latest Change": "Latest Change",
    "Listeners": "Listeners",
    "Local Discovery": "Local Discovery",
    "Local State": "Local State",
@@ -153,6 +156,8 @@
    "Scanning": "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.": "Select the folders to share with this device.",
+   "Send \u0026 Receive": "Send \u0026 Receive",
+   "Send Only": "Send Only",
    "Settings": "Settings",
    "Share": "Share",
    "Share Folder": "Share Folder",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Descargado",
     "Downloading": "Descargando",
     "Edit": "Editar",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Editando",
     "Enable NAT traversal": "Permitir NAT transversal",
     "Enable Relaying": "Habilitar Retransmisión",
@@ -95,6 +97,7 @@
     "Last Scan": "Último escaneo",
     "Last seen": "Visto por última vez",
     "Later": "Más tarde",
+    "Latest Change": "Latest Change",
     "Listeners": "Oyentes",
     "Local Discovery": "Descubrimiento local",
     "Local State": "Estado local",
@@ -153,6 +156,8 @@
     "Scanning": "Analizando",
     "Select the devices to share this folder with.": "Selecciona los dispositivos con los que compartir esta carpeta.",
     "Select the folders to share with this device.": "Selecciona las carpetas para compartir con este dispositivo.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Ajustes",
     "Share": "Compartir",
     "Share Folder": "Compartir carpeta",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Descargado",
     "Downloading": "Descargando",
     "Edit": "Editar",
+    "Edit Device": "Cambiando dispositivo",
+    "Edit Folder": "Cambiando repositorio",
     "Editing": "Editando",
     "Enable NAT traversal": "Habilitar NAT trasversal",
     "Enable Relaying": "Habilitar Retransmisión",
@@ -95,6 +97,7 @@
     "Last Scan": "Último escaneo",
     "Last seen": "Visto por ultima vez",
     "Later": "Más tarde",
+    "Latest Change": "Último cambio",
     "Listeners": "Receptor",
     "Local Discovery": "Búsqueda en red local",
     "Local State": "Estado local",
@@ -153,6 +156,8 @@
     "Scanning": "Actualización",
     "Select the devices to share this folder with.": "Seleccione los dispositivos con los cuales compartir este repositorio.",
     "Select the folders to share with this device.": "Seleccione los repositorios para compartir con este dispositivo.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Configuración",
     "Share": "Compartir",
     "Share Folder": "Compartir repositorio",

gui/default/assets/lang/lang-eu.json

@@ -52,6 +52,8 @@
     "Downloaded": "Telekargatua",
     "Downloading": "Deskargatze",
     "Edit": "Aldatu",
+    "Edit Device": "Aldaketa tresna",
+    "Edit Folder": "Aldaketa partekatze",
     "Editing": "Aldaketa",
     "Enable NAT traversal": "Ahalbidetu NAT",
     "Enable Relaying": "Ahalbidetu lekua hartu",
@@ -95,6 +97,7 @@
     "Last Scan": "Azterketa azken",
     "Last seen": "Azken agerraldia",
     "Later": "Berantago",
+    "Latest Change": "Asken aldaketa",
     "Listeners": "Entzungailuak",
     "Local Discovery": "Lekuko aurkikuntza",
     "Local State": "Lekuko egoera",
@@ -123,7 +126,7 @@
     "Out of Sync Items": "Ez sinkronizatu elementuak",
     "Outgoing Rate Limit (KiB/s)": "Bidaltze emari gehieneko (KiB/s)",
     "Override Changes": "Aldaketak desegin",
-    "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": "Bertako tresnaren karpetari buruzko bidea. Ez balin bada, asmatu beharko da bat. Tildea (~, edo ~+Espazioa Windows XP+Azerty-n) erabil litzateke bide motz gisa.",
+    "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": "Bertako tresnaren karpetari buruzko bidea. Ez balin bada, asmatu beharko da bat. Vous pouvez entrer un chemin absolu (p.ex \"/home/moi/Sync/Exemple\") ou relatif à celui du programme (p.ex \"..\\Partages\\Exemple\" - utile pour installation portable). Tildea (~, edo ~+Espazioa Windows XP+Azerty-n) erabil litzateke bide motz gisa",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Kopiak kontserbatzeko bidea (hutsa utzezazu, .stversioen karpetaren bide ohituan).",
     "Pause": "Pausa",
     "Paused": "Geldirik",
@@ -153,6 +156,8 @@
     "Scanning": "Etengabeko azterketa",
     "Select the devices to share this folder with.": "Honekin sinkronizatua:",
     "Select the folders to share with this device.": "Tresna hunek erabiltzen dituen banaketak hauta",
+    "Send & Receive": "Igorri & Artu",
+    "Send Only": "Bakarrik igorri",
     "Settings": "Egokitzek",
     "Share": "Banatu",
     "Share Folder": "Banatu",

gui/default/assets/lang/lang-fi.json

@@ -52,6 +52,8 @@
     "Downloaded": "Ladattu",
     "Downloading": "Ladataan",
     "Edit": "Muokkaa",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Muokkaus",
     "Enable NAT traversal": "Aktivoi osoitteenmuunnoksen kierto",
     "Enable Relaying": "Aktivoi yhteyden välitys",
@@ -95,6 +97,7 @@
     "Last Scan": "Viimeisin skannaus",
     "Last seen": "Nähty viimeksi",
     "Later": "Myöhemmin",
+    "Latest Change": "Latest Change",
     "Listeners": "Kuuntelijat",
     "Local Discovery": "Paikallinen etsintä",
     "Local State": "Paikallinen tila",
@@ -153,6 +156,8 @@
     "Scanning": "Skannataan",
     "Select the devices to share this folder with.": "Valitse laitteet, joiden kanssa tämä kansio jaetaan.",
     "Select the folders to share with this device.": "Valitse kansiot jaettavaksi tämän laitteen kanssa.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Asetukset",
     "Share": "Jaa",
     "Share Folder": "Jaa kansio",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Téléchargé",
     "Downloading": "Téléchargement",
     "Edit": "Modifier",
+    "Edit Device": "Modifier l'appareil",
+    "Edit Folder": "Modifier le partage",
     "Editing": "Modifications",
     "Enable NAT traversal": "Activer transfert d'adresses NAT",
     "Enable Relaying": "Activer le relayage",
@@ -91,10 +93,11 @@
     "Inversion of the given condition (i.e. do not exclude)": "Inverser la condition donnée (i.e. ne pas exclure)",
     "Keep Versions": "Combien de versions conserver",
     "Largest First": "Les plus volumineux d'abord",
-    "Last File Received": "Dernière mise à jour",
+    "Last File Received": "Dernier changement",
     "Last Scan": "Dernière analyse",
     "Last seen": "Dernière apparition",
     "Later": "Plus tard",
+    "Latest Change": "Dernier changement",
     "Listeners": "Systèmes à l'écoute",
     "Local Discovery": "Découverte locale",
     "Local State": "État local",
@@ -123,7 +126,7 @@
     "Out of Sync Items": "Éléments non synchronisés",
     "Outgoing Rate Limit (KiB/s)": "Limite du débit sortant (KiB/s)",
     "Override Changes": "Écraser les changements",
-    "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": "Chemin vers le répertoire dans l'appareil local. Il sera créé s'il n'existe pas. Le caractère tilde (~, ou ~+Espace sous Windows XP+Azerty) peut être utilisé comme raccourci vers",
+    "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": "Chemin vers le répertoire dans l'appareil local. Il sera créé s'il n'existe pas. Vous pouvez entrer un chemin absolu (p.ex \"/home/moi/Sync/Exemple\") ou relatif à celui du programme (p.ex \"..\\Partages\\Exemple\" - utile pour installation portable). Le caractère tilde (~, ou ~+Espace sous Windows XP+Azerty) peut être utilisé comme raccourci vers",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Chemin où les versions doivent être conservées (laisser vide pour le chemin par défaut de .stversions dans le répertoire)",
     "Pause": "Pause",
     "Paused": "En pause",
@@ -153,6 +156,8 @@
     "Scanning": "Analyse en cours",
     "Select the devices to share this folder with.": "Synchroniser avec :",
     "Select the folders to share with this device.": "Sélectionner les partages auxquels participe cet appareil.",
+    "Send & Receive": "Envoi & réception",
+    "Send Only": "Envoi seulement",
     "Settings": "Configuration",
     "Share": "Partager",
     "Share Folder": "Partager",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Téléchargé",
     "Downloading": "Téléchargement",
     "Edit": "Modifier",
+    "Edit Device": "Modifier l'appareil",
+    "Edit Folder": "Modifier le partage",
     "Editing": "Modifications",
     "Enable NAT traversal": "Activer la translation d'adresses (NAT)",
     "Enable Relaying": "Relayage possible",
@@ -91,10 +93,11 @@
     "Inversion of the given condition (i.e. do not exclude)": "Inverser la condition donnée (i.e. ne pas exclure)",
     "Keep Versions": "Combien de versions conserver",
     "Largest First": "Les plus volumineux d'abord",
-    "Last File Received": "Dernière mise à jour",
+    "Last File Received": "Dernier changement",
     "Last Scan": "Dernière analyse",
     "Last seen": "Dernière apparition",
     "Later": "Plus tard",
+    "Latest Change": "Dernier changement",
     "Listeners": "Systèmes en écoute",
     "Local Discovery": "Découverte locale",
     "Local State": "État local",
@@ -123,7 +126,7 @@
     "Out of Sync Items": "Éléments non synchronisés",
     "Outgoing Rate Limit (KiB/s)": "Limite du débit d'émission (Ko/s)",
     "Override Changes": "Écraser les changements",
-    "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": "Chemin vers le répertoire dans l'appareil local. Il sera créé s'il n'existe pas. Le caractère tilde (~, ou ~+Espace sous Windows XP+Azerty) peut être utilisé comme raccourci vers",
+    "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": "Chemin vers le répertoire dans l'appareil local. Il sera créé s'il n'existe pas. Vous pouvez entrer un chemin absolu (p.ex \"/home/moi/Sync/Exemple\") ou relatif à celui du programme (p.ex \"..\\Partages\\Exemple\" - utile pour installation portable). Le caractère tilde (~, ou ~+Espace sous Windows XP+Azerty) peut être utilisé comme raccourci vers",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Chemin où les copies doivent être conservées (laisser vide pour le chemin par défaut de .stversions dans le répertoire)",
     "Pause": "Pause",
     "Paused": "En pause",
@@ -153,6 +156,8 @@
     "Scanning": "Analyse en cours",
     "Select the devices to share this folder with.": "Synchroniser avec :",
     "Select the folders to share with this device.": "Sélectionner les partages auxquels participe cet appareil.",
+    "Send & Receive": "Envoyer & recevoir",
+    "Send Only": "Envoyer seulement",
     "Settings": "Configuration",
     "Share": "Partager",
     "Share Folder": "Partager",

gui/default/assets/lang/lang-fy.json

@@ -52,6 +52,8 @@
     "Downloaded": "Ynladen",
     "Downloading": "Oan it ynladen",
     "Edit": "Bewurkje",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Bewurkjen",
     "Enable NAT traversal": "NAT-trochkruse ynskeakelje",
     "Enable Relaying": "Trochjaan tastean",
@@ -95,6 +97,7 @@
     "Last Scan": "Lêst Skent",
     "Last seen": "Lêst sjoen",
     "Later": "Letter",
+    "Latest Change": "Latest Change",
     "Listeners": "Harkers",
     "Local Discovery": "Lokale ûntdekking",
     "Local State": "Lokale tastân",
@@ -153,6 +156,8 @@
     "Scanning": "Oan it skennen",
     "Select the devices to share this folder with.": "Sykje de apparaten út om dizze map mei te dielen.",
     "Select the folders to share with this device.": "Sykje de mappen út om mei dit apparaat te dielen.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Ynstellings",
     "Share": "Diele",
     "Share Folder": "Map diele",

gui/default/assets/lang/lang-hu.json

@@ -52,6 +52,8 @@
     "Downloaded": "Letöltve",
     "Downloading": "Letöltés",
     "Edit": "Szerkesztés",
+    "Edit Device": "Eszköz szerkesztése",
+    "Edit Folder": "Mappa szerkesztése",
     "Editing": "Szerkesztés",
     "Enable NAT traversal": "NAT bejárás engedélyezése",
     "Enable Relaying": "Közvetítés engedélyezése",
@@ -95,6 +97,7 @@
     "Last Scan": "Utolsó vizsgálat",
     "Last seen": "Utoljára látva",
     "Later": "Később",
+    "Latest Change": "Utolsó módosítás",
     "Listeners": "Kapcsolatok",
     "Local Discovery": "Helyi felfedezés",
     "Local State": "Helyi állapot",
@@ -153,6 +156,8 @@
     "Scanning": "Átnézés",
     "Select the devices to share this folder with.": "Válaszd ki az eszközöket, amelyekkel meg szeretnéd osztani a mappát",
     "Select the folders to share with this device.": "Válaszd ki a mappákat, amiket meg szeretnél osztani ezzel az eszközzel.",
+    "Send & Receive": "Küldés és fogadás",
+    "Send Only": "Csak küldés",
     "Settings": "Beállítások",
     "Share": "Megosztás",
     "Share Folder": "Mappa megosztása",

gui/default/assets/lang/lang-id.json

@@ -52,6 +52,8 @@
     "Downloaded": "Terunduh",
     "Downloading": "Mengunduh",
     "Edit": "Sunting",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Menyunting",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Aktifkan Relay",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "Last seen",
     "Later": "Later",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "Local Discovery",
     "Local State": "Local State",
@@ -153,6 +156,8 @@
     "Scanning": "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.": "Select the folders to share with this device.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Settings",
     "Share": "Share",
     "Share Folder": "Share Folder",

gui/default/assets/lang/lang-it.json

@@ -52,6 +52,8 @@
     "Downloaded": "Scaricato",
     "Downloading": "Scaricamento in corso",
     "Edit": "Modifica",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Modifica di",
     "Enable NAT traversal": "Abilita NAT traversal",
     "Enable Relaying": "Abilita Reindirizzamento",
@@ -92,10 +94,11 @@
     "Keep Versions": "Versioni Mantenute",
     "Largest First": "Prima il più grande",
     "Last File Received": "Ultimo File Ricevuto",
-    "Last Scan": "Ultima scansione",
+    "Last Scan": "Ultima Scansione",
     "Last seen": "Ultima connessione",
     "Later": "Più Tardi",
-    "Listeners": "In ascolto",
+    "Latest Change": "Ultima Modifica",
+    "Listeners": "In Ascolto",
     "Local Discovery": "Individuazione Locale",
     "Local State": "Stato Locale",
     "Local State (Total)": "Stato Locale (Totale)",
@@ -153,6 +156,8 @@
     "Scanning": "Scansione in corso",
     "Select the devices to share this folder with.": "Seleziona i dispositivi con i quali condividere questa cartella.",
     "Select the folders to share with this device.": "Seleziona le cartelle da condividere con questo dispositivo.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Impostazioni",
     "Share": "Condividi",
     "Share Folder": "Condividi la Cartella",
@@ -220,7 +225,7 @@
     "Upgrade To {%version%}": "Aggiorna alla {{version}}",
     "Upgrading": "Aggiornamento",
     "Upload Rate": "Velocità Upload",
-    "Uptime": "Tempo di funzionamento",
+    "Uptime": "Tempo di Funzionamento",
     "Use HTTPS for GUI": "Utilizza HTTPS per l'interfaccia grafica",
     "Version": "Versione",
     "Versions Path": "Percorso Cartella Versioni",

gui/default/assets/lang/lang-ja.json

@@ -31,7 +31,7 @@
     "Command": "コマンド",
     "Comment, when used at the start of a line": "行頭で使用された場合、コメント行",
     "Compression": "圧縮",
-    "Configured": "Configured",
+    "Configured": "設定値",
     "Connection Error": "接続エラー",
     "Connection Type": "接続種別",
     "Copied from elsewhere": "別ファイルからコピー済",
@@ -45,13 +45,15 @@
     "Device Name": "デバイス名",
     "Devices": "デバイス",
     "Disconnected": "切断中",
-    "Discovered": "Discovered",
+    "Discovered": "探索結果",
     "Discovery": "探索サーバー",
     "Documentation": "マニュアル",
     "Download Rate": "ダウンロード速度",
     "Downloaded": "ダウンロード済",
     "Downloading": "ダウンロード中",
     "Edit": "編集",
+    "Edit Device": "デバイスの編集",
+    "Edit Folder": "フォルダーの編集",
     "Editing": "編集中",
     "Enable NAT traversal": "NATトラバーサルを有効にする",
     "Enable Relaying": "中継サーバー経由の通信を有効にする",
@@ -95,6 +97,7 @@
     "Last Scan": "最終スキャン時刻",
     "Last seen": "最終接続日時",
     "Later": "後で設定",
+    "Latest Change": "最終更新内容",
     "Listeners": "待ち受けポート",
     "Local Discovery": "LAN内で探索",
     "Local State": "ローカル状態",
@@ -135,7 +138,7 @@
     "Quick guide to supported patterns": "サポートされているパターンの簡易ガイド",
     "RAM Utilization": "メモリ使用量",
     "Random": "ランダム",
-    "Reduced by ignore patterns": "Reduced by ignore patterns",
+    "Reduced by ignore patterns": "無視パターン該当分を除く",
     "Release Notes": "リリースノート",
     "Remote Devices": "他のデバイス",
     "Remove": "除去",
@@ -153,6 +156,8 @@
     "Scanning": "スキャン中",
     "Select the devices to share this folder with.": "このフォルダーを共有するデバイスを選択してください。",
     "Select the folders to share with this device.": "このデバイスと共有するフォルダーを選択してください。",
+    "Send & Receive": "送受信",
+    "Send Only": "送信のみ",
     "Settings": "設定",
     "Share": "共有",
     "Share Folder": "フォルダーを共有する",
@@ -231,8 +236,8 @@
     "Yes": "はい",
     "You must keep at least one version.": "少なくとも一つのバージョンを保存してください。",
     "days": "日",
-    "directories": "directories",
-    "files": "files",
+    "directories": "ディレクトリ",
+    "files": "ファイル",
     "full documentation": "詳細なマニュアル",
     "items": "項目",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} がフォルダー \"{{folder}}\" を共有するよう求めています。",

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

@@ -52,6 +52,8 @@
     "Downloaded": "다운로드됨",
     "Downloading": "다운로드 중",
     "Edit": "편집",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "편집",
     "Enable NAT traversal": "NAT traversal 활성화",
     "Enable Relaying": "Relaying 활성화",
@@ -95,6 +97,7 @@
     "Last Scan": "마지막 탐색",
     "Last seen": "마지막 접속",
     "Later": "나중에",
+    "Latest Change": "최신 변경",
     "Listeners": "수신자",
     "Local Discovery": "로컬 노드 검색",
     "Local State": "로컬 상태",
@@ -153,6 +156,8 @@
     "Scanning": "탐색중",
     "Select the devices to share this folder with.": "이 폴더를 공유할 장치를 선택합니다.",
     "Select the folders to share with this device.": "이 장치와 공유할 폴더를 선택합니다.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "설정",
     "Share": "공유",
     "Share Folder": "폴더 공유",

gui/default/assets/lang/lang-lt.json

@@ -52,6 +52,8 @@
     "Downloaded": "Parsisiųstas",
     "Downloading": "Siunčiama",
     "Edit": "Redaguoti",
+    "Edit Device": "Redaguoti įrenginį",
+    "Edit Folder": "Redaguoti aplanką",
     "Editing": "Redagavimas",
     "Enable NAT traversal": "Leisti kirsti NAT",
     "Enable Relaying": "Įjungti retransliavimą",
@@ -82,7 +84,7 @@
     "Global State": "Visuotinė būsena",
     "Help": "Pagalba",
     "Home page": "Pagrindinis puslapis",
-    "Ignore": "Ignoruoti",
+    "Ignore": "Nepaisyti",
     "Ignore Patterns": "Nepaisyti šablonų",
     "Ignore Permissions": "Nepaisyti failų prieigos leidimų",
     "Incoming Rate Limit (KiB/s)": "Įeinančio srauto maksimalus greitis (KiB/s)",
@@ -95,6 +97,7 @@
     "Last Scan": "Paskutinis nuskaitymas",
     "Last seen": "Paskutinį kartą matytas",
     "Later": "Vėliau",
+    "Latest Change": "Paskutinis pakeitimas",
     "Listeners": "Klausytojai",
     "Local Discovery": "Vietinis matomumas",
     "Local State": "Vietinė būsena",
@@ -135,7 +138,7 @@
     "Quick guide to supported patterns": "Trumpas leistinų šablonų vadovas",
     "RAM Utilization": "Atminties naudojimas",
     "Random": "Atsitiktinė",
-    "Reduced by ignore patterns": "Reduced by ignore patterns",
+    "Reduced by ignore patterns": "Sumažinta pagal nepaisomus šablonus",
     "Release Notes": "Laidos Informacija",
     "Remote Devices": "Nuotoliniai įrenginiai",
     "Remove": "Pašalinti",
@@ -153,6 +156,8 @@
     "Scanning": "Skenuojama",
     "Select the devices to share this folder with.": "Pasirinkite įrenginius, su kuriais dalinsitės šį aplanką.",
     "Select the folders to share with this device.": "Pasirinkite aplankus kuriais norite dalintis su šiuo įrenginiu.",
+    "Send & Receive": "Siųsti ir gauti",
+    "Send Only": "Tik siųsti",
     "Settings": "Nustatymai",
     "Share": "Dalintis",
     "Share Folder": "Dalintis aplanku",

gui/default/assets/lang/lang-nb.json

@@ -6,20 +6,20 @@
     "About": "Om",
     "Actions": "Handlinger",
     "Add": "Legg til",
-    "Add Device": "Legg til Enhet",
-    "Add Folder": "Legg til Mappe",
+    "Add Device": "Legg til enhet",
+    "Add Folder": "Legg til mappe",
     "Add Remote Device": "Legg til ekstern enhet",
     "Add new folder?": "Legg til ny mappe?",
     "Address": "Adresse",
     "Addresses": "Adresser",
     "Advanced": "Avansert",
-    "Advanced Configuration": "Avanserte Innstillinger",
+    "Advanced Configuration": "Avanserte innstillinger",
     "Advanced settings": "Avanserte innstillinger ",
     "All Data": "Alle data",
-    "Allow Anonymous Usage Reporting?": "Tillat Anonym Innsamling Av Brukerdata?",
+    "Allow Anonymous Usage Reporting?": "Tillat anonym innsamling av brukerdata?",
     "Alphabetic": "Alfabetisk",
     "An external command handles the versioning. It has to remove the file from the synced folder.": "En ekstern kommando håndterer versjonkontrollen. Den må fjerne filen fra den synkroniserte katalogen.",
-    "Anonymous Usage Reporting": "Anonym Innsamling Av Brukerdata",
+    "Anonymous Usage Reporting": "Anonym innsamling av brukerdata",
     "Any devices configured on an introducer device will be added to this device as well.": "Enheter konfigurert på en introduksjonsenhet vil også bli lagt til denne enheten.",
     "Automatic upgrades": "Automatiske oppdateringer",
     "Be careful!": "Vær forsiktig!",
@@ -42,7 +42,7 @@
     "Device \"{%name%}\" ({%device%} at {%address%}) wants to connect. Add new device?": "Enhet \"{{name}}\" ({{device}} på {{address}}) ønsker å koble til. Legge til ny enhet?",
     "Device ID": "Enhets ID",
     "Device Identification": "Enhetskjennemerke",
-    "Device Name": "Navn på Enhet",
+    "Device Name": "Navn på enhet",
     "Devices": "Enheter",
     "Disconnected": "Frakoblet",
     "Discovered": "Oppdaget",
@@ -52,13 +52,15 @@
     "Downloaded": "Lastet ned",
     "Downloading": "Laster ned",
     "Edit": "Rediger",
+    "Edit Device": "Rediger enhet",
+    "Edit Folder": "Rediger katalog",
     "Editing": "Redigerer",
     "Enable NAT traversal": "Slå på NAT traversering",
     "Enable Relaying": "Aktiver relésending",
     "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Skriv inn kommaseparerte (\"tcp://ip:port\", \"tcp://host:port\") adresser, eller ordet \"dynamic\" for å gjøre automatisk oppslag for adressen.",
     "Enter ignore patterns, one per line.": "Skriv inn mønster som skal utelates, ett per linje.",
     "Error": "Feilmelding",
-    "External File Versioning": "Ekstern Versjonskontroll",
+    "External File Versioning": "Ekstern versjonskontroll",
     "Failed Items": "Elementsynkronisering som har feilet",
     "File Pull Order": "Filenes Henterekkefølge",
     "File Versioning": "Versjonskontroll",
@@ -79,39 +81,40 @@
     "Generate": "Generer",
     "Global Discovery": "Globalt oppslag",
     "Global Discovery Servers": "Globale oppslagstjenere",
-    "Global State": "Global Tilstand",
+    "Global State": "Global tilstand",
     "Help": "Hjelp",
     "Home page": "Hjemmeside",
     "Ignore": "Ignorer",
     "Ignore Patterns": "Utelatelsesmønster",
     "Ignore Permissions": "Ignorer Tilgangsbit",
-    "Incoming Rate Limit (KiB/s)": "Innkommende Hastighetsbegrensning (KiB/s)",
+    "Incoming Rate Limit (KiB/s)": "Innkommende hastighetsbegrensning (KiB/s)",
     "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Feilaktige innstillinger kan skade innholdet i dine delte kataloger og hindre Syncthing i å fungere.",
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Invers av den gitte tilstanden (t.d. ikke ekskluder)",
-    "Keep Versions": "Behold Versjoner",
+    "Keep Versions": "Behold versjoner",
     "Largest First": "Største fil",
     "Last File Received": "Siste mottatte fil",
     "Last Scan": "Siste gjennomsøking",
     "Last seen": "Sist sett",
     "Later": "Senere",
+    "Latest Change": "Sist endret",
     "Listeners": "Lyttere",
     "Local Discovery": "Lokalt oppslag",
-    "Local State": "Lokal Tilstand",
-    "Local State (Total)": "Lokal Tilstand (Total)",
-    "Major Upgrade": "Hovedoppgradering",
-    "Master": "Hoved",
-    "Maximum Age": "Maksimal Levetid",
+    "Local State": "Lokal tilstand",
+    "Local State (Total)": "Lokal tilstand (Total)",
+    "Major Upgrade": "Storoppgradering",
+    "Master": "Styrende",
+    "Maximum Age": "Maksimal levetid",
     "Metadata Only": "Kun metadata",
     "Minimum Free Disk Space": "Nødvendig ledig diskplass",
     "Move to top of queue": "Flytt fremst i køen",
     "Multi level wildcard (matches multiple directory levels)": "Multinivåsøk (søker på flere mappenivå)",
     "Never": "Aldri",
-    "New Device": "Ny Enhet",
-    "New Folder": "Ny Mappe",
+    "New Device": "Ny enhet",
+    "New Folder": "Ny mappe",
     "Newest First": "Den nyeste først",
     "No": "Nei",
-    "No File Versioning": "Ingen Versjonskontroll",
+    "No File Versioning": "Ingen versjonskontroll",
     "Normal": "Normal",
     "Notice": "Merknader",
     "OK": "OK",
@@ -120,18 +123,18 @@
     "Optional descriptive label for the folder. Can be different on each device.": "Valgfri merkelapp på katalogen. Denne kan være ulik på forskjellige enheter",
     "Options": "Valg",
     "Out of Sync": "Ikke synkronisert",
-    "Out of Sync Items": "Ikke Synkroniserte Element",
-    "Outgoing Rate Limit (KiB/s)": "Utgående Hastighetsbegrensning (KiB/s)",
-    "Override Changes": "Overstyr Endringer",
+    "Out of Sync Items": "Ikke synkroniserte element",
+    "Outgoing Rate Limit (KiB/s)": "Utgående hastighetsbegrensning (KiB/s)",
+    "Override Changes": "Overstyr endringer",
     "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": "Plasseringen av mappen på datamaskinen. Denne vil bli opprettet dersom den ikke finnes. Krøllstrektegnet (~) kan brukes som forkortelse for",
     "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Plasseringen for lagrede versjoner (la denne være tom for å bruke standard .stversions-mappen i mappen).",
     "Pause": "Oppholde",
     "Paused": "Oppholdt",
-    "Please consult the release notes before performing a major upgrade.": "Se \"release notes\" før en hovedoppgradering utføres.",
+    "Please consult the release notes before performing a major upgrade.": "Se \"release notes\" før en storoppgradering utføres.",
     "Please set a GUI Authentication User and Password in the Settings dialog.": "Vennligst angi bruker og passord for GUI-autentisering i innstillingsvinduet.",
     "Please wait": "Vennligst vent",
     "Preview": "Forhåndsvisning",
-    "Preview Usage Report": "Forhåndsvisning Av Datainnsamling",
+    "Preview Usage Report": "Forhåndsvisning av datainnsamling",
     "Quick guide to supported patterns": "Kjapp innføring i godkjente mønster",
     "RAM Utilization": "RAM-utnyttelse",
     "Random": "Tilfeldig",
@@ -144,8 +147,8 @@
     "Rescan All": "Gjennomsøk alt på nytt",
     "Rescan Interval": "Intervall for gjennomsøking",
     "Restart": "Omstart",
-    "Restart Needed": "Omstart Kreves",
-    "Restarting": "Starter På Ny",
+    "Restart Needed": "Omstart kreves",
+    "Restarting": "Starter på nytt",
     "Resume": "Gjenoppta",
     "Reused": "Gjenbrukt",
     "Save": "Lagre",
@@ -153,29 +156,31 @@
     "Scanning": "Gjennomsøker",
     "Select the devices to share this folder with.": "Velg enhetene du vil dele denne mappen med.",
     "Select the folders to share with this device.": "Velg hvilke mapper som skal deles med denne enheten.",
+    "Send & Receive": "Sende og motta",
+    "Send Only": "Bare sende",
     "Settings": "Innstillinger",
     "Share": "Del",
-    "Share Folder": "Del Mappe",
-    "Share Folders With Device": "Del Mapper Med Enhet",
-    "Share With Devices": "Del Med Enheter",
+    "Share Folder": "Del mappe",
+    "Share Folders With Device": "Del mapper med enhet",
+    "Share With Devices": "Del med enheter",
     "Share this folder?": "Dele denne mappen?",
     "Shared With": "Delt med",
     "Show ID": "Vis ID",
     "Show QR": "Vis QR kode",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Vis i stedet for Eining ID i gruppestatus. Vil bli kringkastet til andre enheter som et valgfritt standardnavn.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Vist i stedet for Mappe-ID i gruppestatus. Vil bli oppdatert til navnet enheten kringkaster dersom tomt.",
+    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Vis i stedet for enhets ID i gruppestatus. Vil bli kringkastet til andre enheter som et valgfritt standardnavn.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Vist i stedet for mappe ID i gruppestatus. Vil bli oppdatert til navnet enheten kringkaster dersom tomt.",
     "Shutdown": "Avslutt",
     "Shutdown Complete": "Avslutning fullført",
-    "Simple File Versioning": "Enkel Versjonskontroll",
+    "Simple File Versioning": "Enkel versjonskontroll",
     "Single level wildcard (matches within a directory only)": "Enkeltnivåsøk (søker kun i en mappe)",
     "Smallest First": "Den minste først",
     "Source Code": "Kildekode",
     "Staggered File Versioning": "Forskjøvet Versjonskontroll",
-    "Start Browser": "Start Nettleser",
+    "Start Browser": "Start nettleser",
     "Statistics": "Statistikk",
     "Stopped": "Stoppa",
     "Support": "Brukerstøtte",
-    "Sync Protocol Listen Addresses": "Lytteadresse For Synkroniseringsprotokoll",
+    "Sync Protocol Listen Addresses": "Lytteadresse for synkroniseringsprotokoll",
     "Syncing": "Synkroniserer",
     "Syncthing has been shut down.": "Syncthing har blitt slått av.",
     "Syncthing includes the following software or portions thereof:": "Syncthing inkluderer helt eller delvis følgende programvare:",
@@ -209,21 +214,21 @@
     "They are retried automatically and will be synced when the error is resolved.": "Disse hentes automatisk og vil synkroniseres når feilen er blitt utbedret.",
     "This Device": "Denne enheten",
     "This can easily give hackers access to read and change any files on your computer.": "Dette kan lett gi hackere tilgang til å lese og endre alle filer på datamaskinen din.",
-    "This is a major version upgrade.": "Dette er en hovedoppgradering",
-    "Trash Can File Versioning": "Papirkurv Versjonskontroll",
+    "This is a major version upgrade.": "Dette er en storoppgradering",
+    "Trash Can File Versioning": "Papirkurv versjonskontroll",
     "Unknown": "Ukjent",
     "Unshared": "Ikke delt",
     "Unused": "Ikke i bruk",
     "Up to Date": "Oppdatert",
     "Updated": "Oppdatert",
     "Upgrade": "Oppgradere",
-    "Upgrade To {%version%}": "Oppgrader Til {{version}}",
+    "Upgrade To {%version%}": "Oppgrader til {{version}}",
     "Upgrading": "Oppgraderer",
     "Upload Rate": "Opplastingsrate",
     "Uptime": "Oppetid",
     "Use HTTPS for GUI": "Bruk HTTPS for GUI",
     "Version": "Versjon",
-    "Versions Path": "Plassering Av Versjoner",
+    "Versions Path": "Plassering av versjoner",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Versjoner blir automatisk slettet når maksimal levetid er nådd eller når antall filer er oversteget.",
     "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Advarsel, denne stien er en underkatalog i en eksisterende katalog \"{{otherFolder}}\".",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "Merk at når en ny enhet blir lagt til må denne også legges til på andre siden.",

gui/default/assets/lang/lang-nl.json

@@ -31,7 +31,7 @@
     "Command": "Commando",
     "Comment, when used at the start of a line": "Reageer indien gebruikt aan het begin van een lijn.",
     "Compression": "Compressie",
-    "Configured": "Configured",
+    "Configured": "Geconfigureerd",
     "Connection Error": "Verbindingsfout",
     "Connection Type": "Soort verbinding",
     "Copied from elsewhere": "Gekopieerd vanaf elders",
@@ -45,13 +45,15 @@
     "Device Name": "Naam apparaat",
     "Devices": "Apparaten",
     "Disconnected": "Niet verbonden",
-    "Discovered": "Discovered",
+    "Discovered": "Ontdekt",
     "Discovery": "Zoeken",
     "Documentation": "Documentatie",
     "Download Rate": "Downloadsnelheid",
     "Downloaded": "Gedownload",
     "Downloading": "Bezig met downloaden",
     "Edit": "Bewerk",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Bezig met bewerken",
     "Enable NAT traversal": "Activeer NAT traversal",
     "Enable Relaying": "Activeer doorsturen",
@@ -95,6 +97,7 @@
     "Last Scan": "Laatste scan",
     "Last seen": "Laatst gezien op",
     "Later": "Later",
+    "Latest Change": "Meest recente wijziging",
     "Listeners": "Luisteraars",
     "Local Discovery": "Lokaal zoeken",
     "Local State": "Lokale status",
@@ -135,7 +138,7 @@
     "Quick guide to supported patterns": "Snelgids voor ondersteunde patronen",
     "RAM Utilization": "Geheugengebruik",
     "Random": "Willekeurig",
-    "Reduced by ignore patterns": "Reduced by ignore patterns",
+    "Reduced by ignore patterns": "Verminderd door negeerpatronen",
     "Release Notes": "Release notes",
     "Remote Devices": "Externe apparaten",
     "Remove": "Verwijderen",
@@ -153,6 +156,8 @@
     "Scanning": "Aan het zoeken",
     "Select the devices to share this folder with.": "Selecteer de apparaten om deze map mee te delen.",
     "Select the folders to share with this device.": "Selecteer de mappen om met dit apparaat te delen.",
+    "Send & Receive": "Verzenden & Ontvangen",
+    "Send Only": "Alleen verzenden",
     "Settings": "Instellingen",
     "Share": "Delen",
     "Share Folder": "Deel map",
@@ -231,8 +236,8 @@
     "Yes": "Ja",
     "You must keep at least one version.": "Minstens 1 versie moet bewaard blijven.",
     "days": "dagen",
-    "directories": "directories",
-    "files": "files",
+    "directories": "Mappen",
+    "files": "Bestanden",
     "full documentation": "volledige documentatie",
     "items": "objecten",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wil de map \"{{folder}}\" delen.",

gui/default/assets/lang/lang-nn.json

@@ -1,6 +1,6 @@
 {
-    "A device with that ID is already added.": "Ein eining med den ID er allerede lagt til.",
-    "A negative number of days doesn't make sense.": "Eit negativt tal dagar har ikkje meining.",
+    "A device with that ID is already added.": "Ei eining med den ID-en er allereie lagt til.",
+    "A negative number of days doesn't make sense.": "Eit negativt tal dagar gir ikkje meining.",
     "A new major version may not be compatible with previous versions.": "Ein ny hovudversjon er ikkje nødvendigvis kompatibel med eldre versjonar. ",
     "API Key": "API-nøkkel",
     "About": "Om",
@@ -8,17 +8,17 @@
     "Add": "Legg til",
     "Add Device": "Legg Til Eining",
     "Add Folder": "Legg Til Mappe",
-    "Add Remote Device": "Legg Til Ekstern Eining",
+    "Add Remote Device": "Legg til ekstern eining",
     "Add new folder?": "Leggja til ny mappe?",
     "Address": "Adresse",
     "Addresses": "Adresser",
     "Advanced": "Avansert",
     "Advanced Configuration": "Avansert konfigurasjon",
-    "Advanced settings": "Avansert innstillingar",
+    "Advanced settings": "Avanserte innstillingar",
     "All Data": "Alle data",
     "Allow Anonymous Usage Reporting?": "Tillata anonymisert bruksrapportering?",
     "Alphabetic": "Alfabetisk",
-    "An external command handles the versioning. It has to remove the file from the synced folder.": "Ein ekstern kommando håndterer filutgåver. Den må sørge for at fila blir fjerna frå den synkroniserte mappa.",
+    "An external command handles the versioning. It has to remove the file from the synced folder.": "Ein ekstern kommando handterer filutgåver. Den må sørga for at fila blir fjerna frå den synkroniserte mappa.",
     "Anonymous Usage Reporting": "Anonymisert bruksrapportering",
     "Any devices configured on an introducer device will be added to this device as well.": "Einingar konfigurert på ei introduksjonseining vil òg verta lagt til denne eininga.",
     "Automatic upgrades": "Automatiske oppdateringar",
@@ -39,7 +39,7 @@
     "Copyright © 2014-2016 the following Contributors:": "Opphavsrett © 2014-2016 for følgjande bidragsyterar:",
     "Danger!": "Fare!",
     "Deleted": "Sletta",
-    "Device \"{%name%}\" ({%device%} at {%address%}) wants to connect. Add new device?": "Eininga \"{{name}}\" {{device}} ({{address}}) vil kopla seg til. Vil du leggja ho til?",
+    "Device \"{%name%}\" ({%device%} at {%address%}) wants to connect. Add new device?": "Eininga «{{name}}» {{device}} ({{address}}) vil kopla seg til. Vil du leggja ho til?",
     "Device ID": "Eining ID",
     "Device Identification": "Einingskjennemerke",
     "Device Name": "Namn På Eining",
@@ -52,23 +52,25 @@
     "Downloaded": "Lasta ned",
     "Downloading": "Lastar ned",
     "Edit": "Rediger",
+    "Edit Device": "Rediger enhet",
+    "Edit Folder": "Rediger katalog",
     "Editing": "Redigerer",
     "Enable NAT traversal": "Slå på NAT-gjennomgang",
-    "Enable Relaying": "Aktiver Reléer",
-    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Skriv inn adresser med komma mellom kvar adresse (\"tcp://ip:port\", \"tcp://host:port\"), eller \"dynamic\" for å automatisk søkja opp adressa.",
+    "Enable Relaying": "Aktiver relé",
+    "Enter comma separated  (\"tcp://ip:port\", \"tcp://host:port\") addresses or \"dynamic\" to perform automatic discovery of the address.": "Skriv inn adresser med komma mellom kvar adresse («tcp://ip:port», «tcp://host:port»), eller «dynamic» for å automatisk søkja opp adressa.",
     "Enter ignore patterns, one per line.": "Skriv inn mønster som skal utelatast, eitt per linje.",
     "Error": "Feilmelding",
     "External File Versioning": "Ekstern filutgåvehandtering",
     "Failed Items": "Feilande element",
     "File Pull Order": "Henterekkefølge for filer",
     "File Versioning": "Filutgåvekontroll",
-    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Informasjon om filrettar vert ignorert når det blir leita etter endringar. Bruk på FAT filsystem. ",
+    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Informasjon om filrettar vert ignorert når det blir leita etter endringar. Bruk på FAT-filsystem. ",
     "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Filer som Syncthing slettar eller skriv over vert flytta til katalogen .stversions.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Filer som Syncthing oppdaterar eller sletter vert flytta til ein datostempla versjon i .stversions-katalogen.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Filer som Syncthing oppdaterer eller slettar vert flytta til ein datostempla versjon i .stversions-katalogen.",
     "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 er beskytta mot endringar gjort på andre einingar, men endringar gjort på denne eininga vert sende til resten av klyngja.",
     "Folder": "Mappe",
     "Folder ID": "Mappe ID",
-    "Folder Label": "Merkelapp for Mappe",
+    "Folder Label": "Merkelapp for mappa",
     "Folder Path": "Mappeplassering",
     "Folder Type": "Mappetype",
     "Folders": "Mapper",
@@ -78,7 +80,7 @@
     "GUI Listen Addresses": "GUI Lytteadresse",
     "Generate": "Generer",
     "Global Discovery": "Global søking",
-    "Global Discovery Servers": "Globalsøkjetenarar",
+    "Global Discovery Servers": "Globale søkjetenarar",
     "Global State": "Global Tilstand",
     "Help": "Hjelp",
     "Home page": "Heimeside",
@@ -86,15 +88,16 @@
     "Ignore Patterns": "Utelatingsmønster",
     "Ignore Permissions": "Ignorer tilgangar",
     "Incoming Rate Limit (KiB/s)": "Innkomande hastigheitsgrense (KiB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Feil innstillingar kan skade innhaldet i dine delte katalogar og hindre Syncthing i å fungere.",
+    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Feil innstillingar kan skada innhaldet i dine delte katalogar og hindra Syncthing i å fungera.",
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Det motsette av den gitte tilstanden (dvs. ekskluder ikkje)",
     "Keep Versions": "Behald Versjonar",
     "Largest First": "Største fyrst",
     "Last File Received": "Siste mottatte fila",
-    "Last Scan": "Siste Skanning",
+    "Last Scan": "Siste skanning",
     "Last seen": "Sist sett",
     "Later": "Seinare",
+    "Latest Change": "Siste endringar",
     "Listeners": "Lyttarar",
     "Local Discovery": "Lokal oppdaging",
     "Local State": "Lokal Tilstand",
@@ -111,24 +114,24 @@
     "New Folder": "Ny mappe",
     "Newest First": "Nyaste fyrst",
     "No": "Nei",
-    "No File Versioning": "Ingen filutgåvehandtering",
+    "No File Versioning": "Inga filutgåvehandtering",
     "Normal": "Normal",
     "Notice": "Merknad",
     "OK": "OK",
     "Off": "Av",
-    "Oldest First": "Elste fyrst",
-    "Optional descriptive label for the folder. Can be different on each device.": "Valfri merkelapp på katalogen. Denne kan være ulik på andre enheter.",
+    "Oldest First": "Eldste fyrst",
+    "Optional descriptive label for the folder. Can be different on each device.": "Valfri merkelapp på katalogen. Denne kan vera ulik på andre einingar.",
     "Options": "Val",
     "Out of Sync": "Ikkje synkronisert",
     "Out of Sync Items": "Ikkje-synkroniserte element",
     "Outgoing Rate Limit (KiB/s)": "Utgåande hastigheitsgrense (KiB/s)",
     "Override Changes": "Overstyr endringar",
     "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": "Plasseringa av mappa på datamaskinen. Vert oppretta om ho ikkje finst. Krøllstrekteiknet (~) kan brukast som forkorting for",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Plasseringa for lagra versjonar (la denne vera tom for å bruka standard .stversions-mappa i mappa).",
+    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Plasseringa for lagra versjonar (la denne vera tom for å bruka standardmappa .stversions i mappa).",
     "Pause": "Stans",
     "Paused": "Stansa",
-    "Please consult the release notes before performing a major upgrade.": "Sjå \"release notes\" før ei hovudoppgradering vert utført.",
-    "Please set a GUI Authentication User and Password in the Settings dialog.": "Ver vennleg å set ein GUI brukar og passord i Innstillingar-dialogen.",
+    "Please consult the release notes before performing a major upgrade.": "Sjå utgjevingsmerknadene før ei hovudoppgradering vert utført.",
+    "Please set a GUI Authentication User and Password in the Settings dialog.": "Ver vennleg å laga ein GUI-brukar og eit passord i Innstillingar-dialogen.",
     "Please wait": "Gjer vel og vent",
     "Preview": "Førehandsvisning",
     "Preview Usage Report": "Førehandsvis bruksrapporten",
@@ -136,10 +139,10 @@
     "RAM Utilization": "Minnebruk",
     "Random": "Tilfeldig",
     "Reduced by ignore patterns": "Reduser med utelatelsesmønster",
-    "Release Notes": "Utgivingsnotat",
-    "Remote Devices": "Eksterne Einingar",
+    "Release Notes": "Utgjevingsnotat",
+    "Remote Devices": "Eksterne einingar",
     "Remove": "Fjern",
-    "Required identifier for the folder. Must be the same on all cluster devices.": "Påkrevd identifikator for katalogen. Denne må være lik på alle einingar i samme klynge.",
+    "Required identifier for the folder. Must be the same on all cluster devices.": "Påkravd identifikator for katalogen. Denne må vera lik på alle einingane i same klynge.",
     "Rescan": "Skann På Ny",
     "Rescan All": "Skann alle på nytt",
     "Rescan Interval": "Skanneintervall",
@@ -149,10 +152,12 @@
     "Resume": "Start",
     "Reused": "Gjenbrukt",
     "Save": "Lagre",
-    "Scan Time Remaining": "Gjenståande Skannetid",
+    "Scan Time Remaining": "Gjenståande skannetid",
     "Scanning": "Skannar",
     "Select the devices to share this folder with.": "Vel einingane du vil dela denne mappa med.",
     "Select the folders to share with this device.": "Vel mappene du vil dela med denne eininga.",
+    "Send & Receive": "Sende og motta",
+    "Send Only": "Bare sende",
     "Settings": "Innstillingar",
     "Share": "Del",
     "Share Folder": "Del mappe",
@@ -182,35 +187,35 @@
     "Syncthing is restarting.": "Syncthing startar på ny.",
     "Syncthing is upgrading.": "Syncthing oppgraderer.",
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing ser ut til å vera nede, eller så er det eit problem med nettilkoplinga di. Prøvar på ny …",
-    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing ser ut til å ha støtt på eit problem under behandling av din førespurnad. Vær vennleg å oppfrisk nettlesaren eller start Syncthing på nytt om problemet vedvarer.",
-    "The Syncthing admin interface is configured to allow remote access without a password.": "Syncthing sitt administreringsgrensesnitt er sett opp til å tillate ekstern tilgang uten passord.",
+    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing ser ut til å ha støtt på eit problem under behandling av førespurnaden din. Ver vennleg å oppfriska nettlesaren eller starta Syncthing på nytt om problemet varer ved.",
+    "The Syncthing admin interface is configured to allow remote access without a password.": "Administreringsgrensesnittet til Syncthing er sett opp til å tillata ekstern tilgang utan passord.",
     "The aggregated statistics are publicly available at the URL below.": "Samla statistikk er opent tilgjengeleg på URL-en nedanfor.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Instillingane har blitt lagra men ikkje aktivert. Syncthing må starta på ny for å aktivera dei nye instillingane.",
     "The device ID cannot be blank.": "Eining ID kan ikkje vera tom.",
-    "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Einings-IDen som skal oppgis her kan hentast fram via \"Rediger > Vis ID\"-dialogboksen på den andre eininga. Mellomrom og bindestrek er valfritt (blir ignorert).",
-    "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.": "Den krypterte bruksrapporten vert send dagleg. Han vert nytta til å spora vanlege plattformer, mappestorleikar og programutgåvene. Om datasettet endrar seg, vil dette meldingsvindauget dukka opp att og du vil verta beden om å godkjenna det.",
+    "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Einings-ID-en som skal oppgjevast her kan hentast fram via menyvalet «Handlingar > Vis ID» på den andre eininga. Mellomrom og bindestrek er valfritt (blir ignorert).",
+    "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.": "Den krypterte bruksrapporten vert send dagleg. Han vert nytta til å spora vanlege plattformer, mappestorleikar og programutgåvene. Om datasettet endrar seg, vil dette meldingsvindauget dukka opp att, og du vil verta beden om å godkjenna det.",
     "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.": "Einings-ID-en er ikkje gyldig. Han må vera på 52 eller 56 teikn og vera samansett av bokstavar og tal med valfrie mellomrom og bindestrekar.",
     "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "Den første kommandolinjeparameteren er mappebana og den andre syner den relative bana i mappa.",
     "The folder ID cannot be blank.": "Mappe ID kan ikkje vera tom.",
     "The folder ID must be unique.": "Mappe ID må vera unik.",
     "The folder path cannot be blank.": "Mappeplasseringa kan ikkje vera tom.",
     "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.": "Desse intervalla vert nytta: den fyrste timen vert ei utgåve lagra kvart 30. sekund, den fyrste dagen vert ei utgåve lagra kvar time, dei fyrste 30 dagane vert ei utgåve lagra kvar dag, og inntil høgaste alderen vert ei utgåve lagra kvar veke.",
-    "The following items could not be synchronized.": "Fyljande filer kunne ikkje synkroniserast.",
+    "The following items could not be synchronized.": "Fylgjande filer kunne ikkje synkroniserast.",
     "The maximum age must be a number and cannot be blank.": "Maksimal levetid må vera eit tal og kan ikkje vera tomt.",
-    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Høgaste tidsrom å behalda ei utgåve (i dagar, set til 0 for å behalda versjonane for alltid).",
-    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Nødvendig ledig diskplass må vere eit tal mellom 0 og 100.",
-    "The number of days must be a number and cannot be blank.": "Tal på dagar må ver eit tal og kan ikkje vera tomt.",
+    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Høgaste tidsrom å spara på ei utgåve (i dagar; set til 0 for å spara på versjonane for alltid).",
+    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "Nødvendig ledig diskplass må vera eit tal mellom 0 og 100.",
+    "The number of days must be a number and cannot be blank.": "Tal på dagar må vera eit tal, og kan ikkje vera tomt.",
     "The number of days to keep files in the trash can. Zero means forever.": "Antall dagar å behalda filer i søppelkorga. Null betyr for alltid.",
     "The number of old versions to keep, per file.": "Tal på gamle versjonar ein skal behalda, per fil.",
     "The number of versions must be a number and cannot be blank.": "Tal på versjonar må vera eit tal og kan ikkje vera tomt.",
     "The path cannot be blank.": "Bana kan ikkje vera tom.",
-    "The rate limit must be a non-negative number (0: no limit)": "Hastigheitsgrensa må ver eit positivt tall (0: ingen grensa)",
+    "The rate limit must be a non-negative number (0: no limit)": "Hastigheitsgrensa må vera eit positivt tall (0: inga grense)",
     "The rescan interval must be a non-negative number of seconds.": "Talet på sekund i skanneintervallet kan ikkje vera negativt.",
     "They are retried automatically and will be synced when the error is resolved.": "Desse vil bli prøvd på nytt automatisk og vil bli synkronisert når feilen har blitt utbetra.",
-    "This Device": "Denne Eininga",
-    "This can easily give hackers access to read and change any files on your computer.": "Dette kan lett gje dataekspertar tilgang til å lese og endre vilkårlege filer på denne maskina.",
+    "This Device": "Denne eininga",
+    "This can easily give hackers access to read and change any files on your computer.": "Dette kan lett gje datasnokar tilgang til å lesa og endra vilkårlege filer på denne maskina.",
     "This is a major version upgrade.": "Dette er ei hovudoppgradering",
-    "Trash Can File Versioning": "Papirkorg filutgåvehandtering",
+    "Trash Can File Versioning": "Papirkorg-filutgåvehandtering",
     "Unknown": "Ukjent",
     "Unshared": "Ikkje delt",
     "Unused": "Ubrukt",
@@ -225,16 +230,16 @@
     "Version": "Versjon",
     "Versions Path": "Utgåvebane",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Utgåver vert automatisk sletta når maksimal levetid er nådd eller når det høgaste tillate talet på filer innan eit intervall vert overskride.",
-    "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Åtvaring, denne banen er ei undermappe av den eksisterande mappa \"{{otherFolder}}\".",
-    "When adding a new device, keep in mind that this device must be added on the other side too.": "Hugs at når ei ny eining vert lagt til må ho òg leggjast til på andre sida.",
+    "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Åtvaring, denne bana er ei undermappe av den eksisterande mappa «{{otherFolder}}».",
+    "When adding a new device, keep in mind that this device must be added on the other side too.": "Hugs at når ei ny eining vert lagt til, må ho òg leggjast til på andre sida.",
     "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.": "Hugs at når ei ny mappe vert lagt til, vert mappe-ID-en brukt til å binda saman mappene mellom einingane. Det er skilnad på store og små bokstavar, så ID-ane må vera identiske på alle einingane.",
     "Yes": "Ja",
     "You must keep at least one version.": "Du må behalda minst ein versjon.",
     "days": "dagar",
-    "directories": "kataloger",
+    "directories": "katalogar",
     "files": "filer",
     "full documentation": "all dokumentasjon",
     "items": "element",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} ønskjer å dela mappa \"{{folder}}\".",
-    "{%device%} wants to share folder \"{%folderlabel%}\" ({%folder%}).": "{{device}} ønskjer å dela mappa \"{{folderLabel}}\" ({{folder}})."
+    "{%device%} wants to share folder \"{%folderlabel%}\" ({%folder%}).": "{{device}} ønskjer å dela mappa «{{folderLabel}}» ({{folder}})."
 }

gui/default/assets/lang/lang-pl.json

@@ -52,6 +52,8 @@
     "Downloaded": "Pobrane",
     "Downloading": "Pobieranie",
     "Edit": "Edytuj",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Edytowanie",
     "Enable NAT traversal": "Włącz trawersowanie NAT",
     "Enable Relaying": "Włącz przekazywanie",
@@ -95,6 +97,7 @@
     "Last Scan": "Czas ostatniego skanu",
     "Last seen": "Ostatnio widziany",
     "Later": "Później",
+    "Latest Change": "Latest Change",
     "Listeners": "Nasłuchujący",
     "Local Discovery": "Lokalne odnajdywanie",
     "Local State": "Status lokalny",
@@ -153,6 +156,8 @@
     "Scanning": "Skanowanie",
     "Select the devices to share this folder with.": "Wybierz urządzenie, któremu udostępnić folder.",
     "Select the folders to share with this device.": "Wybierz foldery do współdzielenia z tym urządzeniem.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Ustawienia",
     "Share": "Udostępnij",
     "Share Folder": "Udostępnij folder",

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

@@ -31,7 +31,7 @@
     "Command": "Comando",
     "Comment, when used at the start of a line": "Comentário, se usado no início de uma linha",
     "Compression": "Compressão",
-    "Configured": "Configured",
+    "Configured": "Configurado",
     "Connection Error": "Erro de conexão",
     "Connection Type": "Tipo da conexão",
     "Copied from elsewhere": "Copiado de outro lugar",
@@ -45,13 +45,15 @@
     "Device Name": "Nome do dispositivo",
     "Devices": "Dispositivos",
     "Disconnected": "Desconectado",
-    "Discovered": "Discovered",
+    "Discovered": "Descoberto",
     "Discovery": "Descoberta",
     "Documentation": "Documentação",
     "Download Rate": "Velocidade de recepção",
     "Downloaded": "Recebido",
     "Downloading": "Recebendo",
     "Edit": "Editar",
+    "Edit Device": "Editar dispositivo",
+    "Edit Folder": "Editar pasta",
     "Editing": "Editando",
     "Enable NAT traversal": "Habilitar NAT",
     "Enable Relaying": "Habilitar retransmissão",
@@ -95,6 +97,7 @@
     "Last Scan": "Última verificação",
     "Last seen": "Visto por último em",
     "Later": "Depois",
+    "Latest Change": "Última mudança",
     "Listeners": "Escutadores",
     "Local Discovery": "Descoberta local",
     "Local State": "Estado local",
@@ -135,7 +138,7 @@
     "Quick guide to supported patterns": "Guia rápido dos padrões suportados",
     "RAM Utilization": "Uso de RAM",
     "Random": "Aleatória",
-    "Reduced by ignore patterns": "Reduced by ignore patterns",
+    "Reduced by ignore patterns": "Reduzido por filtros",
     "Release Notes": "Notas de lançamento",
     "Remote Devices": "Dispositivos remotos",
     "Remove": "Remover",
@@ -153,6 +156,8 @@
     "Scanning": "Verificando",
     "Select the devices to share this folder with.": "Selecione os dispositivos com os quais esta pasta será compartilhada.",
     "Select the folders to share with this device.": "Selecione as pastas a serem compartilhadas com este dispositivo.",
+    "Send & Receive": "Enviar e receber",
+    "Send Only": "Somente enviar",
     "Settings": "Configurações",
     "Share": "Compartilhar",
     "Share Folder": "Compartilhar pasta",
@@ -231,8 +236,8 @@
     "Yes": "Sim",
     "You must keep at least one version.": "Você deve manter pelo menos uma versão.",
     "days": "dias",
-    "directories": "directories",
-    "files": "files",
+    "directories": "diretórios",
+    "files": "arquivos",
     "full documentation": "documentação completa",
     "items": "itens",
     "{%device%} wants to share folder \"{%folder%}\".": "{{device}} quer compartilhar a pasta \"{{folder}}\".",

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

@@ -52,6 +52,8 @@
     "Downloaded": "Recebido",
     "Downloading": "Recebendo",
     "Edit": "Editar",
+    "Edit Device": "Editar dispositivo",
+    "Edit Folder": "Editar pasta",
     "Editing": "Editando",
     "Enable NAT traversal": "Activar travessia de NAT",
     "Enable Relaying": "Permitir retransmissão",
@@ -95,6 +97,7 @@
     "Last Scan": "Última verificação",
     "Last seen": "Última vez que foi verificado",
     "Later": "Mais tarde",
+    "Latest Change": "Última alteração",
     "Listeners": "Auscultadores",
     "Local Discovery": "Pesquisa local",
     "Local State": "Estado local",
@@ -153,6 +156,8 @@
     "Scanning": "Verificando",
     "Select the devices to share this folder with.": "Seleccione os dispositivos com os quais vai partilhar esta pasta.",
     "Select the folders to share with this device.": "Seleccione as pastas a partilhar com este dispositivo.",
+    "Send & Receive": "Enviar e receber",
+    "Send Only": "Enviar apenas",
     "Settings": "Configurações",
     "Share": "Partilhar",
     "Share Folder": "Partilhar pasta",

gui/default/assets/lang/lang-ru.json

@@ -52,6 +52,8 @@
     "Downloaded": "Загружено",
     "Downloading": "Загрузка",
     "Edit": "Редактировать",
+    "Edit Device": "Редактирование устройства",
+    "Edit Folder": "Редактирование папки",
     "Editing": "Редактирование",
     "Enable NAT traversal": "Включить NAT traversal",
     "Enable Relaying": "Включить релеи",
@@ -95,6 +97,7 @@
     "Last Scan": "Последнее сканирование",
     "Last seen": "Был доступен",
     "Later": "Позже",
+    "Latest Change": "Последнее изменение",
     "Listeners": "Прослушиватель",
     "Local Discovery": "Локальное обнаружение",
     "Local State": "Локальное состояние",
@@ -153,6 +156,8 @@
     "Scanning": "Сканирование",
     "Select the devices to share this folder with.": "Выберите устройства, для которых будет доступна эта папка.",
     "Select the folders to share with this device.": "Выберите папки, которые будут доступны этому устройству.",
+    "Send & Receive": "Отправить и получить",
+    "Send Only": "Только отправить",
     "Settings": "Настройки",
     "Share": "Предоставить доступ",
     "Share Folder": "Предоставить доступ к папке",

gui/default/assets/lang/lang-sv.json

@@ -52,6 +52,8 @@
     "Downloaded": "Hämtat",
     "Downloading": "Hämtar",
     "Edit": "Redigera",
+    "Edit Device": "Redigera enhet",
+    "Edit Folder": "Redigera katalog",
     "Editing": "Redigerar",
     "Enable NAT traversal": "Aktivera NAT traversering",
     "Enable Relaying": "Aktivera reläa",
@@ -95,6 +97,7 @@
     "Last Scan": "Senaste skanning",
     "Last seen": "Senast sedd",
     "Later": "Senare",
+    "Latest Change": "Senaste ändring",
     "Listeners": "Lyssnare",
     "Local Discovery": "Lokal annonsering",
     "Local State": "Lokal status",
@@ -153,6 +156,8 @@
     "Scanning": "Skannar",
     "Select the devices to share this folder with.": "Ange enheterna som den här katalogen ska delas med.",
     "Select the folders to share with this device.": "Välj kataloger att dela med den här enheten.",
+    "Send & Receive": "Skicka & ta emot",
+    "Send Only": "Skicka endast",
     "Settings": "Inställningar",
     "Share": "Dela",
     "Share Folder": "Dela katalog",
@@ -181,14 +186,14 @@
     "Syncthing includes the following software or portions thereof:": "Syncthing innehåller följande mjukvarupaket eller delar av dem:",
     "Syncthing is restarting.": "Syncthing startar om.",
     "Syncthing is upgrading.": "Syncthing uppgraderas.",
-    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing verkar avstängd, eller finns det problem med din Internetanslutning. Försöker igen...",
+    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing verkar avstängd eller så är det problem med din Internetanslutning. Försöker igen...",
     "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing verkar ha drabbats av ett problem med behandlingen av din begäran. Uppdatera sidan eller starta om Syncthing om problemet kvarstår.",
     "The Syncthing admin interface is configured to allow remote access without a password.": "Syncthing administratör gränssnittet är konfigurerat för att tillåta fjärrtillträde utan ett lösenord.",
-    "The aggregated statistics are publicly available at the URL below.": "Den aggregerade statistiken är offentligt tillgängliga på webbadressen nedan.",
+    "The aggregated statistics are publicly available at the URL below.": "Den aggregerade statistiken är offentligt tillgänglig på webbadressen nedan.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Konfigurationen har sparats men inte aktiverats. Syncthing måste startas om för att aktivera den nya konfigurationen.",
     "The device ID cannot be blank.": "Enhet-ID kan inte vara tomt.",
     "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Enhet-ID som behövs här kan du hitta i \"Åtgärder > Visa ID\"-dialogrutan på den andra enheten. Mellanrum och bindestreck är valfria (ignoreras).",
-    "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.": "Den krypterade användarstatistiken skickas dagligen. Den används för att spåra vanliga plattformar, katalogstorlekar och versioner. Om datan som rapporteras ändras så kommer du att bli tillfrågad igen.",
+    "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.": "Den krypterade användarstatistiken skickas dagligen. Den används för att spåra vanliga plattformar, katalogstorlekar och versioner. Om datat som rapporteras ändras så kommer du att bli tillfrågad igen.",
     "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.": "Det inmatade enhet-ID verkar inte vara korrekt. Det ska vara en 52 eller 56 teckensträng bestående av siffror och bokstäver, eventuellt med mellanrum och bindestreck.",
     "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "Den första kommandoparametern är sökvägen till mappen och den andra parametern är den relativa sökvägen i mappen.",
     "The folder ID cannot be blank.": "Katalog-ID får inte vara tomt.",
@@ -215,7 +220,7 @@
     "Unshared": "Inte delad",
     "Unused": "Oanvänd",
     "Up to Date": "Uppdaterad",
-    "Updated": "Uppdaterad",
+    "Updated": "Uppdaterade",
     "Upgrade": "Uppgradering",
     "Upgrade To {%version%}": "Uppgradera till {{version}}",
     "Upgrading": "Uppgraderar",
@@ -223,8 +228,8 @@
     "Uptime": "Drifttid",
     "Use HTTPS for GUI": "Använd HTTPS för GUI",
     "Version": "Version",
-    "Versions Path": "Versioner sökväg",
-    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Versioner tas bort automatiskt när de är äldre än den maximala åldersgränsen eller överstiger frekvensen i sitt interval.",
+    "Versions Path": "Sökväg för versioner",
+    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Versioner tas bort automatiskt när de är äldre än den maximala åldersgränsen eller överstiger frekvensen i intervallet.",
     "Warning, this path is a subdirectory of an existing folder \"{%otherFolder%}\".": "Varning, denna sökväg är en underkatalog till en befintlig katalog \"{{otherFolder}}\".",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "När du lägger till en ny enhet, kom ihåg att den här enheten måste läggas till på den andra enheten också.",
     "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 knyter ihop kataloger mellan olika enheter. De skiftlägeskänsliga och måste matcha precis mellan alla enheter.",

gui/default/assets/lang/lang-tr.json

@@ -31,7 +31,7 @@
     "Command": "Komut",
     "Comment, when used at the start of a line": "Satır başında kullanıldığında açıklama özelliği taşır",
     "Compression": "Sıkıştırma",
-    "Configured": "Configured",
+    "Configured": "Yapılandırıldı",
     "Connection Error": "Bağlantı hatası",
     "Connection Type": "Bağlantı Türü",
     "Copied from elsewhere": "Başka bir yerden kopyalanmış",
@@ -52,6 +52,8 @@
     "Downloaded": "İndirilmiş",
     "Downloading": "İndiriliyor",
     "Edit": "Düzenle",
+    "Edit Device": "Aygıtı Düzenle",
+    "Edit Folder": "Klasörü Düzenle",
     "Editing": "Düzenleniyor",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Enable Relaying",
@@ -95,6 +97,7 @@
     "Last Scan": "Son Tarama",
     "Last seen": "Son görülme",
     "Later": "Sonra",
+    "Latest Change": "Son Değişim",
     "Listeners": "Dinleyiciler",
     "Local Discovery": "Yerel Discovery",
     "Local State": "Yerel Durum",
@@ -139,7 +142,7 @@
     "Release Notes": "Sürüm Notları",
     "Remote Devices": "Uzak Aygıtlar",
     "Remove": "Kaldır",
-    "Required identifier for the folder. Must be the same on all cluster devices.": "Required identifier for the folder. Must be the same on all cluster devices.",
+    "Required identifier for the folder. Must be the same on all cluster devices.": "Klasör için tanımlayıcı gereklidir. Tüm küme cihazlarda aynı olmalıdır.",
     "Rescan": "Tekrar Tara",
     "Rescan All": "Tümünü Tekrar Tara",
     "Rescan Interval": "Tarama Aralığı",
@@ -153,6 +156,8 @@
     "Scanning": "Taranıyor",
     "Select the devices to share this folder with.": "Bu klasörü paylaşacağın aygıtları seç.",
     "Select the folders to share with this device.": "Bu aygıtla paylaşılacak klasörleri seç.",
+    "Send & Receive": "Gönder & Al",
+    "Send Only": "Yalnızca Gönder",
     "Settings": "Ayarlar",
     "Share": "Paylaş",
     "Share Folder": "Paylaşım Klasörü",
@@ -184,7 +189,7 @@
     "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing uygulaması çökmüş olabilir, veya internet bağlantınızda bir sorun var. Tekrar deniyor....",
     "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing isteminizi işleme alırken bir sorunla karşılaştı. Lütfen sayfanızı yenileyin veya sorun devam ediyorsa Syncthing'i yeniden başlatın.",
     "The Syncthing admin interface is configured to allow remote access without a password.": "Syncthing yönetici arayüzü parolasız olarak uzaktan erişime izin verilecek şekilde yapılandırıldı.",
-    "The aggregated statistics are publicly available at the URL below.": "The aggregated statistics are publicly available at the URL below.",
+    "The aggregated statistics are publicly available at the URL below.": "Toplanan istatistikler halka açık biçimde aşağıdaki adrestedir.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Yapılandırma kaydedildi ancak etkinleştirilmedi. Etkinleştirmek için Syncthing yeniden başlatılmalı.",
     "The device ID cannot be blank.": "Aygıt ID boş olamaz.",
     "The device ID to enter here can be found in the \"Actions > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Buraya girilecek olan aygıt ID'si diğer aygıtlarda, \"Eylemler > ID Göster\" penceresinde bulunabilir. Boşluklar ve çizgiler isteğe bağlıdır (yoksayılmış).",

gui/default/assets/lang/lang-uk.json

@@ -52,6 +52,8 @@
     "Downloaded": "Завантажено",
     "Downloading": "Завантаження",
     "Edit": "Редагувати",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Редагування",
     "Enable NAT traversal": "Увімкнути NAT traversal",
     "Enable Relaying": "Увімкнути ретрансляцію (relaying)",
@@ -95,6 +97,7 @@
     "Last Scan": "Останнє сканування",
     "Last seen": "З’являвся останній раз",
     "Later": "Пізніше",
+    "Latest Change": "Latest Change",
     "Listeners": "Приймачі (TCP & Relay)",
     "Local Discovery": "Локальне виявлення (LAN)",
     "Local State": "Локальний статус",
@@ -153,6 +156,8 @@
     "Scanning": "Сканування",
     "Select the devices to share this folder with.": "Оберіть пристрої, які матимуть доступ до цієї директорії.",
     "Select the folders to share with this device.": "Оберіть директорії до яких матиме доступ цей пристрій.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Налаштування",
     "Share": "Розповсюдити ",
     "Share Folder": "Розповсюдити каталог",

gui/default/assets/lang/lang-vi.json

@@ -52,6 +52,8 @@
     "Downloaded": "Đã tải xuống",
     "Downloading": "Đang tải xuống",
     "Edit": "Chỉnh sửa",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "Đang ch.sửa",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "Bật chế độ ch.tiếp",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "Thấy lần cuối",
     "Later": "Để sau",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "Dò tìm cục bộ",
     "Local State": "Tr.thái cục bộ",
@@ -153,6 +156,8 @@
     "Scanning": "Đang quét",
     "Select the devices to share this folder with.": "Chọn các thiết bị để chia sẻ thư mục này.",
     "Select the folders to share with this device.": "Chọn các thư mục để chia sẻ với thiết bị này.",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "Cài đặt",
     "Share": "Chia sẻ",
     "Share Folder": "Chia sẻ th.mục",

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

@@ -52,6 +52,8 @@
     "Downloaded": "已下载",
     "Downloading": "下载中",
     "Edit": "选项",
+    "Edit Device": "编辑设备",
+    "Edit Folder": "编辑文件夹",
     "Editing": "正在编辑",
     "Enable NAT traversal": "启用 NAT 遍历",
     "Enable Relaying": "开启中继",
@@ -95,6 +97,7 @@
     "Last Scan": "最后扫描",
     "Last seen": "最后可见",
     "Later": "稍后",
+    "Latest Change": "最后更改",
     "Listeners": "侦听程序",
     "Local Discovery": "在局域网上寻找设备",
     "Local State": "本地状态",
@@ -153,6 +156,8 @@
     "Scanning": "扫描中",
     "Select the devices to share this folder with.": "选择将本文件夹共享给哪些设备",
     "Select the folders to share with this device.": "选择与该设备共享的文件夹。",
+    "Send & Receive": "发送与接收",
+    "Send Only": "仅发送",
     "Settings": "设置",
     "Share": "共享",
     "Share Folder": "共享文件夹",

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

@@ -52,6 +52,8 @@
     "Downloaded": "已下載",
     "Downloading": "正在下載",
     "Edit": "編輯",
+    "Edit Device": "Edit Device",
+    "Edit Folder": "Edit Folder",
     "Editing": "正在編輯",
     "Enable NAT traversal": "Enable NAT traversal",
     "Enable Relaying": "啟用中繼",
@@ -95,6 +97,7 @@
     "Last Scan": "Last Scan",
     "Last seen": "最後發現時間",
     "Later": "稍後",
+    "Latest Change": "Latest Change",
     "Listeners": "Listeners",
     "Local Discovery": "本機探索",
     "Local State": "本機狀態",
@@ -153,6 +156,8 @@
     "Scanning": "正在掃描",
     "Select the devices to share this folder with.": "選擇要共享這個資料夾的裝置。",
     "Select the folders to share with this device.": "選擇要共享這個資料夾的裝置。",
+    "Send & Receive": "Send & Receive",
+    "Send Only": "Send Only",
     "Settings": "設定",
     "Share": "分享",
     "Share Folder": "分享資料夾",

gui/default/index.html

@@ -271,6 +271,7 @@
                   <span class="fa fa-fw" ng-class="[folder.type == 'readonly' ? 'fa-lock' : 'fa-folder']"></span>
                 </div>
                 <div class="panel-status pull-right text-{{folderClass(folder)}}" ng-switch="folderStatus(folder)">
+                  <span ng-switch-when="paused"><span class="hidden-xs" translate>Paused</span><span class="visible-xs">&#9724;</span></span>
                   <span ng-switch-when="unknown"><span class="hidden-xs" translate>Unknown</span><span class="visible-xs">&#9724;</span></span>
                   <span ng-switch-when="unshared"><span class="hidden-xs" translate>Unshared</span><span class="visible-xs">&#9724;</span></span>
                   <span ng-switch-when="stopped"><span class="hidden-xs" translate>Stopped</span><span class="visible-xs">&#9724;</span></span>
@@ -307,11 +308,11 @@
                         <span tooltip data-original-title="{{folder.path}}">{{folder.path}}</span>
                       </td>
                     </tr>
-                    <tr ng-if="model[folder.id].invalid || model[folder.id].error">
+                    <tr ng-if="!folder.paused && (model[folder.id].invalid || model[folder.id].error)">
                       <th><span class="fa fa-fw fa-exclamation-triangle"></span>&nbsp;<span translate>Error</span></th>
                       <td class="text-right">{{model[folder.id].invalid || model[folder.id].error}}</td>
                     </tr>
-                    <tr>
+                    <tr ng-if="!folder.paused">
                       <th><span class="fa fa-fw fa-globe"></span>&nbsp;<span translate>Global State</span></th>
                       <td class="text-right">
                         <span tooltip data-original-title="{{model[folder.id].globalFiles | alwaysNumber}} {{'files' | translate}}, {{model[folder.id].globalDirectories | alwaysNumber}} {{'directories' | translate}}, ~{{model[folder.id].globalBytes | binary}}B">
@@ -321,7 +322,7 @@
                         </span>
                       </td>
                     </tr>
-                    <tr>
+                    <tr ng-if="!folder.paused">
                       <th><span class="fa fa-fw fa-home"></span>&nbsp;<span translate>Local State</span></th>
                       <td class="text-right">
                         <span tooltip data-original-title="{{model[folder.id].localFiles | alwaysNumber}} {{'files' | translate}}, {{model[folder.id].localDirectories | alwaysNumber}} {{'directories' | translate}}, ~{{model[folder.id].localBytes | binary}}B">
@@ -354,7 +355,7 @@
                     <tr ng-if="folder.type != 'readwrite'">
                       <th><span class="fa fa-fw fa-lock"></span>&nbsp;<span translate>Folder Type</span></th>
                       <td class="text-right">
-                        <span ng-if="folder.type == 'readonly'" translate>Master</span>
+                        <span ng-if="folder.type == 'readonly'" translate>Send Only</span>
                         <span ng-if="folder.type != 'readonly'">{{ folder.type.charAt(0).toUpperCase() + folder.type.slice(1) }}</span>
                       </td>
                     </tr>
@@ -417,6 +418,12 @@
                   <span class="fa fa-arrow-circle-up"></span>&nbsp;<span translate>Override Changes</span>
                 </button>
                 <span class="pull-right">
+                  <button ng-if="!folder.paused" type="button" class="btn btn-sm btn-default" ng-click="setFolderPause(folder.id, true)">
+                    <span class="fa fa-pause"></span>&nbsp;<span translate>Pause</span>
+                  </button>
+                  <button ng-if="folder.paused" type="button" class="btn btn-sm btn-default" ng-click="setFolderPause(folder.id, false)">
+                    <span class="fa fa-play"></span>&nbsp;<span translate>Resume</span>
+                  </button>
                   <button type="button" class="btn btn-sm btn-default" ng-click="rescanFolder(folder.id)" ng-show="['idle', 'stopped', 'unshared'].indexOf(folderStatus(folder)) > -1">
                     <span class="fa fa-refresh"></span>&nbsp;<span translate>Rescan</span>
                   </button>
@@ -579,6 +586,10 @@
                       <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="deviceCfg.introducedBy">
+                      <th><span class="fa fa-fw fa-meh-o"></span>&nbsp;<span translate>Introduced By</span></th>
+                      <td translate class="text-right">{{ deviceName(findDevice(deviceCfg.introducedBy)) || deviceCfg.introducedBy.substring(0, 5) }}</td>
+                    </tr>
                     <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>
@@ -597,10 +608,10 @@
               </div>
               <div class="panel-footer">
                 <span class="pull-right">
-                  <button ng-if="!connections[deviceCfg.deviceID].paused" type="button" class="btn btn-sm btn-default" ng-click="pauseDevice(deviceCfg.deviceID)">
+                  <button ng-if="!deviceCfg.paused" type="button" class="btn btn-sm btn-default" ng-click="setDevicePause(deviceCfg.deviceID, true)">
                     <span class="fa fa-pause"></span>&nbsp;<span translate>Pause</span>
                   </button>
-                  <button ng-if="connections[deviceCfg.deviceID].paused" type="button" class="btn btn-sm btn-default" ng-click="resumeDevice(deviceCfg.deviceID)">
+                  <button ng-if="deviceCfg.paused" type="button" class="btn btn-sm btn-default" ng-click="setDevicePause(deviceCfg.deviceID, false)">
                     <span class="fa fa-play"></span>&nbsp;<span translate>Resume</span>
                   </button>
                   <button type="button" class="btn btn-sm btn-default" ng-click="editDevice(deviceCfg)">
@@ -613,9 +624,14 @@
           </div>
         </div>
         <div class="form-group">
-          <button type="button" class="btn btn-sm btn-default pull-right" ng-click="addDevice()">
-            <span class="fa fa-plus"></span>&nbsp;<span translate>Add Remote Device</span>
-          </button>
+          <span class="pull-right">
+            <button type="button" class="btn btn-sm btn-default" ng-click="globalChanges()">
+              <span class="fa fa-fw fa-history"></span>&nbsp;<span translate>Global Changes</span>
+            </button>
+            <button type="button" class="btn btn-sm btn-default" ng-click="addDevice()">
+              <span class="fa fa-plus"></span>&nbsp;<span translate>Add Remote Device</span>
+            </button>
+          </span>
           <div class="clearfix"></div>
         </div>
       </div>
@@ -647,6 +663,7 @@
   <ng-include src="'syncthing/core/shutdownDialogView.html'"></ng-include>
   <ng-include src="'syncthing/device/idqrModalView.html'"></ng-include>
   <ng-include src="'syncthing/device/editDeviceModalView.html'"></ng-include>
+  <ng-include src="'syncthing/device/globalChangesModalView.html'"></ng-include>
   <ng-include src="'syncthing/folder/editFolderModalView.html'"></ng-include>
   <ng-include src="'syncthing/folder/editIgnoresModalView.html'"></ng-include>
   <ng-include src="'syncthing/settings/settingsModalView.html'"></ng-include>

gui/default/syncthing/core/aboutModalView.html

@@ -12,7 +12,7 @@
     <p translate>Copyright &copy; 2014-2016 the following Contributors:</p>
     <div class="row">
       <div class="col-md-12" id="contributor-list">
-Jakob Borg, Audrius Butkevicius, Alexander Graf, Anderson Mesquita, Antony Male, Ben Schulz, Caleb Callaway, Daniel Harte, Lars K.W. Gohlke, Lode Hoste, Michael Ploujnikov, Philippe Schommers, Ryan Sullivan, Sergey Mishin, Stefan Tatschner, Aaron Bieber, Adam Piggott, Alessandro G., Alexandre Viau, Andrew Dunham, Andrey D, Antoine Lamielle, Arthur Axel fREW Schmidt, Bart De Vries, Ben Curthoys, Ben Sidhom, Benny Ng, Brandon Philips, Brendan Long, Brian R. Becker, Carsten Hagemann, Cathryne Linenweaver, Cedric Staniewski, Chris Howie, Chris Joel, Colin Kennedy, Daniel Bergmann, Daniel Martí, David Rimmer, Denis A., Dennis Wilson, Dominik Heidler, Elias Jarlebring, Emil Hessman, Erik Meitner, Federico Castagnini, Felix Ableitner, Felix Unterpaintner, Francois-Xavier Gsell, Frank Isemann, Gilli Sigurdsson, Jaakko Hannikainen, Jacek Szafarkiewicz, Jake Peterson, James Patterson, Jaroslav Malec, Jens Diemer, Jochen Voss, Johan Vromans, Karol Różycki, Kelong Cong, Ken'ichi Kamada, Kevin Allen, Kevin White, Jr., Laurent Etiemble, Leo Arias, Lord Landon Agahnim, Majed Abdulaziz, Marc Laporte, Marc Pujol, Marcin Dziadus, Mateusz Naściszewski, Matt Burke, Max Schulze, Michael Jephcote, Michael Tilli, Nate Morrison, Pascal Jungblut, Peter Hoeg, Phill Luby, Piotr Bejda, Roman Zaynetdinov, Scott Klupfel, Simon Frei, Stefan Kuntz, Tim Abell, Tim Howes, Tobias Nygren, Tomas Cerveny, Tully Robinson, Tyler Brazier, Unrud, Veeti Paananen, Victor Buinsky, Vil Brekin, William A. Kennington III, Wulf Weich, Xavier O., Yannic A.
+Jakob Borg, Audrius Butkevicius, Alexander Graf, Anderson Mesquita, Antony Male, Ben Schulz, Caleb Callaway, Daniel Harte, Lars K.W. Gohlke, Lode Hoste, Michael Ploujnikov, Philippe Schommers, Ryan Sullivan, Sergey Mishin, Stefan Tatschner, Aaron Bieber, Adam Piggott, Alessandro G., Alexandre Viau, Andrew Dunham, Andrey D, Antoine Lamielle, Arthur Axel fREW Schmidt, Bart De Vries, Ben Curthoys, Ben Sidhom, Benny Ng, Brandon Philips, Brendan Long, Brian R. Becker, Carsten Hagemann, Cathryne Linenweaver, Cedric Staniewski, Chris Howie, Chris Joel, Colin Kennedy, Daniel Bergmann, Daniel Martí, David Rimmer, Denis A., Dennis Wilson, Dominik Heidler, Elias Jarlebring, Emil Hessman, Erik Meitner, Federico Castagnini, Felix Ableitner, Felix Unterpaintner, Francois-Xavier Gsell, Frank Isemann, Gilli Sigurdsson, Heiko Zuerker, Jaakko Hannikainen, Jacek Szafarkiewicz, Jake Peterson, James Patterson, Jaroslav Malec, Jens Diemer, Jochen Voss, Johan Vromans, Karol Różycki, Kelong Cong, Ken'ichi Kamada, Kevin Allen, Kevin White, Jr., Laurent Etiemble, Leo Arias, Lord Landon Agahnim, Majed Abdulaziz, Marc Laporte, Marc Pujol, Marcin Dziadus, Mateusz Naściszewski, Matt Burke, Max Schulze, Michael Jephcote, Michael Tilli, Nate Morrison, Pascal Jungblut, Peter Hoeg, Phill Luby, Piotr Bejda, Roman Zaynetdinov, Scott Klupfel, Simon Frei, Stefan Kuntz, Tim Abell, Tim Howes, Tobias Nygren, Tomas Cerveny, Tully Robinson, Tyler Brazier, Unrud, Veeti Paananen, Victor Buinsky, Vil Brekin, William A. Kennington III, Wulf Weich, Xavier O., Yannic A.
     </div>
     </div>
     <hr/>

gui/default/syncthing/core/eventService.js

@@ -33,11 +33,9 @@ angular.module('syncthing.core')
                 lastID = lastEvent.id;
             }
 
-            $timeout(function () {
-                $http.get(urlbase + '/events?since=' + lastID)
-                    .success(successFn)
-                    .error(errorFn);
-            }, 500, false);
+            $http.get(urlbase + '/events?since=' + lastID)
+                .success(successFn)
+                .error(errorFn);
         }
 
         function errorFn (dummy) {
@@ -79,6 +77,8 @@ angular.module('syncthing.core')
             STATE_CHANGED:        'StateChanged',   // Emitted when a folder changes state
             FOLDER_ERRORS:        'FolderErrors',   // Emitted when a folder has errors preventing a full sync
             FOLDER_SCAN_PROGRESS: 'FolderScanProgress',   // Emitted every ScanProgressIntervalS seconds, indicating how far into the scan it is at.
+            FOLDER_PAUSED:        'FolderPaused',   // Emitted when a folder is paused
+            FOLDER_RESUMED:       'FolderResumed',   // Emitted when a folder is resumed
 
             start: function() {
                 $http.get(urlbase + '/events?limit=1')

gui/default/syncthing/core/syncthingController.js

@@ -51,6 +51,7 @@ angular.module('syncthing.core')
         $scope.failedPageSize = 10;
         $scope.scanProgress = {};
         $scope.themes = [];
+        $scope.globalChangeEvents = {};
 
         $scope.localStateTotal = {
             bytes: 0,
@@ -186,6 +187,7 @@ angular.module('syncthing.core')
 
         $scope.$on(Events.LOCAL_INDEX_UPDATED, function (event, arg) {
             refreshFolderStats();
+            refreshGlobalChanges();
         });
 
         $scope.$on(Events.DEVICE_DISCONNECTED, function (event, arg) {
@@ -233,14 +235,6 @@ angular.module('syncthing.core')
             $scope.deviceRejections[arg.data.device] = arg;
         });
 
-        $scope.$on(Events.DEVICE_PAUSED, function (event, arg) {
-            $scope.connections[arg.data.device].paused = true;
-        });
-
-        $scope.$on(Events.DEVICE_RESUMED, function (event, arg) {
-            $scope.connections[arg.data.device].paused = false;
-        });
-
         $scope.$on(Events.FOLDER_REJECTED, function (event, arg) {
             $scope.folderRejections[arg.data.folder + "-" + arg.data.device] = arg;
         });
@@ -629,6 +623,15 @@ angular.module('syncthing.core')
             }).error($scope.emitHTTPError);
         }, 2500);
 
+        var refreshGlobalChanges = debounce(function () {
+            $http.get(urlbase + "/events/disk?limit=15").success(function (data) {
+                data = data.reverse();
+                $scope.globalChangeEvents = data;
+
+                console.log("refreshGlobalChanges", data);
+            }).error($scope.emitHTTPError);
+        }, 2500);
+
         $scope.refresh = function () {
             refreshSystem();
             refreshDiscoveryCache();
@@ -641,6 +644,10 @@ angular.module('syncthing.core')
                 return 'unknown';
             }
 
+            if (folderCfg.paused) {
+                return 'paused';
+            }
+
             // after restart syncthing process state may be empty
             if (!$scope.model[folderCfg.id].state) {
                 return 'unknown';
@@ -674,6 +681,9 @@ angular.module('syncthing.core')
             if (status === 'idle') {
                 return 'success';
             }
+            if (status == 'paused') {
+                return 'default';
+            }
             if (status === 'syncing' || status === 'scanning') {
                 return 'primary';
             }
@@ -790,7 +800,7 @@ angular.module('syncthing.core')
                 return 'unknown';
             }
 
-            if ($scope.connections[deviceCfg.deviceID].paused) {
+            if (deviceCfg.paused) {
                 return 'paused';
             }
 
@@ -816,7 +826,7 @@ angular.module('syncthing.core')
                 return 'info';
             }
 
-            if ($scope.connections[deviceCfg.deviceID].paused) {
+            if (deviceCfg.paused) {
                 return 'default';
             }
 
@@ -912,6 +922,16 @@ angular.module('syncthing.core')
             return '';
         };
 
+        $scope.friendlyNameFromShort = function (shortID) {
+            var matches = $scope.devices.filter(function (n) {
+                return n.deviceID.substr(0, 7) === shortID;
+            });
+            if (matches.length !== 1) {
+                return shortID;
+            }
+            return matches[0].name;
+        };
+
         $scope.findDevice = function (deviceID) {
             var matches = $scope.devices.filter(function (n) {
                 return n.deviceID === deviceID;
@@ -943,12 +963,23 @@ angular.module('syncthing.core')
             return device.deviceID.substr(0, 6);
         };
 
-        $scope.pauseDevice = function (device) {
-            $http.post(urlbase + "/system/pause?device=" + device);
+        $scope.setDevicePause = function (device, pause) {
+            $scope.devices.forEach(function (cfg) {
+                if (cfg.deviceID == device) {
+                    cfg.paused = pause;
+                }
+            });
+            $scope.config.devices = $scope.devices;
+            $scope.saveConfig();
         };
 
-        $scope.resumeDevice = function (device) {
-            $http.post(urlbase + "/system/resume?device=" + device);
+        $scope.setFolderPause = function (folder, pause) {
+            var cfg = $scope.folders[folder];
+            if (cfg) {
+                cfg.paused = pause;
+                $scope.config.folders = folderList($scope.folders);
+                $scope.saveConfig();
+            }
         };
 
         $scope.editSettings = function () {
@@ -1268,7 +1299,11 @@ angular.module('syncthing.core')
                     $scope.folderEditor = form;
                     break;
             }
-        }
+        };
+
+        $scope.globalChanges = function () {
+            $('#globalChanges').modal();
+        };
 
         $scope.editFolder = function (folderCfg) {
             $scope.currentFolder = angular.copy(folderCfg);

gui/default/syncthing/device/globalChangesModalView.html

@@ -0,0 +1,27 @@
+<style> th, td { padding: 6px; } </style>
+<modal id="globalChanges" status="default" icon="{{'history'}}" heading="{{'Global Changes' | translate}}" large="yes" closeable="yes">
+    <div class="modal-body">
+        <table>
+          <tr>
+            <th translate>Device</th>
+            <th translate>Action</th>
+            <th translate>Type</th>
+            <th translate>Path</th>
+            <th translate>Time</th>
+          </tr>
+          <tr ng-repeat="changeEvent in globalChangeEvents">
+            <td ng-if="changeEvent.data.modifiedBy">{{friendlyNameFromShort(changeEvent.data.modifiedBy)}}</td>
+            <td ng-if="!changeEvent.data.modifiedBy"><span translate>Unknown</span></td>
+            <td>{{changeEvent.data.action}}</td>
+            <td>{{changeEvent.data.type}}</td>
+            <td>{{changeEvent.data.path}}</td>
+            <td>{{changeEvent.time | date:'medium'}}</td>
+          </tr>
+        </table>
+    </div>
+    <div class="modal-footer">
+        <button type="button" class="btn btn-default btn-sm" data-dismiss="modal">
+        <span class="fa fa-times"></span>&nbsp;<span translate>Close</span>
+        </button>
+    </div>
+</model>

gui/default/syncthing/folder/editFolderModalView.html

@@ -84,10 +84,10 @@
           <div class="col-md-6">
             <div class="form-group">
               <label translate>Folder Type</label>
-              &nbsp;<a href="https://docs.syncthing.net/users/foldermaster.html" target="_blank"><span class="fa fa-book"></span>&nbsp;<span translate>Help</span></a>
+              &nbsp;<a href="https://docs.syncthing.net/users/foldertypes.html" target="_blank"><span class="fa fa-book"></span>&nbsp;<span translate>Help</span></a>
               <select class="form-control" ng-model="currentFolder.type">
-                <option value="readwrite" translate>Normal</option>
-                <option value="readonly" translate>Master</option>
+                <option value="readwrite" translate>Send &amp; Receive</option>
+                <option value="readonly" translate>Send Only</option>
               </select>
               <p ng-if="currentFolder.type == 'readonly'" translate class="help-block">Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.</p>
             </div>

jenkins/build-linux.bash

@@ -55,3 +55,15 @@ go run build.go -goarch armhf snap
 go run build.go -goarch arm64 snap
 
 mv *.snap "$WORKSPACE"
+
+if [[ -d /usr/local/oldgo ]]; then
+	echo
+	echo Building with minimum supported Go version
+	export GOROOT=/usr/local/oldgo
+	export PATH="$GOROOT/bin:$PATH"
+	go version
+	echo
+
+	rm -rf "$GOPATH/pkg"
+	go run build.go install all # only compile, don't run lints and stuff
+fi

lib/config/config.go

@@ -407,9 +407,9 @@ func convertV13V14(cfg *Configuration) {
 
 	for i, fcfg := range cfg.Folders {
 		if fcfg.DeprecatedReadOnly {
-			cfg.Folders[i].Type = FolderTypeReadOnly
+			cfg.Folders[i].Type = FolderTypeSendOnly
 		} else {
-			cfg.Folders[i].Type = FolderTypeReadWrite
+			cfg.Folders[i].Type = FolderTypeSendReceive
 		}
 		cfg.Folders[i].DeprecatedReadOnly = false
 	}

lib/config/config_test.go

@@ -96,7 +96,7 @@ func TestDeviceConfig(t *testing.T) {
 				ID:              "test",
 				RawPath:         "testdata",
 				Devices:         []FolderDeviceConfiguration{{DeviceID: device1}, {DeviceID: device4}},
-				Type:            FolderTypeReadOnly,
+				Type:            FolderTypeSendOnly,
 				RescanIntervalS: 600,
 				Copiers:         0,
 				Pullers:         0,

lib/config/deviceconfiguration.go

@@ -17,6 +17,7 @@ type DeviceConfiguration struct {
 	Introducer               bool                 `xml:"introducer,attr" json:"introducer"`
 	SkipIntroductionRemovals bool                 `xml:"skipIntroductionRemovals,attr" json:"skipIntroductionRemovals"`
 	IntroducedBy             protocol.DeviceID    `xml:"introducedBy,attr" json:"introducedBy"`
+	Paused                   bool                 `xml:"paused" json:"paused"`
 }
 
 func NewDeviceConfiguration(id protocol.DeviceID, name string) DeviceConfiguration {

lib/config/folderconfiguration.go

@@ -40,6 +40,8 @@ type FolderConfiguration struct {
 	DisableSparseFiles    bool                        `xml:"disableSparseFiles" json:"disableSparseFiles"`
 	DisableTempIndexes    bool                        `xml:"disableTempIndexes" json:"disableTempIndexes"`
 	Fsync                 bool                        `xml:"fsync" json:"fsync"`
+	DisableWeakHash       bool                        `xml:"disableWeakHash" json:"disableWeakHash"`
+	Paused                bool                        `xml:"paused" json:"paused"`
 
 	cachedPath string
 
@@ -98,13 +100,13 @@ func (f *FolderConfiguration) CreateMarker() error {
 
 func (f *FolderConfiguration) HasMarker() bool {
 	_, err := os.Stat(filepath.Join(f.Path(), ".stfolder"))
-	if err != nil {
-		return false
-	}
-	return true
+	return err == nil
 }
 
 func (f FolderConfiguration) Description() string {
+	if f.Label == "" {
+		return f.ID
+	}
 	return fmt.Sprintf("%q (%s)", f.Label, f.ID)
 }
 

lib/config/foldertype.go

@@ -9,15 +9,15 @@ package config
 type FolderType int
 
 const (
-	FolderTypeReadWrite FolderType = iota // default is readwrite
-	FolderTypeReadOnly
+	FolderTypeSendReceive FolderType = iota // default is sendreceive
+	FolderTypeSendOnly
 )
 
 func (t FolderType) String() string {
 	switch t {
-	case FolderTypeReadWrite:
+	case FolderTypeSendReceive:
 		return "readwrite"
-	case FolderTypeReadOnly:
+	case FolderTypeSendOnly:
 		return "readonly"
 	default:
 		return "unknown"
@@ -30,12 +30,12 @@ func (t FolderType) MarshalText() ([]byte, error) {
 
 func (t *FolderType) UnmarshalText(bs []byte) error {
 	switch string(bs) {
-	case "readwrite":
-		*t = FolderTypeReadWrite
-	case "readonly":
-		*t = FolderTypeReadOnly
+	case "readwrite", "sendreceive":
+		*t = FolderTypeSendReceive
+	case "readonly", "sendonly":
+		*t = FolderTypeSendOnly
 	default:
-		*t = FolderTypeReadWrite
+		*t = FolderTypeSendReceive
 	}
 	return nil
 }

lib/config/optionsconfiguration.go

@@ -41,6 +41,7 @@ type OptionsConfiguration struct {
 	OverwriteRemoteDevNames bool     `xml:"overwriteRemoteDeviceNamesOnConnect" json:"overwriteRemoteDeviceNamesOnConnect" default:"false"`
 	TempIndexMinBlocks      int      `xml:"tempIndexMinBlocks" json:"tempIndexMinBlocks" default:"10"`
 	UnackedNotificationIDs  []string `xml:"unackedNotificationID" json:"unackedNotificationIDs"`
+	TrafficClass            int      `xml:"trafficClass" json:"trafficClass"`
 
 	DeprecatedUPnPEnabled  bool     `xml:"upnpEnabled,omitempty" json:"-"`
 	DeprecatedUPnPLeaseM   int      `xml:"upnpLeaseMinutes,omitempty" json:"-"`

lib/config/wrapper.go

@@ -323,6 +323,18 @@ func (w *Wrapper) Device(id protocol.DeviceID) (DeviceConfiguration, bool) {
 	return DeviceConfiguration{}, false
 }
 
+// Folder returns the configuration for the given folder and an "ok" bool.
+func (w *Wrapper) Folder(id string) (FolderConfiguration, bool) {
+	w.mut.Lock()
+	defer w.mut.Unlock()
+	for _, folder := range w.cfg.Folders {
+		if folder.ID == id {
+			return folder, true
+		}
+	}
+	return FolderConfiguration{}, false
+}
+
 // Save writes the configuration to disk, and generates a ConfigSaved event.
 func (w *Wrapper) Save() error {
 	fd, err := osutil.CreateAtomic(w.path)

lib/connections/connections_test.go

@@ -0,0 +1,26 @@
+// Copyright (C) 2016 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 connections
+
+import "testing"
+import "net/url"
+
+func TestFixupPort(t *testing.T) {
+	cases := [][2]string{
+		{"tcp://1.2.3.4:5", "tcp://1.2.3.4:5"},
+		{"tcp://1.2.3.4:", "tcp://1.2.3.4:22000"},
+		{"tcp://1.2.3.4", "tcp://1.2.3.4:22000"},
+	}
+
+	for _, tc := range cases {
+		u0, _ := url.Parse(tc[0])
+		u1 := fixupPort(u0).String()
+		if u1 != tc[1] {
+			t.Errorf("fixupPort(%q) => %q, expected %q", tc[0], u1, tc[1])
+		}
+	}
+}

lib/connections/empty_test.go

@@ -1,10 +0,0 @@
-// Copyright (C) 2016 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/.
-
-// The existence of this file means we get 0% test coverage rather than no
-// test coverage at all. Remove when implementing an actual test.
-
-package connections

lib/connections/relay_dial.go

@@ -45,6 +45,11 @@ func (d *relayDialer) Dial(id protocol.DeviceID, uri *url.URL) (internalConn, er
 		return internalConn{}, err
 	}
 
+	err = dialer.SetTrafficClass(conn, d.cfg.Options().TrafficClass)
+	if err != nil {
+		l.Debugf("failed to set traffic class: %s", err)
+	}
+
 	var tc *tls.Conn
 	if inv.ServerSocket {
 		tc = tls.Server(conn, d.tlsCfg)

lib/connections/relay_listen.go

@@ -29,6 +29,7 @@ type relayListener struct {
 	onAddressesChangedNotifier
 
 	uri     *url.URL
+	cfg     *config.Wrapper
 	tlsCfg  *tls.Config
 	conns   chan internalConn
 	factory listenerFactory
@@ -79,6 +80,11 @@ func (t *relayListener) Serve() {
 				l.Infoln(err)
 			}
 
+			err = dialer.SetTrafficClass(conn, t.cfg.Options().TrafficClass)
+			if err != nil {
+				l.Debugf("failed to set traffic class: %s", err)
+			}
+
 			var tc *tls.Conn
 			if inv.ServerSocket {
 				tc = tls.Server(conn, t.tlsCfg)
@@ -170,6 +176,7 @@ type relayListenerFactory struct{}
 func (f *relayListenerFactory) New(uri *url.URL, cfg *config.Wrapper, tlsCfg *tls.Config, conns chan internalConn, natService *nat.Service) genericListener {
 	return &relayListener{
 		uri:     uri,
+		cfg:     cfg,
 		tlsCfg:  tlsCfg,
 		conns:   conns,
 		factory: f,

lib/connections/service.go

@@ -41,6 +41,32 @@ const (
 	tlsHandshakeTimeout  = 10 * time.Second
 )
 
+// From go/src/crypto/tls/cipher_suites.go
+var tlsCipherSuiteNames = map[uint16]string{
+	0x0005: "TLS_RSA_WITH_RC4_128_SHA",
+	0x000a: "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
+	0x002f: "TLS_RSA_WITH_AES_128_CBC_SHA",
+	0x0035: "TLS_RSA_WITH_AES_256_CBC_SHA",
+	0x003c: "TLS_RSA_WITH_AES_128_CBC_SHA256",
+	0x009c: "TLS_RSA_WITH_AES_128_GCM_SHA256",
+	0x009d: "TLS_RSA_WITH_AES_256_GCM_SHA384",
+	0xc007: "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
+	0xc009: "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+	0xc00a: "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
+	0xc011: "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
+	0xc012: "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
+	0xc013: "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
+	0xc014: "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
+	0xc023: "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+	0xc027: "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+	0xc02f: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+	0xc02b: "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+	0xc030: "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+	0xc02c: "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+	0xcca8: "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
+	0xcca9: "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
+}
+
 // Service listens and dials all configured unconnected devices, via supported
 // dialers. Successful connections are handed to the model.
 type Service struct {
@@ -272,8 +298,7 @@ next:
 		protoConn := protocol.NewConnection(remoteID, rd, wr, s.model, name, deviceCfg.Compression)
 		modelConn := completeConn{c, protoConn}
 
-		l.Infof("Established secure connection to %s at %s", remoteID, name)
-		l.Debugf("cipher suite: %04X in lan: %t", c.ConnectionState().CipherSuite, !limit)
+		l.Infof("Established secure connection to %s at %s (%s)", remoteID, name, tlsCipherSuiteNames[c.ConnectionState().CipherSuite])
 
 		s.model.AddConnection(modelConn, hello)
 		s.curConMut.Lock()
@@ -318,8 +343,7 @@ func (s *Service) connect() {
 				continue
 			}
 
-			paused := s.model.IsPaused(deviceID)
-			if paused {
+			if deviceCfg.Paused {
 				continue
 			}
 

lib/connections/structs.go

@@ -116,7 +116,6 @@ type Model interface {
 	protocol.Model
 	AddConnection(conn Connection, hello protocol.HelloResult)
 	ConnectedTo(remoteID protocol.DeviceID) bool
-	IsPaused(remoteID protocol.DeviceID) bool
 	OnHello(protocol.DeviceID, net.Addr, protocol.HelloResult) error
 	GetHello(protocol.DeviceID) protocol.HelloIntf
 }

lib/connections/tcp_dial.go

@@ -39,6 +39,16 @@ func (d *tcpDialer) Dial(id protocol.DeviceID, uri *url.URL) (internalConn, erro
 		return internalConn{}, err
 	}
 
+	err = dialer.SetTCPOptions(conn)
+	if err != nil {
+		l.Infoln(err)
+	}
+
+	err = dialer.SetTrafficClass(conn, d.cfg.Options().TrafficClass)
+	if err != nil {
+		l.Debugf("failed to set traffic class: %s", err)
+	}
+
 	tc := tls.Client(conn, d.tlsCfg)
 	err = tlsTimedHandshake(tc)
 	if err != nil {

lib/connections/tcp_listen.go

@@ -30,6 +30,7 @@ type tcpListener struct {
 	onAddressesChangedNotifier
 
 	uri     *url.URL
+	cfg     *config.Wrapper
 	tlsCfg  *tls.Config
 	stop    chan struct{}
 	conns   chan internalConn
@@ -107,6 +108,11 @@ func (t *tcpListener) Serve() {
 			l.Infoln(err)
 		}
 
+		err = dialer.SetTrafficClass(conn, t.cfg.Options().TrafficClass)
+		if err != nil {
+			l.Debugf("failed to set traffic class: %s", err)
+		}
+
 		tc := tls.Server(conn, t.tlsCfg)
 		err = tlsTimedHandshake(tc)
 		if err != nil {
@@ -176,6 +182,7 @@ type tcpListenerFactory struct{}
 func (f *tcpListenerFactory) New(uri *url.URL, cfg *config.Wrapper, tlsCfg *tls.Config, conns chan internalConn, natService *nat.Service) genericListener {
 	return &tcpListener{
 		uri:        fixupPort(uri),
+		cfg:        cfg,
 		tlsCfg:     tlsCfg,
 		conns:      conns,
 		natService: natService,
@@ -192,7 +199,7 @@ func fixupPort(uri *url.URL) *url.URL {
 	copyURI := *uri
 
 	host, port, err := net.SplitHostPort(uri.Host)
-	if err != nil && strings.HasPrefix(err.Error(), "missing port") {
+	if err != nil && strings.Contains(err.Error(), "missing port") {
 		// addr is on the form "1.2.3.4"
 		copyURI.Host = net.JoinHostPort(uri.Host, "22000")
 	} else if err == nil && port == "" {

lib/db/blockmap.go

@@ -209,7 +209,7 @@ func blockKeyInto(o, hash []byte, folder uint32, file string) []byte {
 	}
 	o[0] = KeyTypeBlock
 	binary.BigEndian.PutUint32(o[keyPrefixLen:], folder)
-	copy(o[keyPrefixLen+keyFolderLen:], []byte(hash))
+	copy(o[keyPrefixLen+keyFolderLen:], hash)
 	copy(o[keyPrefixLen+keyFolderLen+keyHashLen:], []byte(file))
 	return o
 }

lib/db/blockmap_test.go

@@ -58,10 +58,7 @@ func setup() (*Instance, *BlockFinder) {
 func dbEmpty(db *Instance) bool {
 	iter := db.NewIterator(util.BytesPrefix([]byte{KeyTypeBlock}), nil)
 	defer iter.Release()
-	if iter.Next() {
-		return false
-	}
-	return true
+	return !iter.Next()
 }
 
 func TestBlockMapAddUpdateWipe(t *testing.T) {

lib/db/concurrency_test.go

@@ -4,7 +4,8 @@
 // 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 ignore // this  is a really tedious test for an old issue
+// this  is a really tedious test for an old issue
+// +build ignore
 
 package db_test
 

lib/db/leveldb_dbinstance.go

@@ -635,7 +635,7 @@ func (db *Instance) deviceKeyInto(k []byte, folder, device, file []byte) []byte
 	k[0] = KeyTypeDevice
 	binary.BigEndian.PutUint32(k[keyPrefixLen:], db.folderIdx.ID(folder))
 	binary.BigEndian.PutUint32(k[keyPrefixLen+keyFolderLen:], db.deviceIdx.ID(device))
-	copy(k[keyPrefixLen+keyFolderLen+keyDeviceLen:], []byte(file))
+	copy(k[keyPrefixLen+keyFolderLen+keyDeviceLen:], file)
 	return k[:reqLen]
 }
 
@@ -670,7 +670,7 @@ func (db *Instance) globalKey(folder, file []byte) []byte {
 	k := make([]byte, keyPrefixLen+keyFolderLen+len(file))
 	k[0] = KeyTypeGlobal
 	binary.BigEndian.PutUint32(k[keyPrefixLen:], db.folderIdx.ID(folder))
-	copy(k[keyPrefixLen+keyFolderLen:], []byte(file))
+	copy(k[keyPrefixLen+keyFolderLen:], file)
 	return k
 }
 

lib/db/structs.pb.go

@@ -58,6 +58,7 @@ type FileInfoTruncated struct {
 	Permissions   uint32                `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions,omitempty"`
 	ModifiedS     int64                 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modified_s,omitempty"`
 	ModifiedNs    int32                 `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3" json:"modified_ns,omitempty"`
+	ModifiedBy    protocol.ShortID      `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=protocol.ShortID" json:"modified_by"`
 	Deleted       bool                  `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted,omitempty"`
 	Invalid       bool                  `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid,omitempty"`
 	NoPermissions bool                  `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"no_permissions,omitempty"`
@@ -226,6 +227,11 @@ func (m *FileInfoTruncated) MarshalTo(data []byte) (int, error) {
 		i++
 		i = encodeVarintStructs(data, i, uint64(m.ModifiedNs))
 	}
+	if m.ModifiedBy != 0 {
+		data[i] = 0x60
+		i++
+		i = encodeVarintStructs(data, i, uint64(m.ModifiedBy))
+	}
 	if len(m.SymlinkTarget) > 0 {
 		data[i] = 0x8a
 		i++
@@ -324,6 +330,9 @@ func (m *FileInfoTruncated) ProtoSize() (n int) {
 	if m.ModifiedNs != 0 {
 		n += 1 + sovStructs(uint64(m.ModifiedNs))
 	}
+	if m.ModifiedBy != 0 {
+		n += 1 + sovStructs(uint64(m.ModifiedBy))
+	}
 	l = len(m.SymlinkTarget)
 	if l > 0 {
 		n += 2 + l + sovStructs(uint64(l))
@@ -798,6 +807,25 @@ func (m *FileInfoTruncated) Unmarshal(data []byte) error {
 					break
 				}
 			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedBy", wireType)
+			}
+			m.ModifiedBy = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStructs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.ModifiedBy |= (protocol.ShortID(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		case 17:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field SymlinkTarget", wireType)

lib/db/structs.proto

@@ -28,6 +28,7 @@ message FileInfoTruncated {
     uint32                permissions    = 4;
     int64                 modified_s     = 5;
     int32                 modified_ns    = 11;
+    uint64                modified_by    = 12 [(gogoproto.customtype) = "protocol.ShortID", (gogoproto.nullable) = false];
     bool                  deleted        = 6;
     bool                  invalid        = 7;
     bool                  no_permissions = 8;

lib/dialer/public.go

@@ -10,6 +10,9 @@ import (
 	"fmt"
 	"net"
 	"time"
+
+	"golang.org/x/net/ipv4"
+	"golang.org/x/net/ipv6"
 )
 
 // Dial tries dialing via proxy if a proxy is configured, and falls back to
@@ -75,3 +78,22 @@ func SetTCPOptions(conn net.Conn) error {
 		return fmt.Errorf("unknown connection type %T", conn)
 	}
 }
+
+func SetTrafficClass(conn net.Conn, class int) error {
+	switch conn := conn.(type) {
+	case *net.TCPConn:
+		e1 := ipv4.NewConn(conn).SetTOS(class)
+		e2 := ipv6.NewConn(conn).SetTrafficClass(class)
+
+		if e1 != nil {
+			return e1
+		}
+		return e2
+
+	case dialerConn:
+		return SetTrafficClass(conn.Conn, class)
+
+	default:
+		return fmt.Errorf("unknown connection type %T", conn)
+	}
+}

lib/discover/local.go

@@ -51,7 +51,7 @@ func NewLocal(id protocol.DeviceID, addr string, addrList AddressLister) (Finder
 		Supervisor:      suture.NewSimple("local"),
 		myID:            id,
 		addrList:        addrList,
-		localBcastTick:  time.Tick(BroadcastInterval),
+		localBcastTick:  time.NewTicker(BroadcastInterval).C,
 		forcedBcastTick: make(chan time.Time),
 		localBcastStart: time.Now(),
 		cache:           newCache(),

lib/events/events.go

@@ -29,6 +29,7 @@ const (
 	DevicePaused
 	DeviceResumed
 	LocalChangeDetected
+	RemoteChangeDetected
 	LocalIndexUpdated
 	RemoteIndexUpdated
 	ItemStarted
@@ -42,6 +43,8 @@ const (
 	FolderCompletion
 	FolderErrors
 	FolderScanProgress
+	FolderPaused
+	FolderResumed
 	ListenAddressesChanged
 	LoginAttempt
 
@@ -68,6 +71,8 @@ func (t EventType) String() string {
 		return "DeviceRejected"
 	case LocalChangeDetected:
 		return "LocalChangeDetected"
+	case RemoteChangeDetected:
+		return "RemoteChangeDetected"
 	case LocalIndexUpdated:
 		return "LocalIndexUpdated"
 	case RemoteIndexUpdated:
@@ -98,6 +103,10 @@ func (t EventType) String() string {
 		return "DeviceResumed"
 	case FolderScanProgress:
 		return "FolderScanProgress"
+	case FolderPaused:
+		return "FolderPaused"
+	case FolderResumed:
+		return "FolderResumed"
 	case ListenAddressesChanged:
 		return "ListenAddressesChanged"
 	case LoginAttempt:

lib/events/events_test.go

@@ -247,22 +247,23 @@ func BenchmarkBufferedSub(b *testing.B) {
 	}
 
 	// Receive the events
-	done := make(chan struct{})
+	done := make(chan error)
 	go func() {
-		defer close(done)
 		recv := 0
 		var evs []Event
 		for i := 0; i < b.N; {
 			evs = bs.Since(recv, evs[:0])
 			for _, ev := range evs {
 				if ev.GlobalID != recv+1 {
-					b.Fatal("skipped event", ev.GlobalID, recv)
+					done <- fmt.Errorf("skipped event %v %v", ev.GlobalID, recv)
+					return
 				}
 				recv = ev.GlobalID
 				coord <- struct{}{}
 			}
 			i += len(evs)
 		}
+		done <- nil
 	}()
 
 	// Send the events
@@ -276,7 +277,9 @@ func BenchmarkBufferedSub(b *testing.B) {
 		<-coord
 	}
 
-	<-done
+	if err := <-done; err != nil {
+		b.Error(err)
+	}
 	b.ReportAllocs()
 }
 

lib/ignore/cache_test.go

@@ -15,7 +15,7 @@ func TestCache(t *testing.T) {
 	c := newCache(nil)
 
 	res, ok := c.get("nonexistent")
-	if res.IsIgnored() || res.IsDeletable() || ok != false {
+	if res.IsIgnored() || res.IsDeletable() || ok {
 		t.Errorf("res %v, ok %v for nonexistent item", res, ok)
 	}
 
@@ -25,12 +25,12 @@ func TestCache(t *testing.T) {
 	c.set("false", 0)
 
 	res, ok = c.get("true")
-	if !res.IsIgnored() || !res.IsDeletable() || ok != true {
+	if !res.IsIgnored() || !res.IsDeletable() || !ok {
 		t.Errorf("res %v, ok %v for true item", res, ok)
 	}
 
 	res, ok = c.get("false")
-	if res.IsIgnored() || res.IsDeletable() || ok != true {
+	if res.IsIgnored() || res.IsDeletable() || !ok {
 		t.Errorf("res %v, ok %v for false item", res, ok)
 	}
 
@@ -41,12 +41,12 @@ func TestCache(t *testing.T) {
 	// Same values should exist
 
 	res, ok = c.get("true")
-	if !res.IsIgnored() || !res.IsDeletable() || ok != true {
+	if !res.IsIgnored() || !res.IsDeletable() || !ok {
 		t.Errorf("res %v, ok %v for true item", res, ok)
 	}
 
 	res, ok = c.get("false")
-	if res.IsIgnored() || res.IsDeletable() || ok != true {
+	if res.IsIgnored() || res.IsDeletable() || !ok {
 		t.Errorf("res %v, ok %v for false item", res, ok)
 	}
 

lib/model/model.go

@@ -35,6 +35,7 @@ import (
 	"github.com/syncthing/syncthing/lib/stats"
 	"github.com/syncthing/syncthing/lib/symlinks"
 	"github.com/syncthing/syncthing/lib/sync"
+	"github.com/syncthing/syncthing/lib/upgrade"
 	"github.com/syncthing/syncthing/lib/versioner"
 	"github.com/thejerf/suture"
 )
@@ -92,12 +93,12 @@ type Model struct {
 	folderStatRefs     map[string]*stats.FolderStatisticsReference            // folder -> statsRef
 	fmut               sync.RWMutex                                           // protects the above
 
-	conn            map[protocol.DeviceID]connections.Connection
-	closed          map[protocol.DeviceID]chan struct{}
-	helloMessages   map[protocol.DeviceID]protocol.HelloResult
-	devicePaused    map[protocol.DeviceID]bool
-	deviceDownloads map[protocol.DeviceID]*deviceDownloadState
-	pmut            sync.RWMutex // protects the above
+	conn                map[protocol.DeviceID]connections.Connection
+	closed              map[protocol.DeviceID]chan struct{}
+	helloMessages       map[protocol.DeviceID]protocol.HelloResult
+	deviceDownloads     map[protocol.DeviceID]*deviceDownloadState
+	remotePausedFolders map[protocol.DeviceID][]string // deviceID -> folders
+	pmut                sync.RWMutex                   // protects the above
 }
 
 type folderFactory func(*Model, config.FolderConfiguration, versioner.Versioner, *fs.MtimeFS) service
@@ -133,33 +134,33 @@ func NewModel(cfg *config.Wrapper, id protocol.DeviceID, deviceName, clientName,
 				l.Debugln(line)
 			},
 		}),
-		cfg:                cfg,
-		db:                 ldb,
-		finder:             db.NewBlockFinder(ldb),
-		progressEmitter:    NewProgressEmitter(cfg),
-		id:                 id,
-		shortID:            id.Short(),
-		cacheIgnoredFiles:  cfg.Options().CacheIgnoredFiles,
-		protectedFiles:     protectedFiles,
-		deviceName:         deviceName,
-		clientName:         clientName,
-		clientVersion:      clientVersion,
-		folderCfgs:         make(map[string]config.FolderConfiguration),
-		folderFiles:        make(map[string]*db.FileSet),
-		folderDevices:      make(folderDeviceSet),
-		deviceFolders:      make(map[protocol.DeviceID][]string),
-		deviceStatRefs:     make(map[protocol.DeviceID]*stats.DeviceStatisticsReference),
-		folderIgnores:      make(map[string]*ignore.Matcher),
-		folderRunners:      make(map[string]service),
-		folderRunnerTokens: make(map[string][]suture.ServiceToken),
-		folderStatRefs:     make(map[string]*stats.FolderStatisticsReference),
-		conn:               make(map[protocol.DeviceID]connections.Connection),
-		closed:             make(map[protocol.DeviceID]chan struct{}),
-		helloMessages:      make(map[protocol.DeviceID]protocol.HelloResult),
-		devicePaused:       make(map[protocol.DeviceID]bool),
-		deviceDownloads:    make(map[protocol.DeviceID]*deviceDownloadState),
-		fmut:               sync.NewRWMutex(),
-		pmut:               sync.NewRWMutex(),
+		cfg:                 cfg,
+		db:                  ldb,
+		finder:              db.NewBlockFinder(ldb),
+		progressEmitter:     NewProgressEmitter(cfg),
+		id:                  id,
+		shortID:             id.Short(),
+		cacheIgnoredFiles:   cfg.Options().CacheIgnoredFiles,
+		protectedFiles:      protectedFiles,
+		deviceName:          deviceName,
+		clientName:          clientName,
+		clientVersion:       clientVersion,
+		folderCfgs:          make(map[string]config.FolderConfiguration),
+		folderFiles:         make(map[string]*db.FileSet),
+		folderDevices:       make(folderDeviceSet),
+		deviceFolders:       make(map[protocol.DeviceID][]string),
+		deviceStatRefs:      make(map[protocol.DeviceID]*stats.DeviceStatisticsReference),
+		folderIgnores:       make(map[string]*ignore.Matcher),
+		folderRunners:       make(map[string]service),
+		folderRunnerTokens:  make(map[string][]suture.ServiceToken),
+		folderStatRefs:      make(map[string]*stats.FolderStatisticsReference),
+		conn:                make(map[protocol.DeviceID]connections.Connection),
+		closed:              make(map[protocol.DeviceID]chan struct{}),
+		helloMessages:       make(map[protocol.DeviceID]protocol.HelloResult),
+		deviceDownloads:     make(map[protocol.DeviceID]*deviceDownloadState),
+		remotePausedFolders: make(map[protocol.DeviceID][]string),
+		fmut:                sync.NewRWMutex(),
+		pmut:                sync.NewRWMutex(),
 	}
 	if cfg.Options().ProgressUpdateIntervalS > -1 {
 		go m.progressEmitter.Serve()
@@ -182,10 +183,13 @@ func (m *Model) StartDeadlockDetector(timeout time.Duration) {
 // StartFolder constructs the folder service and starts it.
 func (m *Model) StartFolder(folder string) {
 	m.fmut.Lock()
+	m.pmut.Lock()
 	folderType := m.startFolderLocked(folder)
+	folderCfg := m.folderCfgs[folder]
+	m.pmut.Unlock()
 	m.fmut.Unlock()
 
-	l.Infoln("Ready to synchronize", folder, fmt.Sprintf("(%s)", folderType))
+	l.Infof("Ready to synchronize %s (%s)", folderCfg.Description(), folderType)
 }
 
 func (m *Model) startFolderLocked(folder string) config.FolderType {
@@ -216,6 +220,11 @@ func (m *Model) startFolderLocked(folder string) config.FolderType {
 		}
 	}
 
+	// Close connections to affected devices
+	for _, id := range cfg.DeviceIDs() {
+		m.closeLocked(id)
+	}
+
 	v, ok := fs.Sequence(protocol.LocalDeviceID), true
 	indexHasFiles := ok && v > 0
 	if !indexHasFiles {
@@ -264,7 +273,7 @@ func (m *Model) startFolderLocked(folder string) config.FolderType {
 }
 
 func (m *Model) warnAboutOverwritingProtectedFiles(folder string) {
-	if m.folderCfgs[folder].Type == config.FolderTypeReadOnly {
+	if m.folderCfgs[folder].Type == config.FolderTypeSendOnly {
 		return
 	}
 
@@ -364,13 +373,16 @@ func (m *Model) RestartFolder(cfg config.FolderConfiguration) {
 	m.pmut.Lock()
 
 	m.tearDownFolderLocked(cfg.ID)
-	m.addFolderLocked(cfg)
-	folderType := m.startFolderLocked(cfg.ID)
+	if !cfg.Paused {
+		m.addFolderLocked(cfg)
+		folderType := m.startFolderLocked(cfg.ID)
+		l.Infoln("Restarted folder", cfg.Description(), fmt.Sprintf("(%s)", folderType))
+	} else {
+		l.Infoln("Paused folder", cfg.Description())
+	}
 
 	m.pmut.Unlock()
 	m.fmut.Unlock()
-
-	l.Infoln("Restarted folder", cfg.ID, fmt.Sprintf("(%s)", folderType))
 }
 
 type ConnectionInfo struct {
@@ -403,7 +415,7 @@ func (m *Model) ConnectionStats() map[string]interface{} {
 	res := make(map[string]interface{})
 	devs := m.cfg.Devices()
 	conns := make(map[string]ConnectionInfo, len(devs))
-	for device := range devs {
+	for device, deviceCfg := range devs {
 		hello := m.helloMessages[device]
 		versionString := hello.ClientVersion
 		if hello.ClientName != "syncthing" {
@@ -411,7 +423,7 @@ func (m *Model) ConnectionStats() map[string]interface{} {
 		}
 		ci := ConnectionInfo{
 			ClientVersion: strings.TrimSpace(versionString),
-			Paused:        m.devicePaused[device],
+			Paused:        deviceCfg.Paused,
 		}
 		if conn, ok := m.conn[device]; ok {
 			ci.Type = conn.Type()
@@ -764,6 +776,7 @@ func (m *Model) ClusterConfig(deviceID protocol.DeviceID, cm protocol.ClusterCon
 
 	m.pmut.RLock()
 	conn, ok := m.conn[deviceID]
+	hello := m.helloMessages[deviceID]
 	m.pmut.RUnlock()
 	if !ok {
 		panic("bug: ClusterConfig called on closed or nonexistent connection")
@@ -771,8 +784,26 @@ func (m *Model) ClusterConfig(deviceID protocol.DeviceID, cm protocol.ClusterCon
 
 	dbLocation := filepath.Dir(m.db.Location())
 
+	// See issue #3802 - in short, we can't send modern symlink entries to older
+	// clients.
+	dropSymlinks := false
+	if hello.ClientName == m.clientName && upgrade.CompareVersions(hello.ClientVersion, "v0.14.14") < 0 {
+		l.Warnln("Not sending symlinks to old client", deviceID, "- please upgrade to v0.14.14 or newer")
+		dropSymlinks = true
+	}
+
 	m.fmut.Lock()
+	var paused []string
 	for _, folder := range cm.Folders {
+		if folder.Paused {
+			paused = append(paused, folder.ID)
+			continue
+		}
+
+		if cfg, ok := m.cfg.Folder(folder.ID); ok && cfg.Paused {
+			continue
+		}
+
 		if !m.folderSharedWithLocked(folder.ID, deviceID) {
 			events.Default.Log(events.FolderRejected, map[string]string{
 				"folder":      folder.ID,
@@ -857,9 +888,13 @@ func (m *Model) ClusterConfig(deviceID protocol.DeviceID, cm protocol.ClusterCon
 			}
 		}
 
-		go sendIndexes(conn, folder.ID, fs, m.folderIgnores[folder.ID], startSequence, dbLocation)
+		go sendIndexes(conn, folder.ID, fs, m.folderIgnores[folder.ID], startSequence, dbLocation, dropSymlinks)
 	}
 
+	m.pmut.Lock()
+	m.remotePausedFolders[deviceID] = paused
+	m.pmut.Unlock()
+
 	// This breaks if we send multiple CM messages during the same connection.
 	if len(tempIndexFolders) > 0 {
 		m.pmut.RLock()
@@ -1047,6 +1082,7 @@ func (m *Model) Closed(conn protocol.Connection, err error) {
 	delete(m.conn, device)
 	delete(m.helloMessages, device)
 	delete(m.deviceDownloads, device)
+	delete(m.remotePausedFolders, device)
 	closed := m.closed[device]
 	delete(m.closed, device)
 	m.pmut.Unlock()
@@ -1062,9 +1098,13 @@ func (m *Model) Closed(conn protocol.Connection, err error) {
 // close will close the underlying connection for a given device
 func (m *Model) close(device protocol.DeviceID) {
 	m.pmut.Lock()
-	conn, ok := m.conn[device]
+	m.closeLocked(device)
 	m.pmut.Unlock()
+}
 
+// closeLocked will close the underlying connection for a given device
+func (m *Model) closeLocked(device protocol.DeviceID) {
+	conn, ok := m.conn[device]
 	if !ok {
 		// There is no connection to close
 		return
@@ -1260,16 +1300,15 @@ func (m *Model) SetIgnores(folder string, content []string) error {
 // This allows us to extract some information from the Hello message
 // and add it to a list of known devices ahead of any checks.
 func (m *Model) OnHello(remoteID protocol.DeviceID, addr net.Addr, hello protocol.HelloResult) error {
-	if m.IsPaused(remoteID) {
-		return errDevicePaused
-	}
-
 	if m.cfg.IgnoredDevice(remoteID) {
 		return errDeviceIgnored
 	}
 
-	if _, ok := m.cfg.Device(remoteID); ok {
+	if cfg, ok := m.cfg.Device(remoteID); ok {
 		// The device exists
+		if cfg.Paused {
+			return errDevicePaused
+		}
 		return nil
 	}
 
@@ -1336,10 +1375,11 @@ func (m *Model) AddConnection(conn connections.Connection, hello protocol.HelloR
 	l.Infof(`Device %s client is "%s %s" named "%s"`, deviceID, hello.ClientName, hello.ClientVersion, hello.DeviceName)
 
 	conn.Start()
+	m.pmut.Unlock()
 
+	// Acquires fmut, so has to be done outside of pmut.
 	cm := m.generateClusterConfig(deviceID)
 	conn.ClusterConfig(cm)
-	m.pmut.Unlock()
 
 	device, ok := m.cfg.Devices()[deviceID]
 	if ok && (device.Name == "" || m.cfg.Options().OverwriteRemoteDevNames) {
@@ -1351,17 +1391,6 @@ func (m *Model) AddConnection(conn connections.Connection, hello protocol.HelloR
 	m.deviceWasSeen(deviceID)
 }
 
-func (m *Model) PauseDevice(device protocol.DeviceID) {
-	m.pmut.Lock()
-	m.devicePaused[device] = true
-	conn, ok := m.conn[device]
-	m.pmut.Unlock()
-	if ok {
-		closeRawConn(conn)
-	}
-	events.Default.Log(events.DevicePaused, map[string]string{"device": device.String()})
-}
-
 func (m *Model) DownloadProgress(device protocol.DeviceID, folder string, updates []protocol.FileDownloadProgressUpdate) {
 	if !m.folderSharedWith(folder, device) {
 		return
@@ -1371,7 +1400,7 @@ func (m *Model) DownloadProgress(device protocol.DeviceID, folder string, update
 	cfg, ok := m.folderCfgs[folder]
 	m.fmut.RUnlock()
 
-	if !ok || cfg.Type == config.FolderTypeReadOnly || cfg.DisableTempIndexes {
+	if !ok || cfg.Type == config.FolderTypeSendOnly || cfg.DisableTempIndexes {
 		return
 	}
 
@@ -1387,20 +1416,6 @@ func (m *Model) DownloadProgress(device protocol.DeviceID, folder string, update
 	})
 }
 
-func (m *Model) ResumeDevice(device protocol.DeviceID) {
-	m.pmut.Lock()
-	m.devicePaused[device] = false
-	m.pmut.Unlock()
-	events.Default.Log(events.DeviceResumed, map[string]string{"device": device.String()})
-}
-
-func (m *Model) IsPaused(device protocol.DeviceID) bool {
-	m.pmut.Lock()
-	paused := m.devicePaused[device]
-	m.pmut.Unlock()
-	return paused
-}
-
 func (m *Model) deviceStatRef(deviceID protocol.DeviceID) *stats.DeviceStatisticsReference {
 	m.fmut.Lock()
 	defer m.fmut.Unlock()
@@ -1434,7 +1449,7 @@ func (m *Model) receivedFile(folder string, file protocol.FileInfo) {
 	m.folderStatRef(folder).ReceivedFile(file.Name, file.IsDeleted())
 }
 
-func sendIndexes(conn protocol.Connection, folder string, fs *db.FileSet, ignores *ignore.Matcher, startSequence int64, dbLocation string) {
+func sendIndexes(conn protocol.Connection, folder string, fs *db.FileSet, ignores *ignore.Matcher, startSequence int64, dbLocation string, dropSymlinks bool) {
 	deviceID := conn.ID()
 	name := conn.Name()
 	var err error
@@ -1442,7 +1457,7 @@ func sendIndexes(conn protocol.Connection, folder string, fs *db.FileSet, ignore
 	l.Debugf("sendIndexes for %s-%s/%q starting (slv=%d)", deviceID, name, folder, startSequence)
 	defer l.Debugf("sendIndexes for %s-%s/%q exiting: %v", deviceID, name, folder, err)
 
-	minSequence, err := sendIndexTo(startSequence, conn, folder, fs, ignores, dbLocation)
+	minSequence, err := sendIndexTo(startSequence, conn, folder, fs, ignores, dbLocation, dropSymlinks)
 
 	// Subscribe to LocalIndexUpdated (we have new information to send) and
 	// DeviceDisconnected (it might be us who disconnected, so we should
@@ -1465,7 +1480,7 @@ func sendIndexes(conn protocol.Connection, folder string, fs *db.FileSet, ignore
 			continue
 		}
 
-		minSequence, err = sendIndexTo(minSequence, conn, folder, fs, ignores, dbLocation)
+		minSequence, err = sendIndexTo(minSequence, conn, folder, fs, ignores, dbLocation, dropSymlinks)
 
 		// Wait a short amount of time before entering the next loop. If there
 		// are continuous changes happening to the local index, this gives us
@@ -1474,7 +1489,7 @@ func sendIndexes(conn protocol.Connection, folder string, fs *db.FileSet, ignore
 	}
 }
 
-func sendIndexTo(minSequence int64, conn protocol.Connection, folder string, fs *db.FileSet, ignores *ignore.Matcher, dbLocation string) (int64, error) {
+func sendIndexTo(minSequence int64, conn protocol.Connection, folder string, fs *db.FileSet, ignores *ignore.Matcher, dbLocation string, dropSymlinks bool) (int64, error) {
 	deviceID := conn.ID()
 	name := conn.Name()
 	batch := make([]protocol.FileInfo, 0, indexBatchSize)
@@ -1496,6 +1511,14 @@ func sendIndexTo(minSequence int64, conn protocol.Connection, folder string, fs
 			maxSequence = f.Sequence
 		}
 
+		if dropSymlinks && f.IsSymlink() {
+			// Do not send index entries with symlinks to clients that can't
+			// handle it. Fixes issue #3802. Once both sides are upgraded, a
+			// rescan (i.e., change) of the symlink is required for it to
+			// sync again, due to delta indexes.
+			return true
+		}
+
 		sorter.Append(f)
 		return true
 	})
@@ -1545,12 +1568,18 @@ func (m *Model) updateLocalsFromScanning(folder string, fs []protocol.FileInfo)
 	m.fmut.RLock()
 	folderCfg := m.folderCfgs[folder]
 	m.fmut.RUnlock()
-	// Fire the LocalChangeDetected event to notify listeners about local updates.
-	m.localChangeDetected(folderCfg, fs)
+
+	m.diskChangeDetected(folderCfg, fs, events.LocalChangeDetected)
 }
 
 func (m *Model) updateLocalsFromPulling(folder string, fs []protocol.FileInfo) {
 	m.updateLocals(folder, fs)
+
+	m.fmut.RLock()
+	folderCfg := m.folderCfgs[folder]
+	m.fmut.RUnlock()
+
+	m.diskChangeDetected(folderCfg, fs, events.RemoteChangeDetected)
 }
 
 func (m *Model) updateLocals(folder string, fs []protocol.FileInfo) {
@@ -1576,7 +1605,7 @@ func (m *Model) updateLocals(folder string, fs []protocol.FileInfo) {
 	})
 }
 
-func (m *Model) localChangeDetected(folderCfg config.FolderConfiguration, files []protocol.FileInfo) {
+func (m *Model) diskChangeDetected(folderCfg config.FolderConfiguration, files []protocol.FileInfo, typeOfEvent events.EventType) {
 	path := strings.Replace(folderCfg.Path(), `\\?\`, "", 1)
 
 	for _, file := range files {
@@ -1605,12 +1634,14 @@ func (m *Model) localChangeDetected(folderCfg config.FolderConfiguration, files
 		// for windows paths, strip unwanted chars from the front.
 		path := filepath.Join(path, filepath.FromSlash(file.Name))
 
-		events.Default.Log(events.LocalChangeDetected, map[string]string{
-			"folderID": folderCfg.ID,
-			"label":    folderCfg.Label,
-			"action":   action,
-			"type":     objType,
-			"path":     path,
+		// Two different events can be fired here based on what EventType is passed into function
+		events.Default.Log(typeOfEvent, map[string]string{
+			"folderID":   folderCfg.ID,
+			"label":      folderCfg.Label,
+			"action":     action,
+			"type":       objType,
+			"path":       path,
+			"modifiedBy": file.ModifiedBy.String(),
 		})
 	}
 }
@@ -1687,10 +1718,21 @@ func (m *Model) ScanFolderSubdirs(folder string, subs []string) error {
 }
 
 func (m *Model) internalScanFolderSubdirs(folder string, subDirs []string) error {
-	for i, sub := range subDirs {
-		sub = osutil.NativeFilename(sub)
+	for i := 0; i < len(subDirs); i++ {
+		sub := osutil.NativeFilename(subDirs[i])
+
+		if sub == "" {
+			// A blank subdirs means to scan the entire folder. We can trim
+			// the subDirs list and go on our way.
+			subDirs = nil
+			break
+		}
+
 		// We test each path by joining with "root". What we join with is
-		// not relevant, we just want the dotdot escape detection here.
+		// not relevant, we just want the dotdot escape detection here. For
+		// historical reasons we may get paths that end in a slash. We
+		// remove that first to allow the rootedJoinedPath to pass.
+		sub = strings.TrimRight(sub, string(os.PathSeparator))
 		if _, err := rootedJoinedPath("root", sub); err != nil {
 			return errors.New("invalid subpath")
 		}
@@ -1842,6 +1884,7 @@ func (m *Model) internalScanFolderSubdirs(folder string, subDirs []string) error
 					Size:          f.Size,
 					ModifiedS:     f.ModifiedS,
 					ModifiedNs:    f.ModifiedNs,
+					ModifiedBy:    m.id.Short(),
 					Permissions:   f.Permissions,
 					NoPermissions: f.NoPermissions,
 					Invalid:       true,
@@ -1867,6 +1910,7 @@ func (m *Model) internalScanFolderSubdirs(folder string, subDirs []string) error
 						Size:       0,
 						ModifiedS:  f.ModifiedS,
 						ModifiedNs: f.ModifiedNs,
+						ModifiedBy: m.id.Short(),
 						Deleted:    true,
 						Version:    f.Version.Update(m.shortID),
 					}
@@ -1952,10 +1996,11 @@ func (m *Model) generateClusterConfig(device protocol.DeviceID) protocol.Cluster
 		protocolFolder := protocol.Folder{
 			ID:                 folder,
 			Label:              folderCfg.Label,
-			ReadOnly:           folderCfg.Type == config.FolderTypeReadOnly,
+			ReadOnly:           folderCfg.Type == config.FolderTypeSendOnly,
 			IgnorePermissions:  folderCfg.IgnorePerms,
 			IgnoreDelete:       folderCfg.IgnoreDelete,
 			DisableTempIndexes: folderCfg.DisableTempIndexes,
+			Paused:             folderCfg.Paused,
 		}
 
 		// Devices are sorted, so we always get the same order.
@@ -2165,7 +2210,13 @@ func (m *Model) Availability(folder, file string, version protocol.Vector, block
 	}
 
 	var availabilities []Availability
+next:
 	for _, device := range fs.Availability(file) {
+		for _, pausedFolder := range m.remotePausedFolders[device] {
+			if pausedFolder == folder {
+				continue next
+			}
+		}
 		_, ok := m.conn[device]
 		if ok {
 			availabilities = append(availabilities, Availability{ID: device, FromTemporary: false})
@@ -2323,16 +2374,6 @@ func (m *Model) CommitConfiguration(from, to config.Configuration) bool {
 			l.Debugln(m, "adding folder", folderID)
 			m.AddFolder(cfg)
 			m.StartFolder(folderID)
-
-			// Drop connections to all devices that can now share the new
-			// folder.
-			m.pmut.Lock()
-			for _, dev := range cfg.DeviceIDs() {
-				if conn, ok := m.conn[dev]; ok {
-					closeRawConn(conn)
-				}
-			}
-			m.pmut.Unlock()
 		}
 	}
 
@@ -2354,6 +2395,15 @@ func (m *Model) CommitConfiguration(from, to config.Configuration) bool {
 		if !reflect.DeepEqual(fromCfgCopy, toCfgCopy) {
 			m.RestartFolder(toCfg)
 		}
+
+		// Emit the folder pause/resume event
+		if fromCfg.Paused != toCfg.Paused {
+			eventType := events.FolderResumed
+			if toCfg.Paused {
+				eventType = events.FolderPaused
+			}
+			events.Default.Log(eventType, map[string]string{"id": toCfg.ID, "label": toCfg.Label})
+		}
 	}
 
 	// Removing a device. We actually don't need to do anything.
@@ -2363,6 +2413,24 @@ func (m *Model) CommitConfiguration(from, to config.Configuration) bool {
 	// At some point model.Close() will get called for that device which will
 	// clean residue device state that is not part of any folder.
 
+	// Pausing a device, unpausing is handled by the connection service.
+	fromDevices := mapDeviceConfigs(from.Devices)
+	toDevices := mapDeviceConfigs(to.Devices)
+	for deviceID, toCfg := range toDevices {
+		fromCfg, ok := fromDevices[deviceID]
+		if !ok || fromCfg.Paused == toCfg.Paused {
+			continue
+		}
+
+		if toCfg.Paused {
+			l.Infoln("Pausing", deviceID)
+			m.close(deviceID)
+			events.Default.Log(events.DevicePaused, map[string]string{"device": deviceID.String()})
+		} else {
+			events.Default.Log(events.DeviceResumed, map[string]string{"device": deviceID.String()})
+		}
+	}
+
 	// Some options don't require restart as those components handle it fine
 	// by themselves.
 	from.Options.URAccepted = to.Options.URAccepted
@@ -2404,6 +2472,16 @@ func mapDevices(devices []protocol.DeviceID) map[protocol.DeviceID]struct{} {
 	return m
 }
 
+// mapDeviceConfigs returns a map of device ID to device configuration for the given
+// slice of folder configurations.
+func mapDeviceConfigs(devices []config.DeviceConfiguration) map[protocol.DeviceID]config.DeviceConfiguration {
+	m := make(map[protocol.DeviceID]config.DeviceConfiguration, len(devices))
+	for _, dev := range devices {
+		m[dev.DeviceID] = dev
+	}
+	return m
+}
+
 func symlinkInvalid(folder string, fi db.FileIntf) bool {
 	if !symlinks.Supported && fi.IsSymlink() && !fi.IsInvalid() && !fi.IsDeleted() {
 		symlinkWarning.Do(func() {

lib/model/model_test.go

@@ -1028,7 +1028,7 @@ func TestROScanRecovery(t *testing.T) {
 	fcfg := config.FolderConfiguration{
 		ID:              "default",
 		RawPath:         "testdata/rotestfolder",
-		Type:            config.FolderTypeReadOnly,
+		Type:            config.FolderTypeSendOnly,
 		RescanIntervalS: 1,
 	}
 	cfg := config.Wrap("/tmp/test", config.Configuration{
@@ -1115,7 +1115,7 @@ func TestRWScanRecovery(t *testing.T) {
 	fcfg := config.FolderConfiguration{
 		ID:              "default",
 		RawPath:         "testdata/rwtestfolder",
-		Type:            config.FolderTypeReadWrite,
+		Type:            config.FolderTypeSendReceive,
 		RescanIntervalS: 1,
 	}
 	cfg := config.Wrap("/tmp/test", config.Configuration{
@@ -1763,11 +1763,11 @@ func TestIssue3028(t *testing.T) {
 	m.StartFolder("default")
 	m.ServeBackground()
 
-	// Ugly hack for testing: reach into the model for the rwfolder and wait
+	// Ugly hack for testing: reach into the model for the SendReceiveFolder and wait
 	// for it to complete the initial scan. The risk is that it otherwise
 	// runs during our modifications and screws up the test.
 	m.fmut.RLock()
-	folder := m.folderRunners["default"].(*rwFolder)
+	folder := m.folderRunners["default"].(*sendReceiveFolder)
 	m.fmut.RUnlock()
 	<-folder.initialScanCompleted
 
@@ -1822,7 +1822,7 @@ func TestIssue3164(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	fl := rwFolder{
+	fl := sendReceiveFolder{
 		dbUpdates: make(chan dbUpdateJob, 1),
 		dir:       "testdata",
 	}
@@ -2090,6 +2090,8 @@ func TestSharedWithClearedOnDisconnect(t *testing.T) {
 }
 
 func TestIssue3496(t *testing.T) {
+	t.Skip("This test deletes files that the other test depend on. Needs fixing.")
+
 	// It seems like lots of deleted files can cause negative completion
 	// percentages. Lets make sure that doesn't happen. Also do some general
 	// checks on the completion calculation stuff.
@@ -2166,6 +2168,127 @@ func TestIssue3496(t *testing.T) {
 	}
 }
 
+func TestIssue3804(t *testing.T) {
+	dbi := db.OpenMemory()
+	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", dbi, nil)
+	m.AddFolder(defaultFolderConfig)
+	m.StartFolder("default")
+	m.ServeBackground()
+	defer m.Stop()
+
+	// Subdirs ending in slash should be accepted
+
+	if err := m.ScanFolderSubdirs("default", []string{"baz/", "foo"}); err != nil {
+		t.Error("Unexpected error:", err)
+	}
+}
+
+func TestIssue3829(t *testing.T) {
+	dbi := db.OpenMemory()
+	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", dbi, nil)
+	m.AddFolder(defaultFolderConfig)
+	m.StartFolder("default")
+	m.ServeBackground()
+	defer m.Stop()
+
+	// Empty subdirs should be accepted
+
+	if err := m.ScanFolderSubdirs("default", []string{""}); err != nil {
+		t.Error("Unexpected error:", err)
+	}
+}
+
+func TestNoRequestsFromPausedDevices(t *testing.T) {
+	dbi := db.OpenMemory()
+
+	fcfg := config.NewFolderConfiguration("default", "testdata")
+	fcfg.Devices = []config.FolderDeviceConfiguration{
+		{DeviceID: device1},
+		{DeviceID: device2},
+	}
+	cfg := config.Configuration{
+		Folders: []config.FolderConfiguration{fcfg},
+		Devices: []config.DeviceConfiguration{
+			config.NewDeviceConfiguration(device1, "device1"),
+			config.NewDeviceConfiguration(device2, "device2"),
+		},
+		Options: config.OptionsConfiguration{
+			// Don't remove temporaries directly on startup
+			KeepTemporariesH: 1,
+		},
+	}
+
+	wcfg := config.Wrap("/tmp/test", cfg)
+
+	m := NewModel(wcfg, protocol.LocalDeviceID, "device", "syncthing", "dev", dbi, nil)
+	m.AddFolder(fcfg)
+	m.StartFolder(fcfg.ID)
+	m.ServeBackground()
+
+	file := testDataExpected["foo"]
+	files := m.folderFiles["default"]
+	files.Update(device1, []protocol.FileInfo{file})
+	files.Update(device2, []protocol.FileInfo{file})
+
+	avail := m.Availability("default", file.Name, file.Version, file.Blocks[0])
+	if len(avail) != 0 {
+		t.Errorf("should not be available, no connections")
+	}
+
+	addFakeConn(m, device1)
+	addFakeConn(m, device2)
+
+	// !!! This is not what I'd expect to happen, as we don't even know if the peer has the original index !!!
+
+	avail = m.Availability("default", file.Name, file.Version, file.Blocks[0])
+	if len(avail) != 2 {
+		t.Errorf("should have two available")
+	}
+
+	cc := protocol.ClusterConfig{
+		Folders: []protocol.Folder{
+			{
+				ID: "default",
+				Devices: []protocol.Device{
+					{ID: device1},
+					{ID: device2},
+				},
+			},
+		},
+	}
+
+	m.ClusterConfig(device1, cc)
+	m.ClusterConfig(device2, cc)
+
+	avail = m.Availability("default", file.Name, file.Version, file.Blocks[0])
+	if len(avail) != 2 {
+		t.Errorf("should have two available")
+	}
+
+	m.Closed(&fakeConnection{id: device1}, errDeviceUnknown)
+	m.Closed(&fakeConnection{id: device2}, errDeviceUnknown)
+
+	avail = m.Availability("default", file.Name, file.Version, file.Blocks[0])
+	if len(avail) != 0 {
+		t.Errorf("should have no available")
+	}
+
+	// Test that remote paused folders are not used.
+
+	addFakeConn(m, device1)
+	addFakeConn(m, device2)
+
+	m.ClusterConfig(device1, cc)
+	ccp := cc
+	ccp.Folders[0].Paused = true
+	m.ClusterConfig(device1, ccp)
+
+	avail = m.Availability("default", file.Name, file.Version, file.Blocks[0])
+	if len(avail) != 1 {
+		t.Errorf("should have one available")
+	}
+}
+
 func TestRootedJoinedPath(t *testing.T) {
 	type testcase struct {
 		root   string

lib/model/rofolder.go

@@ -15,25 +15,27 @@ import (
 )
 
 func init() {
-	folderFactories[config.FolderTypeReadOnly] = newROFolder
+	folderFactories[config.FolderTypeSendOnly] = newSendOnlyFolder
 }
 
-type roFolder struct {
+type sendOnlyFolder struct {
 	folder
+	config.FolderConfiguration
 }
 
-func newROFolder(model *Model, cfg config.FolderConfiguration, _ versioner.Versioner, _ *fs.MtimeFS) service {
-	return &roFolder{
+func newSendOnlyFolder(model *Model, cfg config.FolderConfiguration, _ versioner.Versioner, _ *fs.MtimeFS) service {
+	return &sendOnlyFolder{
 		folder: folder{
 			stateTracker: newStateTracker(cfg.ID),
 			scan:         newFolderScanner(cfg),
 			stop:         make(chan struct{}),
 			model:        model,
 		},
+		FolderConfiguration: cfg,
 	}
 }
 
-func (f *roFolder) Serve() {
+func (f *sendOnlyFolder) Serve() {
 	l.Debugln(f, "starting")
 	defer l.Debugln(f, "exiting")
 
@@ -49,7 +51,7 @@ func (f *roFolder) Serve() {
 
 		case <-f.scan.timer.C:
 			if err := f.model.CheckFolderHealth(f.folderID); err != nil {
-				l.Infoln("Skipping folder", f.folderID, "scan due to folder error:", err)
+				l.Infoln("Skipping scan of", f.Description(), "due to folder error:", err)
 				f.scan.Reschedule()
 				continue
 			}
@@ -67,7 +69,7 @@ func (f *roFolder) Serve() {
 			}
 
 			if !initialScanCompleted {
-				l.Infoln("Completed initial scan (ro) of folder", f.folderID)
+				l.Infoln("Completed initial scan (ro) of", f.Description())
 				initialScanCompleted = true
 			}
 
@@ -86,6 +88,6 @@ func (f *roFolder) Serve() {
 	}
 }
 
-func (f *roFolder) String() string {
-	return fmt.Sprintf("roFolder/%s@%p", f.folderID, f)
+func (f *sendOnlyFolder) String() string {
+	return fmt.Sprintf("sendOnlyFolder/%s@%p", f.folderID, f)
 }

lib/model/rwfolder.go

@@ -28,10 +28,11 @@ import (
 	"github.com/syncthing/syncthing/lib/symlinks"
 	"github.com/syncthing/syncthing/lib/sync"
 	"github.com/syncthing/syncthing/lib/versioner"
+	"github.com/syncthing/syncthing/lib/weakhash"
 )
 
 func init() {
-	folderFactories[config.FolderTypeReadWrite] = newRWFolder
+	folderFactories[config.FolderTypeSendReceive] = newSendReceiveFolder
 }
 
 // A pullBlockState is passed to the puller routine for each block that needs
@@ -77,24 +78,15 @@ type dbUpdateJob struct {
 	jobType int
 }
 
-type rwFolder struct {
+type sendReceiveFolder struct {
 	folder
+	config.FolderConfiguration
 
-	mtimeFS        *fs.MtimeFS
-	dir            string
-	versioner      versioner.Versioner
-	ignorePerms    bool
-	order          config.PullOrder
-	maxConflicts   int
-	sleep          time.Duration
-	pause          time.Duration
-	allowSparse    bool
-	checkFreeSpace bool
-	ignoreDelete   bool
-	fsync          bool
-
-	copiers int
-	pullers int
+	mtimeFS   *fs.MtimeFS
+	dir       string
+	versioner versioner.Versioner
+	sleep     time.Duration
+	pause     time.Duration
 
 	queue       *jobQueue
 	dbUpdates   chan dbUpdateJob
@@ -107,27 +99,19 @@ type rwFolder struct {
 	initialScanCompleted chan (struct{}) // exposed for testing
 }
 
-func newRWFolder(model *Model, cfg config.FolderConfiguration, ver versioner.Versioner, mtimeFS *fs.MtimeFS) service {
-	f := &rwFolder{
+func newSendReceiveFolder(model *Model, cfg config.FolderConfiguration, ver versioner.Versioner, mtimeFS *fs.MtimeFS) service {
+	f := &sendReceiveFolder{
 		folder: folder{
 			stateTracker: newStateTracker(cfg.ID),
 			scan:         newFolderScanner(cfg),
 			stop:         make(chan struct{}),
 			model:        model,
 		},
+		FolderConfiguration: cfg,
 
-		mtimeFS:        mtimeFS,
-		dir:            cfg.Path(),
-		versioner:      ver,
-		ignorePerms:    cfg.IgnorePerms,
-		copiers:        cfg.Copiers,
-		pullers:        cfg.Pullers,
-		order:          cfg.Order,
-		maxConflicts:   cfg.MaxConflicts,
-		allowSparse:    !cfg.DisableSparseFiles,
-		checkFreeSpace: cfg.MinDiskFreePct != 0,
-		ignoreDelete:   cfg.IgnoreDelete,
-		fsync:          cfg.Fsync,
+		mtimeFS:   mtimeFS,
+		dir:       cfg.Path(),
+		versioner: ver,
 
 		queue:       newJobQueue(),
 		pullTimer:   time.NewTimer(time.Second),
@@ -138,42 +122,42 @@ func newRWFolder(model *Model, cfg config.FolderConfiguration, ver versioner.Ver
 		initialScanCompleted: make(chan struct{}),
 	}
 
-	f.configureCopiersAndPullers(cfg)
+	f.configureCopiersAndPullers()
 
 	return f
 }
 
-func (f *rwFolder) configureCopiersAndPullers(cfg config.FolderConfiguration) {
-	if f.copiers == 0 {
-		f.copiers = defaultCopiers
+func (f *sendReceiveFolder) configureCopiersAndPullers() {
+	if f.Copiers == 0 {
+		f.Copiers = defaultCopiers
 	}
-	if f.pullers == 0 {
-		f.pullers = defaultPullers
+	if f.Pullers == 0 {
+		f.Pullers = defaultPullers
 	}
 
-	if cfg.PullerPauseS == 0 {
+	if f.PullerPauseS == 0 {
 		f.pause = defaultPullerPause
 	} else {
-		f.pause = time.Duration(cfg.PullerPauseS) * time.Second
+		f.pause = time.Duration(f.PullerPauseS) * time.Second
 	}
 
-	if cfg.PullerSleepS == 0 {
+	if f.PullerSleepS == 0 {
 		f.sleep = defaultPullerSleep
 	} else {
-		f.sleep = time.Duration(cfg.PullerSleepS) * time.Second
+		f.sleep = time.Duration(f.PullerSleepS) * time.Second
 	}
 }
 
 // Helper function to check whether either the ignorePerm flag has been
 // set on the local host or the FlagNoPermBits has been set on the file/dir
 // which is being pulled.
-func (f *rwFolder) ignorePermissions(file protocol.FileInfo) bool {
-	return f.ignorePerms || file.NoPermissions
+func (f *sendReceiveFolder) ignorePermissions(file protocol.FileInfo) bool {
+	return f.IgnorePerms || file.NoPermissions
 }
 
 // Serve will run scans and pulls. It will return when Stop()ed or on a
 // critical error.
-func (f *rwFolder) Serve() {
+func (f *sendReceiveFolder) Serve() {
 	l.Debugln(f, "starting")
 	defer l.Debugln(f, "exiting")
 
@@ -228,7 +212,7 @@ func (f *rwFolder) Serve() {
 			}
 
 			if err := f.model.CheckFolderHealth(f.folderID); err != nil {
-				l.Infoln("Skipping folder", f.folderID, "pull due to folder error:", err)
+				l.Infoln("Skipping pull of", f.Description(), "due to folder error:", err)
 				f.pullTimer.Reset(f.sleep)
 				continue
 			}
@@ -301,7 +285,7 @@ func (f *rwFolder) Serve() {
 			select {
 			case <-f.initialScanCompleted:
 			default:
-				l.Infoln("Completed initial scan (rw) of folder", f.folderID)
+				l.Infoln("Completed initial scan (rw) of", f.Description())
 				close(f.initialScanCompleted)
 			}
 
@@ -314,7 +298,7 @@ func (f *rwFolder) Serve() {
 	}
 }
 
-func (f *rwFolder) IndexUpdated() {
+func (f *sendReceiveFolder) IndexUpdated() {
 	select {
 	case f.remoteIndex <- struct{}{}:
 	default:
@@ -325,15 +309,15 @@ func (f *rwFolder) IndexUpdated() {
 	}
 }
 
-func (f *rwFolder) String() string {
-	return fmt.Sprintf("rwFolder/%s@%p", f.folderID, f)
+func (f *sendReceiveFolder) String() string {
+	return fmt.Sprintf("sendReceiveFolder/%s@%p", f.folderID, f)
 }
 
 // pullerIteration runs a single puller iteration for the given folder and
 // returns the number items that should have been synced (even those that
 // might have failed). One puller iteration handles all files currently
 // flagged as needed in the folder.
-func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
+func (f *sendReceiveFolder) pullerIteration(ignores *ignore.Matcher) int {
 	pullChan := make(chan pullBlockState)
 	copyChan := make(chan copyBlocksState)
 	finisherChan := make(chan *sharedPullerState)
@@ -343,7 +327,7 @@ func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
 	pullWg := sync.NewWaitGroup()
 	doneWg := sync.NewWaitGroup()
 
-	l.Debugln(f, "c", f.copiers, "p", f.pullers)
+	l.Debugln(f, "c", f.Copiers, "p", f.Pullers)
 
 	f.dbUpdates = make(chan dbUpdateJob)
 	updateWg.Add(1)
@@ -353,7 +337,7 @@ func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
 		updateWg.Done()
 	}()
 
-	for i := 0; i < f.copiers; i++ {
+	for i := 0; i < f.Copiers; i++ {
 		copyWg.Add(1)
 		go func() {
 			// copierRoutine finishes when copyChan is closed
@@ -362,7 +346,7 @@ func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
 		}()
 	}
 
-	for i := 0; i < f.pullers; i++ {
+	for i := 0; i < f.Pullers; i++ {
 		pullWg.Add(1)
 		go func() {
 			// pullerRoutine finishes when pullChan is closed
@@ -391,7 +375,7 @@ func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
 	// pile.
 
 	folderFiles.WithNeed(protocol.LocalDeviceID, func(intf db.FileIntf) bool {
-		if shouldIgnore(intf, ignores, f.ignoreDelete, defTempNamer) {
+		if shouldIgnore(intf, ignores, f.IgnoreDelete, defTempNamer) {
 			return true
 		}
 
@@ -488,7 +472,7 @@ func (f *rwFolder) pullerIteration(ignores *ignore.Matcher) int {
 
 	// Now do the file queue. Reorder it according to configuration.
 
-	switch f.order {
+	switch f.Order {
 	case config.OrderRandom:
 		f.queue.Shuffle()
 	case config.OrderAlphabetic:
@@ -510,7 +494,7 @@ nextFile:
 		select {
 		case <-f.stop:
 			// Stop processing files if the puller has been told to stop.
-			break
+			break nextFile
 		default:
 		}
 
@@ -600,7 +584,7 @@ nextFile:
 }
 
 // handleDir creates or updates the given directory
-func (f *rwFolder) handleDir(file protocol.FileInfo) {
+func (f *sendReceiveFolder) handleDir(file protocol.FileInfo) {
 	// Used in the defer closure below, updated by the function body. Take
 	// care not declare another err.
 	var err error
@@ -702,7 +686,7 @@ func (f *rwFolder) handleDir(file protocol.FileInfo) {
 }
 
 // handleSymlink creates or updates the given symlink
-func (f *rwFolder) handleSymlink(file protocol.FileInfo) {
+func (f *sendReceiveFolder) handleSymlink(file protocol.FileInfo) {
 	// Used in the defer closure below, updated by the function body. Take
 	// care not declare another err.
 	var err error
@@ -776,7 +760,7 @@ func (f *rwFolder) handleSymlink(file protocol.FileInfo) {
 }
 
 // deleteDir attempts to delete the given directory
-func (f *rwFolder) deleteDir(file protocol.FileInfo, matcher *ignore.Matcher) {
+func (f *sendReceiveFolder) deleteDir(file protocol.FileInfo, matcher *ignore.Matcher) {
 	// Used in the defer closure below, updated by the function body. Take
 	// care not declare another err.
 	var err error
@@ -834,7 +818,7 @@ func (f *rwFolder) deleteDir(file protocol.FileInfo, matcher *ignore.Matcher) {
 }
 
 // deleteFile attempts to delete the given file
-func (f *rwFolder) deleteFile(file protocol.FileInfo) {
+func (f *sendReceiveFolder) deleteFile(file protocol.FileInfo) {
 	// Used in the defer closure below, updated by the function body. Take
 	// care not declare another err.
 	var err error
@@ -892,7 +876,7 @@ func (f *rwFolder) deleteFile(file protocol.FileInfo) {
 
 // renameFile attempts to rename an existing file to a destination
 // and set the right attributes on it.
-func (f *rwFolder) renameFile(source, target protocol.FileInfo) {
+func (f *sendReceiveFolder) renameFile(source, target protocol.FileInfo) {
 	// Used in the defer closure below, updated by the function body. Take
 	// care not declare another err.
 	var err error
@@ -1016,7 +1000,7 @@ func (f *rwFolder) renameFile(source, target protocol.FileInfo) {
 
 // handleFile queues the copies and pulls as necessary for a single new or
 // changed file.
-func (f *rwFolder) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocksState, finisherChan chan<- *sharedPullerState) {
+func (f *sendReceiveFolder) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocksState, finisherChan chan<- *sharedPullerState) {
 	curFile, hasCurFile := f.model.CurrentFolderFile(f.folderID, file.Name)
 
 	if hasCurFile && len(curFile.Blocks) == len(file.Blocks) && scanner.BlocksEqual(curFile.Blocks, file.Blocks) {
@@ -1130,7 +1114,7 @@ func (f *rwFolder) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocks
 		blocksSize = file.Size
 	}
 
-	if f.checkFreeSpace {
+	if f.MinDiskFreePct > 0 {
 		if free, err := osutil.DiskFreeBytes(f.dir); err == nil && free < blocksSize {
 			l.Warnf(`Folder "%s": insufficient disk space in %s for %s: have %.2f MiB, need %.2f MiB`, f.folderID, f.dir, file.Name, float64(free)/1024/1024, float64(blocksSize)/1024/1024)
 			f.newError(file.Name, errors.New("insufficient space"))
@@ -1165,11 +1149,11 @@ func (f *rwFolder) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocks
 		ignorePerms:      f.ignorePermissions(file),
 		version:          curFile.Version,
 		mut:              sync.NewRWMutex(),
-		sparse:           f.allowSparse,
+		sparse:           !f.DisableSparseFiles,
 		created:          time.Now(),
 	}
 
-	l.Debugf("%v need file %s; copy %d, reused %v", f, file.Name, len(blocks), reused)
+	l.Debugf("%v need file %s; copy %d, reused %v", f, file.Name, len(blocks), len(reused))
 
 	cs := copyBlocksState{
 		sharedPullerState: &s,
@@ -1180,7 +1164,7 @@ func (f *rwFolder) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocks
 
 // shortcutFile sets file mode and modification time, when that's the only
 // thing that has changed.
-func (f *rwFolder) shortcutFile(file protocol.FileInfo) error {
+func (f *sendReceiveFolder) shortcutFile(file protocol.FileInfo) error {
 	realName, err := rootedJoinedPath(f.dir, file.Name)
 	if err != nil {
 		f.newError(file.Name, err)
@@ -1207,7 +1191,7 @@ func (f *rwFolder) shortcutFile(file protocol.FileInfo) error {
 
 // copierRoutine reads copierStates until the in channel closes and performs
 // the relevant copies when possible, or passes it to the puller routine.
-func (f *rwFolder) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState) {
+func (f *sendReceiveFolder) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState) {
 	buf := make([]byte, protocol.BlockSize)
 
 	for state := range in {
@@ -1231,8 +1215,23 @@ func (f *rwFolder) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pull
 		}
 		f.model.fmut.RUnlock()
 
+		var weakHashFinder *weakhash.Finder
+		if !f.DisableWeakHash {
+			hashesToFind := make([]uint32, 0, len(state.blocks))
+			for _, block := range state.blocks {
+				if block.WeakHash != 0 {
+					hashesToFind = append(hashesToFind, block.WeakHash)
+				}
+			}
+
+			weakHashFinder, err = weakhash.NewFinder(state.realName, protocol.BlockSize, hashesToFind)
+			if err != nil {
+				l.Debugln("weak hasher", err)
+			}
+		}
+
 		for _, block := range state.blocks {
-			if f.allowSparse && state.reused == 0 && block.IsEmpty() {
+			if !f.DisableSparseFiles && state.reused == 0 && block.IsEmpty() {
 				// The block is a block of all zeroes, and we are not reusing
 				// a temp file, so there is no need to do anything with it.
 				// If we were reusing a temp file and had this block to copy,
@@ -1245,45 +1244,70 @@ func (f *rwFolder) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pull
 			}
 
 			buf = buf[:int(block.Size)]
-			found := f.model.finder.Iterate(folders, block.Hash, func(folder, file string, index int32) bool {
-				inFile, err := rootedJoinedPath(folderRoots[folder], file)
-				if err != nil {
-					return false
-				}
-				fd, err := os.Open(inFile)
-				if err != nil {
-					return false
-				}
 
-				_, err = fd.ReadAt(buf, protocol.BlockSize*int64(index))
-				fd.Close()
-				if err != nil {
-					return false
-				}
-
-				hash, err := scanner.VerifyBuffer(buf, block)
-				if err != nil {
-					if hash != nil {
-						l.Debugf("Finder block mismatch in %s:%s:%d expected %q got %q", folder, file, index, block.Hash, hash)
-						err = f.model.finder.Fix(folder, file, index, block.Hash, hash)
-						if err != nil {
-							l.Warnln("finder fix:", err)
-						}
-					} else {
-						l.Debugln("Finder failed to verify buffer", err)
-					}
-					return false
+			found, err := weakHashFinder.Iterate(block.WeakHash, buf, func(offset int64) bool {
+				if _, err := scanner.VerifyBuffer(buf, block); err != nil {
+					return true
 				}
 
 				_, err = dstFd.WriteAt(buf, block.Offset)
 				if err != nil {
 					state.fail("dst write", err)
+
 				}
-				if file == state.file.Name {
+				if offset == block.Offset {
 					state.copiedFromOrigin()
+				} else {
+					state.copiedFromOriginShifted()
 				}
-				return true
+
+				return false
 			})
+			if err != nil {
+				l.Debugln("weak hasher iter", err)
+			}
+
+			if !found {
+				found = f.model.finder.Iterate(folders, block.Hash, func(folder, file string, index int32) bool {
+					inFile, err := rootedJoinedPath(folderRoots[folder], file)
+					if err != nil {
+						return false
+					}
+					fd, err := os.Open(inFile)
+					if err != nil {
+						return false
+					}
+
+					_, err = fd.ReadAt(buf, protocol.BlockSize*int64(index))
+					fd.Close()
+					if err != nil {
+						return false
+					}
+
+					hash, err := scanner.VerifyBuffer(buf, block)
+					if err != nil {
+						if hash != nil {
+							l.Debugf("Finder block mismatch in %s:%s:%d expected %q got %q", folder, file, index, block.Hash, hash)
+							err = f.model.finder.Fix(folder, file, index, block.Hash, hash)
+							if err != nil {
+								l.Warnln("finder fix:", err)
+							}
+						} else {
+							l.Debugln("Finder failed to verify buffer", err)
+						}
+						return false
+					}
+
+					_, err = dstFd.WriteAt(buf, block.Offset)
+					if err != nil {
+						state.fail("dst write", err)
+					}
+					if file == state.file.Name {
+						state.copiedFromOrigin()
+					}
+					return true
+				})
+			}
 
 			if state.failed() != nil {
 				break
@@ -1300,11 +1324,12 @@ func (f *rwFolder) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pull
 				state.copyDone(block)
 			}
 		}
+		weakHashFinder.Close()
 		out <- state.sharedPullerState
 	}
 }
 
-func (f *rwFolder) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPullerState) {
+func (f *sendReceiveFolder) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPullerState) {
 	for state := range in {
 		if state.failed() != nil {
 			out <- state.sharedPullerState
@@ -1320,7 +1345,7 @@ func (f *rwFolder) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPul
 			continue
 		}
 
-		if f.allowSparse && state.reused == 0 && state.block.IsEmpty() {
+		if !f.DisableSparseFiles && state.reused == 0 && state.block.IsEmpty() {
 			// There is no need to request a block of all zeroes. Pretend we
 			// requested it and handled it correctly.
 			state.pullDone(state.block)
@@ -1377,7 +1402,7 @@ func (f *rwFolder) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPul
 	}
 }
 
-func (f *rwFolder) performFinish(state *sharedPullerState) error {
+func (f *sendReceiveFolder) performFinish(state *sharedPullerState) error {
 	// Set the correct permission bits on the new file
 	if !f.ignorePermissions(state.file) {
 		if err := os.Chmod(state.tempName, os.FileMode(state.file.Permissions&0777)); err != nil {
@@ -1439,7 +1464,7 @@ func (f *rwFolder) performFinish(state *sharedPullerState) error {
 	return nil
 }
 
-func (f *rwFolder) finisherRoutine(in <-chan *sharedPullerState) {
+func (f *sendReceiveFolder) finisherRoutine(in <-chan *sharedPullerState) {
 	for state := range in {
 		if closed, err := state.finalClose(); closed {
 			l.Debugln(f, "closing", state.file.Name)
@@ -1470,17 +1495,17 @@ func (f *rwFolder) finisherRoutine(in <-chan *sharedPullerState) {
 }
 
 // Moves the given filename to the front of the job queue
-func (f *rwFolder) BringToFront(filename string) {
+func (f *sendReceiveFolder) BringToFront(filename string) {
 	f.queue.BringToFront(filename)
 }
 
-func (f *rwFolder) Jobs() ([]string, []string) {
+func (f *sendReceiveFolder) Jobs() ([]string, []string) {
 	return f.queue.Jobs()
 }
 
 // dbUpdaterRoutine aggregates db updates and commits them in batches no
 // larger than 1000 items, and no more delayed than 2 seconds.
-func (f *rwFolder) dbUpdaterRoutine() {
+func (f *sendReceiveFolder) dbUpdaterRoutine() {
 	const (
 		maxBatchSize = 1000
 		maxBatchTime = 2 * time.Second
@@ -1493,7 +1518,7 @@ func (f *rwFolder) dbUpdaterRoutine() {
 
 	var changedFiles []string
 	var changedDirs []string
-	if f.fsync {
+	if f.Fsync {
 		changedFiles = make([]string, 0, maxBatchSize)
 		changedDirs = make([]string, 0, maxBatchSize)
 	}
@@ -1518,7 +1543,7 @@ func (f *rwFolder) dbUpdaterRoutine() {
 
 		for _, job := range batch {
 			files = append(files, job.file)
-			if f.fsync {
+			if f.Fsync {
 				// collect changed files and dirs
 				switch job.jobType {
 				case dbUpdateHandleFile, dbUpdateShortcutFile:
@@ -1544,7 +1569,7 @@ func (f *rwFolder) dbUpdaterRoutine() {
 			lastFile = job.file
 		}
 
-		if f.fsync {
+		if f.Fsync {
 			// sync files and dirs to disk
 			syncFilesOnce(changedFiles, osutil.SyncFile)
 			changedFiles = changedFiles[:0]
@@ -1591,7 +1616,7 @@ loop:
 	}
 }
 
-func (f *rwFolder) inConflict(current, replacement protocol.Vector) bool {
+func (f *sendReceiveFolder) inConflict(current, replacement protocol.Vector) bool {
 	if current.Concurrent(replacement) {
 		// Obvious case
 		return true
@@ -1617,7 +1642,7 @@ func removeAvailability(availabilities []Availability, availability Availability
 	return availabilities
 }
 
-func (f *rwFolder) moveForConflict(name string) error {
+func (f *sendReceiveFolder) moveForConflict(name string) error {
 	if strings.Contains(filepath.Base(name), ".sync-conflict-") {
 		l.Infoln("Conflict for", name, "which is already a conflict copy; not copying again.")
 		if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
@@ -1626,7 +1651,7 @@ func (f *rwFolder) moveForConflict(name string) error {
 		return nil
 	}
 
-	if f.maxConflicts == 0 {
+	if f.MaxConflicts == 0 {
 		if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
 			return err
 		}
@@ -1644,11 +1669,11 @@ func (f *rwFolder) moveForConflict(name string) error {
 		// matter, go ahead as if the move succeeded.
 		err = nil
 	}
-	if f.maxConflicts > -1 {
+	if f.MaxConflicts > -1 {
 		matches, gerr := osutil.Glob(withoutExt + ".sync-conflict-????????-??????" + ext)
-		if gerr == nil && len(matches) > f.maxConflicts {
+		if gerr == nil && len(matches) > f.MaxConflicts {
 			sort.Sort(sort.Reverse(sort.StringSlice(matches)))
-			for _, match := range matches[f.maxConflicts:] {
+			for _, match := range matches[f.MaxConflicts:] {
 				gerr = os.Remove(match)
 				if gerr != nil {
 					l.Debugln(f, "removing extra conflict", gerr)
@@ -1661,7 +1686,7 @@ func (f *rwFolder) moveForConflict(name string) error {
 	return err
 }
 
-func (f *rwFolder) newError(path string, err error) {
+func (f *sendReceiveFolder) newError(path string, err error) {
 	f.errorsMut.Lock()
 	defer f.errorsMut.Unlock()
 
@@ -1675,13 +1700,13 @@ func (f *rwFolder) newError(path string, err error) {
 	f.errors[path] = err.Error()
 }
 
-func (f *rwFolder) clearErrors() {
+func (f *sendReceiveFolder) clearErrors() {
 	f.errorsMut.Lock()
 	f.errors = make(map[string]string)
 	f.errorsMut.Unlock()
 }
 
-func (f *rwFolder) currentErrors() []fileError {
+func (f *sendReceiveFolder) currentErrors() []fileError {
 	f.errorsMut.Lock()
 	errors := make([]fileError, 0, len(f.errors))
 	for path, err := range f.errors {

lib/model/rwfolder_test.go

@@ -7,12 +7,15 @@
 package model
 
 import (
+	"crypto/rand"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/fs"
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/scanner"
 	"github.com/syncthing/syncthing/lib/sync"
@@ -66,12 +69,14 @@ func setUpModel(file protocol.FileInfo) *Model {
 	return model
 }
 
-func setUpRwFolder(model *Model) rwFolder {
-	return rwFolder{
+func setUpSendReceiveFolder(model *Model) sendReceiveFolder {
+	return sendReceiveFolder{
 		folder: folder{
 			stateTracker: newStateTracker("default"),
 			model:        model,
 		},
+
+		mtimeFS:   fs.NewMtimeFS(db.NewNamespacedKV(model.db, "mtime")),
 		dir:       "testdata",
 		queue:     newJobQueue(),
 		errors:    make(map[string]string),
@@ -95,7 +100,7 @@ func TestHandleFile(t *testing.T) {
 	requiredFile.Blocks = blocks[1:]
 
 	m := setUpModel(existingFile)
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 	copyChan := make(chan copyBlocksState, 1)
 
 	f.handleFile(requiredFile, copyChan, nil)
@@ -136,7 +141,7 @@ func TestHandleFileWithTemp(t *testing.T) {
 	requiredFile.Blocks = blocks[1:]
 
 	m := setUpModel(existingFile)
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 	copyChan := make(chan copyBlocksState, 1)
 
 	f.handleFile(requiredFile, copyChan, nil)
@@ -184,7 +189,7 @@ func TestCopierFinder(t *testing.T) {
 	requiredFile.Name = "file2"
 
 	m := setUpModel(existingFile)
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 	copyChan := make(chan copyBlocksState)
 	pullChan := make(chan pullBlockState, 4)
 	finisherChan := make(chan *sharedPullerState, 1)
@@ -199,7 +204,7 @@ func TestCopierFinder(t *testing.T) {
 
 	select {
 	case <-pullChan:
-		t.Fatal("Finisher channel has data to be read")
+		t.Fatal("Pull channel has data to be read")
 	case <-finisherChan:
 		t.Fatal("Finisher channel has data to be read")
 	default:
@@ -240,6 +245,133 @@ func TestCopierFinder(t *testing.T) {
 	os.Remove(tempFile)
 }
 
+func TestWeakHash(t *testing.T) {
+	tempFile := filepath.Join("testdata", defTempNamer.TempName("weakhash"))
+	var shift int64 = 10
+	var size int64 = 1 << 20
+	expectBlocks := int(size / protocol.BlockSize)
+	expectPulls := int(shift / protocol.BlockSize)
+	if shift > 0 {
+		expectPulls++
+	}
+
+	cleanup := func() {
+		for _, path := range []string{tempFile, "testdata/weakhash"} {
+			os.Remove(path)
+		}
+	}
+
+	cleanup()
+	defer cleanup()
+
+	f, err := os.Create("testdata/weakhash")
+	if err != nil {
+		t.Error(err)
+	}
+	defer f.Close()
+	_, err = io.CopyN(f, rand.Reader, size)
+	if err != nil {
+		t.Error(err)
+	}
+	info, err := f.Stat()
+	if err != nil {
+		t.Error(err)
+	}
+
+	// Create two files, second file has `shifted` bytes random prefix, yet
+	// both are of the same length, for example:
+	// File 1: abcdefgh
+	// File 2: xyabcdef
+	f.Seek(0, os.SEEK_SET)
+	existing, err := scanner.Blocks(f, protocol.BlockSize, size, nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	f.Seek(0, os.SEEK_SET)
+	remainder := io.LimitReader(f, size-shift)
+	prefix := io.LimitReader(rand.Reader, shift)
+	nf := io.MultiReader(prefix, remainder)
+	desired, err := scanner.Blocks(nf, protocol.BlockSize, size, nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	existingFile := protocol.FileInfo{
+		Name:       "weakhash",
+		Blocks:     existing,
+		Size:       size,
+		ModifiedS:  info.ModTime().Unix(),
+		ModifiedNs: int32(info.ModTime().Nanosecond()),
+	}
+	desiredFile := protocol.FileInfo{
+		Name:      "weakhash",
+		Size:      size,
+		Blocks:    desired,
+		ModifiedS: info.ModTime().Unix() + 1,
+	}
+
+	// Setup the model/pull environment
+	m := setUpModel(existingFile)
+	fo := setUpSendReceiveFolder(m)
+	copyChan := make(chan copyBlocksState)
+	pullChan := make(chan pullBlockState, expectBlocks)
+	finisherChan := make(chan *sharedPullerState, 1)
+
+	// Run a single fetcher routine
+	go fo.copierRoutine(copyChan, pullChan, finisherChan)
+
+	// Test 1 - no weak hashing, file gets fully repulled (`expectBlocks` pulls).
+	fo.DisableWeakHash = true
+	fo.handleFile(desiredFile, copyChan, finisherChan)
+
+	var pulls []pullBlockState
+	for len(pulls) < expectBlocks {
+		select {
+		case pull := <-pullChan:
+			pulls = append(pulls, pull)
+		case <-time.After(10 * time.Second):
+			t.Errorf("timed out, got %d pulls expected %d", len(pulls), expectPulls)
+		}
+	}
+	finish := <-finisherChan
+
+	select {
+	case <-pullChan:
+		t.Fatal("Pull channel has data to be read")
+	case <-finisherChan:
+		t.Fatal("Finisher channel has data to be read")
+	default:
+	}
+
+	finish.fd.Close()
+	if err := os.Remove(tempFile); err != nil && !os.IsNotExist(err) {
+		t.Error(err)
+	}
+
+	// Test 2 - using weak hash, expectPulls blocks pulled.
+	fo.DisableWeakHash = false
+	fo.handleFile(desiredFile, copyChan, finisherChan)
+
+	pulls = pulls[:0]
+	for len(pulls) < expectPulls {
+		select {
+		case pull := <-pullChan:
+			pulls = append(pulls, pull)
+		case <-time.After(10 * time.Second):
+			t.Errorf("timed out, got %d pulls expected %d", len(pulls), expectPulls)
+		}
+	}
+
+	finish = <-finisherChan
+	finish.fd.Close()
+
+	expectShifted := expectBlocks - expectPulls
+	if finish.copyOriginShifted != expectShifted {
+		t.Errorf("did not copy %d shifted", expectShifted)
+	}
+}
+
 // Test that updating a file removes it's old blocks from the blockmap
 func TestCopierCleanup(t *testing.T) {
 	iterFn := func(folder, file string, index int32) bool {
@@ -293,7 +425,7 @@ func TestLastResortPulling(t *testing.T) {
 		return true
 	}
 
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 
 	copyChan := make(chan copyBlocksState)
 	pullChan := make(chan pullBlockState, 1)
@@ -331,7 +463,7 @@ func TestDeregisterOnFailInCopy(t *testing.T) {
 	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", db, nil)
 	m.AddFolder(defaultFolderConfig)
 
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 
 	// queue.Done should be called by the finisher routine
 	f.queue.Push("filex", 0, time.Time{})
@@ -404,7 +536,7 @@ func TestDeregisterOnFailInPull(t *testing.T) {
 	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", db, nil)
 	m.AddFolder(defaultFolderConfig)
 
-	f := setUpRwFolder(m)
+	f := setUpSendReceiveFolder(m)
 
 	// queue.Done should be called by the finisher routine
 	f.queue.Push("filex", 0, time.Time{})