2014-11-16 20:13:20 +00:00
|
|
|
// Copyright (C) 2014 The Syncthing Authors.
|
2014-09-29 19:43:32 +00:00
|
|
|
//
|
2015-03-07 20:36:35 +00:00
|
|
|
// 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,
|
2017-02-09 06:52:18 +00:00
|
|
|
// You can obtain one at https://mozilla.org/MPL/2.0/.
|
2014-06-01 20:50:14 +00:00
|
|
|
|
2014-05-15 03:40:17 +00:00
|
|
|
// Package config implements reading and writing of the syncthing configuration file.
|
2014-05-15 00:18:09 +00:00
|
|
|
package config
|
2014-03-02 22:58:14 +00:00
|
|
|
|
|
|
|
import (
|
2015-11-04 20:30:47 +00:00
|
|
|
"encoding/json"
|
2014-03-02 22:58:14 +00:00
|
|
|
"encoding/xml"
|
2022-08-16 08:01:49 +00:00
|
|
|
"errors"
|
2016-07-02 19:38:39 +00:00
|
|
|
"fmt"
|
2014-10-06 07:25:45 +00:00
|
|
|
"io"
|
2017-03-07 12:44:16 +00:00
|
|
|
"net"
|
2016-05-04 19:38:12 +00:00
|
|
|
"net/url"
|
2014-04-22 09:46:08 +00:00
|
|
|
"os"
|
2014-03-02 22:58:14 +00:00
|
|
|
"sort"
|
2017-03-07 12:44:16 +00:00
|
|
|
"strconv"
|
2015-03-07 19:48:53 +00:00
|
|
|
"strings"
|
2014-04-19 11:33:51 +00:00
|
|
|
|
2022-07-28 17:36:39 +00:00
|
|
|
"github.com/syncthing/syncthing/lib/build"
|
2017-08-19 14:36:56 +00:00
|
|
|
"github.com/syncthing/syncthing/lib/fs"
|
2015-09-22 17:38:46 +00:00
|
|
|
"github.com/syncthing/syncthing/lib/protocol"
|
2016-03-25 20:22:29 +00:00
|
|
|
"github.com/syncthing/syncthing/lib/util"
|
2014-03-02 22:58:14 +00:00
|
|
|
)
|
|
|
|
|
2015-04-04 19:49:15 +00:00
|
|
|
const (
|
2015-10-27 10:46:33 +00:00
|
|
|
OldestHandledVersion = 10
|
2022-02-08 06:06:14 +00:00
|
|
|
CurrentVersion = 36
|
2015-06-20 18:21:05 +00:00
|
|
|
MaxRescanIntervalS = 365 * 24 * 60 * 60
|
2015-04-04 19:49:15 +00:00
|
|
|
)
|
2014-10-08 11:52:05 +00:00
|
|
|
|
2015-09-20 13:30:25 +00:00
|
|
|
var (
|
2017-03-07 12:44:16 +00:00
|
|
|
// DefaultTCPPort defines default TCP port used if the URI does not specify one, for example tcp://0.0.0.0
|
|
|
|
DefaultTCPPort = 22000
|
2019-05-29 07:56:40 +00:00
|
|
|
// DefaultQUICPort defines default QUIC port used if the URI does not specify one, for example quic://0.0.0.0
|
|
|
|
DefaultQUICPort = 22000
|
2016-05-04 19:38:12 +00:00
|
|
|
// DefaultListenAddresses should be substituted when the configuration
|
2016-05-17 00:05:38 +00:00
|
|
|
// contains <listenAddress>default</listenAddress>. This is done by the
|
|
|
|
// "consumer" of the configuration as we don't want these saved to the
|
|
|
|
// config.
|
2016-05-04 19:38:12 +00:00
|
|
|
DefaultListenAddresses = []string{
|
2017-03-07 12:44:16 +00:00
|
|
|
util.Address("tcp", net.JoinHostPort("0.0.0.0", strconv.Itoa(DefaultTCPPort))),
|
2016-05-04 19:38:12 +00:00
|
|
|
"dynamic+https://relays.syncthing.net/endpoint",
|
2019-05-29 07:56:40 +00:00
|
|
|
util.Address("quic", net.JoinHostPort("0.0.0.0", strconv.Itoa(DefaultQUICPort))),
|
2016-05-04 19:38:12 +00:00
|
|
|
}
|
2019-02-02 11:43:57 +00:00
|
|
|
DefaultGUIPort = 8384
|
2016-05-04 19:38:12 +00:00
|
|
|
// DefaultDiscoveryServersV4 should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default-v4</globalAnnounceServer>.
|
2015-11-09 14:35:14 +00:00
|
|
|
DefaultDiscoveryServersV4 = []string{
|
2018-01-05 14:18:32 +00:00
|
|
|
"https://discovery.syncthing.net/v2/?noannounce&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
|
|
|
|
"https://discovery-v4.syncthing.net/v2/?nolookup&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
|
2015-11-09 14:35:14 +00:00
|
|
|
}
|
|
|
|
// DefaultDiscoveryServersV6 should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default-v6</globalAnnounceServer>.
|
|
|
|
DefaultDiscoveryServersV6 = []string{
|
2018-01-05 14:18:32 +00:00
|
|
|
"https://discovery.syncthing.net/v2/?noannounce&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
|
|
|
|
"https://discovery-v6.syncthing.net/v2/?nolookup&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
|
2015-09-20 13:30:25 +00:00
|
|
|
}
|
2015-11-09 14:35:14 +00:00
|
|
|
// DefaultDiscoveryServers should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default</globalAnnounceServer>.
|
|
|
|
DefaultDiscoveryServers = append(DefaultDiscoveryServersV4, DefaultDiscoveryServersV6...)
|
2016-01-10 15:37:31 +00:00
|
|
|
// DefaultTheme is the default and fallback theme for the web UI.
|
|
|
|
DefaultTheme = "default"
|
2019-05-29 07:56:40 +00:00
|
|
|
// Default stun servers should be substituted when the configuration
|
|
|
|
// contains <stunServer>default</stunServer>.
|
|
|
|
|
|
|
|
// DefaultPrimaryStunServers are servers provided by us (to avoid causing the public servers burden)
|
|
|
|
DefaultPrimaryStunServers = []string{
|
|
|
|
"stun.syncthing.net:3478",
|
|
|
|
}
|
|
|
|
DefaultSecondaryStunServers = []string{
|
|
|
|
"stun.callwithus.com:3478",
|
|
|
|
"stun.counterpath.com:3478",
|
|
|
|
"stun.counterpath.net:3478",
|
|
|
|
"stun.ekiga.net:3478",
|
|
|
|
"stun.ideasip.com:3478",
|
|
|
|
"stun.internetcalls.com:3478",
|
|
|
|
"stun.schlund.de:3478",
|
|
|
|
"stun.sipgate.net:10000",
|
|
|
|
"stun.sipgate.net:3478",
|
|
|
|
"stun.voip.aebc.com:3478",
|
|
|
|
"stun.voiparound.com:3478",
|
|
|
|
"stun.voipbuster.com:3478",
|
|
|
|
"stun.voipstunt.com:3478",
|
|
|
|
"stun.xten.com:3478",
|
|
|
|
}
|
2015-09-20 13:30:25 +00:00
|
|
|
)
|
|
|
|
|
2019-07-14 09:03:14 +00:00
|
|
|
var (
|
|
|
|
errFolderIDEmpty = errors.New("folder has empty ID")
|
|
|
|
errFolderIDDuplicate = errors.New("folder has duplicate ID")
|
|
|
|
errFolderPathEmpty = errors.New("folder has empty path")
|
|
|
|
)
|
|
|
|
|
2015-10-27 11:04:51 +00:00
|
|
|
func New(myID protocol.DeviceID) Configuration {
|
|
|
|
var cfg Configuration
|
|
|
|
cfg.Version = CurrentVersion
|
|
|
|
|
2020-06-02 10:08:22 +00:00
|
|
|
cfg.Options.UnackedNotificationIDs = []string{"authenticationUserAndPassword"}
|
|
|
|
|
2019-02-02 11:16:27 +00:00
|
|
|
util.SetDefaults(&cfg)
|
2015-10-27 11:04:51 +00:00
|
|
|
|
2016-08-07 16:21:59 +00:00
|
|
|
// Can't happen.
|
|
|
|
if err := cfg.prepare(myID); err != nil {
|
2019-07-31 08:53:35 +00:00
|
|
|
l.Warnln("bug: error in preparing new folder:", err)
|
|
|
|
panic("error in preparing new folder")
|
2016-08-07 16:21:59 +00:00
|
|
|
}
|
2015-10-27 11:04:51 +00:00
|
|
|
|
|
|
|
return cfg
|
|
|
|
}
|
|
|
|
|
2022-01-07 10:19:17 +00:00
|
|
|
func (cfg *Configuration) ProbeFreePorts() error {
|
2019-02-02 11:43:57 +00:00
|
|
|
port, err := getFreePort("127.0.0.1", DefaultGUIPort)
|
|
|
|
if err != nil {
|
2022-08-16 08:01:49 +00:00
|
|
|
return fmt.Errorf("get free port (GUI): %w", err)
|
2019-02-02 11:43:57 +00:00
|
|
|
}
|
|
|
|
cfg.GUI.RawAddress = fmt.Sprintf("127.0.0.1:%d", port)
|
|
|
|
|
|
|
|
port, err = getFreePort("0.0.0.0", DefaultTCPPort)
|
|
|
|
if err != nil {
|
2022-08-16 08:01:49 +00:00
|
|
|
return fmt.Errorf("get free port (BEP): %w", err)
|
2019-02-02 11:43:57 +00:00
|
|
|
}
|
|
|
|
if port == DefaultTCPPort {
|
2019-11-26 16:07:25 +00:00
|
|
|
cfg.Options.RawListenAddresses = []string{"default"}
|
2019-02-02 11:43:57 +00:00
|
|
|
} else {
|
2019-11-26 16:07:25 +00:00
|
|
|
cfg.Options.RawListenAddresses = []string{
|
2020-06-02 14:06:02 +00:00
|
|
|
util.Address("tcp", net.JoinHostPort("0.0.0.0", strconv.Itoa(port))),
|
2019-02-02 11:43:57 +00:00
|
|
|
"dynamic+https://relays.syncthing.net/endpoint",
|
2020-06-02 14:06:02 +00:00
|
|
|
util.Address("quic", net.JoinHostPort("0.0.0.0", strconv.Itoa(port))),
|
2019-02-02 11:43:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-07 10:19:17 +00:00
|
|
|
return nil
|
2019-02-02 11:43:57 +00:00
|
|
|
}
|
|
|
|
|
2020-08-25 06:11:14 +00:00
|
|
|
type xmlConfiguration struct {
|
|
|
|
Configuration
|
|
|
|
XMLName xml.Name `xml:"configuration"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func ReadXML(r io.Reader, myID protocol.DeviceID) (Configuration, int, error) {
|
|
|
|
var cfg xmlConfiguration
|
2015-10-27 11:04:51 +00:00
|
|
|
|
2019-02-02 11:16:27 +00:00
|
|
|
util.SetDefaults(&cfg)
|
2015-10-27 11:04:51 +00:00
|
|
|
|
2016-07-02 19:38:39 +00:00
|
|
|
if err := xml.NewDecoder(r).Decode(&cfg); err != nil {
|
2020-08-25 06:11:14 +00:00
|
|
|
return Configuration{}, 0, err
|
2016-07-02 19:38:39 +00:00
|
|
|
}
|
2020-08-25 06:11:14 +00:00
|
|
|
|
|
|
|
originalVersion := cfg.Version
|
2015-10-27 11:04:51 +00:00
|
|
|
|
2016-07-02 19:38:39 +00:00
|
|
|
if err := cfg.prepare(myID); err != nil {
|
2020-08-25 06:11:14 +00:00
|
|
|
return Configuration{}, originalVersion, err
|
2016-07-02 19:38:39 +00:00
|
|
|
}
|
2020-08-25 06:11:14 +00:00
|
|
|
return cfg.Configuration, originalVersion, nil
|
2015-10-27 11:04:51 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 20:30:47 +00:00
|
|
|
func ReadJSON(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
|
2021-11-22 07:59:47 +00:00
|
|
|
bs, err := io.ReadAll(r)
|
2021-06-03 13:09:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return Configuration{}, err
|
|
|
|
}
|
|
|
|
|
2015-11-04 20:30:47 +00:00
|
|
|
var cfg Configuration
|
|
|
|
|
2019-02-02 11:16:27 +00:00
|
|
|
util.SetDefaults(&cfg)
|
2015-11-04 20:30:47 +00:00
|
|
|
|
2021-06-03 13:09:35 +00:00
|
|
|
if err := json.Unmarshal(bs, &cfg); err != nil {
|
2016-07-02 19:38:39 +00:00
|
|
|
return Configuration{}, err
|
2016-05-06 22:01:56 +00:00
|
|
|
}
|
|
|
|
|
2021-06-03 13:09:35 +00:00
|
|
|
// Unmarshal list of devices and folders separately to set defaults
|
|
|
|
var rawFoldersDevices struct {
|
|
|
|
Folders []json.RawMessage
|
|
|
|
Devices []json.RawMessage
|
|
|
|
}
|
|
|
|
if err := json.Unmarshal(bs, &rawFoldersDevices); err != nil {
|
2016-07-15 14:23:20 +00:00
|
|
|
return Configuration{}, err
|
|
|
|
}
|
2015-11-04 20:30:47 +00:00
|
|
|
|
2021-06-03 13:09:35 +00:00
|
|
|
cfg.Folders = make([]FolderConfiguration, len(rawFoldersDevices.Folders))
|
|
|
|
for i, bs := range rawFoldersDevices.Folders {
|
|
|
|
cfg.Folders[i] = cfg.Defaults.Folder.Copy()
|
|
|
|
if err := json.Unmarshal(bs, &cfg.Folders[i]); err != nil {
|
|
|
|
return Configuration{}, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.Devices = make([]DeviceConfiguration, len(rawFoldersDevices.Devices))
|
|
|
|
for i, bs := range rawFoldersDevices.Devices {
|
|
|
|
cfg.Devices[i] = cfg.Defaults.Device.Copy()
|
|
|
|
if err := json.Unmarshal(bs, &cfg.Devices[i]); err != nil {
|
|
|
|
return Configuration{}, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-02 19:38:39 +00:00
|
|
|
if err := cfg.prepare(myID); err != nil {
|
|
|
|
return Configuration{}, err
|
|
|
|
}
|
|
|
|
return cfg, nil
|
2015-11-04 20:30:47 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 20:32:10 +00:00
|
|
|
func (cfg Configuration) Copy() Configuration {
|
|
|
|
newCfg := cfg
|
2015-04-05 15:36:52 +00:00
|
|
|
|
|
|
|
// Deep copy FolderConfigurations
|
2015-04-28 20:32:10 +00:00
|
|
|
newCfg.Folders = make([]FolderConfiguration, len(cfg.Folders))
|
|
|
|
for i := range newCfg.Folders {
|
|
|
|
newCfg.Folders[i] = cfg.Folders[i].Copy()
|
2015-04-05 15:36:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Deep copy DeviceConfigurations
|
2015-04-28 20:32:10 +00:00
|
|
|
newCfg.Devices = make([]DeviceConfiguration, len(cfg.Devices))
|
|
|
|
for i := range newCfg.Devices {
|
|
|
|
newCfg.Devices[i] = cfg.Devices[i].Copy()
|
2015-04-05 15:36:52 +00:00
|
|
|
}
|
|
|
|
|
2015-04-28 20:32:10 +00:00
|
|
|
newCfg.Options = cfg.Options.Copy()
|
2018-07-26 21:14:12 +00:00
|
|
|
newCfg.GUI = cfg.GUI.Copy()
|
2015-04-05 15:36:52 +00:00
|
|
|
|
|
|
|
// DeviceIDs are values
|
2018-08-25 10:36:10 +00:00
|
|
|
newCfg.IgnoredDevices = make([]ObservedDevice, len(cfg.IgnoredDevices))
|
2015-04-28 20:32:10 +00:00
|
|
|
copy(newCfg.IgnoredDevices, cfg.IgnoredDevices)
|
2015-04-05 15:36:52 +00:00
|
|
|
|
2015-04-28 20:32:10 +00:00
|
|
|
return newCfg
|
2015-04-05 15:36:52 +00:00
|
|
|
}
|
|
|
|
|
2014-10-06 07:25:45 +00:00
|
|
|
func (cfg *Configuration) WriteXML(w io.Writer) error {
|
|
|
|
e := xml.NewEncoder(w)
|
|
|
|
e.Indent("", " ")
|
2020-08-25 06:11:14 +00:00
|
|
|
xmlCfg := xmlConfiguration{Configuration: *cfg}
|
|
|
|
err := e.Encode(xmlCfg)
|
2014-10-06 07:25:45 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
_, err = w.Write([]byte("\n"))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-07-02 19:38:39 +00:00
|
|
|
func (cfg *Configuration) prepare(myID protocol.DeviceID) error {
|
2020-11-20 13:21:54 +00:00
|
|
|
cfg.ensureMyDevice(myID)
|
2016-08-07 16:21:59 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
existingDevices, err := cfg.prepareFoldersAndDevices(myID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.GUI.prepare()
|
|
|
|
|
|
|
|
guiPWIsSet := cfg.GUI.User != "" && cfg.GUI.Password != ""
|
|
|
|
cfg.Options.prepare(guiPWIsSet)
|
|
|
|
|
2020-12-17 18:54:31 +00:00
|
|
|
cfg.prepareIgnoredDevices(existingDevices)
|
2020-11-20 13:21:54 +00:00
|
|
|
|
2021-02-04 20:10:41 +00:00
|
|
|
cfg.Defaults.prepare(myID, existingDevices)
|
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
cfg.removeDeprecatedProtocols()
|
|
|
|
|
|
|
|
util.FillNilExceptDeprecated(cfg)
|
|
|
|
|
|
|
|
// TestIssue1750 relies on migrations happening after preparing options.
|
|
|
|
cfg.applyMigrations()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cfg *Configuration) ensureMyDevice(myID protocol.DeviceID) {
|
2016-08-07 16:21:59 +00:00
|
|
|
for _, device := range cfg.Devices {
|
|
|
|
if device.DeviceID == myID {
|
2020-11-20 13:21:54 +00:00
|
|
|
return
|
2016-08-07 16:21:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
myName, _ := os.Hostname()
|
2016-08-07 16:21:59 +00:00
|
|
|
cfg.Devices = append(cfg.Devices, DeviceConfiguration{
|
|
|
|
DeviceID: myID,
|
|
|
|
Name: myName,
|
|
|
|
})
|
2020-11-20 13:21:54 +00:00
|
|
|
}
|
2016-08-07 16:21:59 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) prepareFoldersAndDevices(myID protocol.DeviceID) (map[protocol.DeviceID]bool, error) {
|
|
|
|
existingDevices := cfg.prepareDeviceList()
|
2016-08-07 16:21:59 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
sharedFolders, err := cfg.prepareFolders(myID, existingDevices)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2016-08-07 16:21:59 +00:00
|
|
|
}
|
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
cfg.prepareDevices(sharedFolders)
|
2016-08-07 16:21:59 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
return existingDevices, nil
|
2016-08-07 16:21:59 +00:00
|
|
|
}
|
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) prepareDeviceList() map[protocol.DeviceID]bool {
|
2019-07-17 05:19:14 +00:00
|
|
|
// Ensure that the device list is
|
|
|
|
// - free from duplicates
|
|
|
|
// - no devices with empty ID
|
|
|
|
// - sorted by ID
|
|
|
|
// Happen before preparting folders as that needs a correct device list.
|
|
|
|
cfg.Devices = ensureNoDuplicateOrEmptyIDDevices(cfg.Devices)
|
|
|
|
sort.Slice(cfg.Devices, func(a, b int) bool {
|
|
|
|
return cfg.Devices[a].DeviceID.Compare(cfg.Devices[b].DeviceID) == -1
|
|
|
|
})
|
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
// Build a list of available devices
|
|
|
|
existingDevices := make(map[protocol.DeviceID]bool, len(cfg.Devices))
|
|
|
|
for _, device := range cfg.Devices {
|
|
|
|
existingDevices[device.DeviceID] = true
|
|
|
|
}
|
|
|
|
return existingDevices
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cfg *Configuration) prepareFolders(myID protocol.DeviceID, existingDevices map[protocol.DeviceID]bool) (map[protocol.DeviceID][]string, error) {
|
2016-07-02 19:38:39 +00:00
|
|
|
// Prepare folders and check for duplicates. Duplicates are bad and
|
|
|
|
// dangerous, can't currently be resolved in the GUI, and shouldn't
|
|
|
|
// happen when configured by the GUI. We return with an error in that
|
|
|
|
// situation.
|
2020-11-20 13:21:54 +00:00
|
|
|
sharedFolders := make(map[protocol.DeviceID][]string, len(cfg.Devices))
|
|
|
|
existingFolders := make(map[string]*FolderConfiguration, len(cfg.Folders))
|
2014-09-28 11:00:38 +00:00
|
|
|
for i := range cfg.Folders {
|
|
|
|
folder := &cfg.Folders[i]
|
2015-06-20 18:21:05 +00:00
|
|
|
|
2018-01-27 09:06:37 +00:00
|
|
|
if folder.ID == "" {
|
2020-11-20 13:21:54 +00:00
|
|
|
return nil, errFolderIDEmpty
|
2019-07-14 09:03:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if folder.Path == "" {
|
2020-11-20 13:21:54 +00:00
|
|
|
return nil, fmt.Errorf("folder %q: %w", folder.ID, errFolderPathEmpty)
|
2018-01-27 09:06:37 +00:00
|
|
|
}
|
|
|
|
|
2018-08-25 10:36:10 +00:00
|
|
|
if _, ok := existingFolders[folder.ID]; ok {
|
2020-11-20 13:21:54 +00:00
|
|
|
return nil, fmt.Errorf("folder %q: %w", folder.ID, errFolderIDDuplicate)
|
2014-03-29 17:53:48 +00:00
|
|
|
}
|
2019-07-14 09:03:14 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
folder.prepare(myID, existingDevices)
|
2015-06-23 12:55:30 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
existingFolders[folder.ID] = folder
|
2014-11-20 21:24:11 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
for _, dev := range folder.Devices {
|
|
|
|
sharedFolders[dev.DeviceID] = append(sharedFolders[dev.DeviceID], folder.ID)
|
|
|
|
}
|
2014-07-22 21:27:00 +00:00
|
|
|
}
|
2018-04-22 16:01:52 +00:00
|
|
|
// Ensure that the folder list is sorted by ID
|
2018-08-25 10:36:10 +00:00
|
|
|
sort.Slice(cfg.Folders, func(a, b int) bool {
|
|
|
|
return cfg.Folders[a].ID < cfg.Folders[b].ID
|
|
|
|
})
|
2020-11-20 13:21:54 +00:00
|
|
|
return sharedFolders, nil
|
|
|
|
}
|
2018-08-25 10:36:10 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) prepareDevices(sharedFolders map[protocol.DeviceID][]string) {
|
2014-09-28 11:00:38 +00:00
|
|
|
for i := range cfg.Devices {
|
2018-08-25 10:36:10 +00:00
|
|
|
cfg.Devices[i].prepare(sharedFolders[cfg.Devices[i].DeviceID])
|
2014-04-22 09:46:08 +00:00
|
|
|
}
|
2020-11-20 13:21:54 +00:00
|
|
|
}
|
2014-11-18 22:57:21 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) prepareIgnoredDevices(existingDevices map[protocol.DeviceID]bool) map[protocol.DeviceID]bool {
|
2016-08-05 09:29:49 +00:00
|
|
|
// The list of ignored devices should not contain any devices that have
|
|
|
|
// been manually added to the config.
|
2020-11-20 13:21:54 +00:00
|
|
|
newIgnoredDevices := cfg.IgnoredDevices[:0]
|
|
|
|
ignoredDevices := make(map[protocol.DeviceID]bool, len(cfg.IgnoredDevices))
|
2016-08-05 09:29:49 +00:00
|
|
|
for _, dev := range cfg.IgnoredDevices {
|
2018-08-25 10:36:10 +00:00
|
|
|
if !existingDevices[dev.ID] {
|
|
|
|
ignoredDevices[dev.ID] = true
|
2016-08-05 09:29:49 +00:00
|
|
|
newIgnoredDevices = append(newIgnoredDevices, dev)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cfg.IgnoredDevices = newIgnoredDevices
|
2020-11-20 13:21:54 +00:00
|
|
|
return ignoredDevices
|
|
|
|
}
|
2016-08-05 09:29:49 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) removeDeprecatedProtocols() {
|
2018-02-09 10:40:57 +00:00
|
|
|
// Deprecated protocols are removed from the list of listeners and
|
|
|
|
// device addresses. So far just kcp*.
|
|
|
|
for _, prefix := range []string{"kcp"} {
|
2019-11-26 16:07:25 +00:00
|
|
|
cfg.Options.RawListenAddresses = filterURLSchemePrefix(cfg.Options.RawListenAddresses, prefix)
|
2018-02-09 10:40:57 +00:00
|
|
|
for i := range cfg.Devices {
|
|
|
|
dev := &cfg.Devices[i]
|
|
|
|
dev.Addresses = filterURLSchemePrefix(dev.Addresses, prefix)
|
|
|
|
}
|
|
|
|
}
|
2020-11-20 13:21:54 +00:00
|
|
|
}
|
2018-02-09 10:40:57 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
func (cfg *Configuration) applyMigrations() {
|
|
|
|
if cfg.Version > 0 && cfg.Version < OldestHandledVersion {
|
|
|
|
l.Warnf("Configuration version %d is deprecated. Attempting best effort conversion, but please verify manually.", cfg.Version)
|
2020-11-09 14:33:32 +00:00
|
|
|
}
|
2018-08-25 10:36:10 +00:00
|
|
|
|
2020-11-20 13:21:54 +00:00
|
|
|
// Upgrade configuration versions as appropriate
|
|
|
|
migrationsMut.Lock()
|
|
|
|
migrations.apply(cfg)
|
|
|
|
migrationsMut.Unlock()
|
2014-09-06 12:11:18 +00:00
|
|
|
}
|
|
|
|
|
2021-01-15 14:43:34 +00:00
|
|
|
func (cfg *Configuration) Device(id protocol.DeviceID) (DeviceConfiguration, int, bool) {
|
|
|
|
for i, device := range cfg.Devices {
|
|
|
|
if device.DeviceID == id {
|
|
|
|
return device, i, true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return DeviceConfiguration{}, 0, false
|
|
|
|
}
|
|
|
|
|
2018-03-26 10:56:50 +00:00
|
|
|
// DeviceMap returns a map of device ID to device configuration for the given configuration.
|
|
|
|
func (cfg *Configuration) DeviceMap() map[protocol.DeviceID]DeviceConfiguration {
|
|
|
|
m := make(map[protocol.DeviceID]DeviceConfiguration, len(cfg.Devices))
|
|
|
|
for _, dev := range cfg.Devices {
|
|
|
|
m[dev.DeviceID] = dev
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2021-01-15 14:43:34 +00:00
|
|
|
func (cfg *Configuration) SetDevice(device DeviceConfiguration) {
|
|
|
|
cfg.SetDevices([]DeviceConfiguration{device})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cfg *Configuration) SetDevices(devices []DeviceConfiguration) {
|
|
|
|
inds := make(map[protocol.DeviceID]int, len(cfg.Devices))
|
|
|
|
for i, device := range cfg.Devices {
|
|
|
|
inds[device.DeviceID] = i
|
|
|
|
}
|
|
|
|
filtered := devices[:0]
|
|
|
|
for _, device := range devices {
|
|
|
|
if i, ok := inds[device.DeviceID]; ok {
|
|
|
|
cfg.Devices[i] = device
|
|
|
|
} else {
|
|
|
|
filtered = append(filtered, device)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cfg.Devices = append(cfg.Devices, filtered...)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cfg *Configuration) Folder(id string) (FolderConfiguration, int, bool) {
|
|
|
|
for i, folder := range cfg.Folders {
|
|
|
|
if folder.ID == id {
|
|
|
|
return folder, i, true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FolderConfiguration{}, 0, false
|
|
|
|
}
|
|
|
|
|
|
|
|
// FolderMap returns a map of folder ID to folder configuration for the given configuration.
|
|
|
|
func (cfg *Configuration) FolderMap() map[string]FolderConfiguration {
|
|
|
|
m := make(map[string]FolderConfiguration, len(cfg.Folders))
|
|
|
|
for _, folder := range cfg.Folders {
|
|
|
|
m[folder.ID] = folder
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2020-11-09 14:33:32 +00:00
|
|
|
// FolderPasswords returns the folder passwords set for this device, for
|
|
|
|
// folders that have an encryption password set.
|
|
|
|
func (cfg Configuration) FolderPasswords(device protocol.DeviceID) map[string]string {
|
|
|
|
res := make(map[string]string, len(cfg.Folders))
|
|
|
|
for _, folder := range cfg.Folders {
|
2021-06-17 11:53:02 +00:00
|
|
|
if dev, ok := folder.Device(device); ok && dev.EncryptionPassword != "" {
|
|
|
|
res[folder.ID] = dev.EncryptionPassword
|
2020-11-09 14:33:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
2021-01-15 14:43:34 +00:00
|
|
|
func (cfg *Configuration) SetFolder(folder FolderConfiguration) {
|
|
|
|
cfg.SetFolders([]FolderConfiguration{folder})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cfg *Configuration) SetFolders(folders []FolderConfiguration) {
|
|
|
|
inds := make(map[string]int, len(cfg.Folders))
|
|
|
|
for i, folder := range cfg.Folders {
|
|
|
|
inds[folder.ID] = i
|
|
|
|
}
|
|
|
|
filtered := folders[:0]
|
|
|
|
for _, folder := range folders {
|
|
|
|
if i, ok := inds[folder.ID]; ok {
|
|
|
|
cfg.Folders[i] = folder
|
|
|
|
} else {
|
|
|
|
filtered = append(filtered, folder)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cfg.Folders = append(cfg.Folders, filtered...)
|
|
|
|
}
|
|
|
|
|
2014-09-28 11:00:38 +00:00
|
|
|
func ensureDevicePresent(devices []FolderDeviceConfiguration, myID protocol.DeviceID) []FolderDeviceConfiguration {
|
|
|
|
for _, device := range devices {
|
|
|
|
if device.DeviceID.Equals(myID) {
|
|
|
|
return devices
|
2014-03-02 22:58:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-28 11:00:38 +00:00
|
|
|
devices = append(devices, FolderDeviceConfiguration{
|
|
|
|
DeviceID: myID,
|
2014-07-27 23:20:36 +00:00
|
|
|
})
|
2014-03-02 22:58:14 +00:00
|
|
|
|
2014-09-28 11:00:38 +00:00
|
|
|
return devices
|
2014-03-02 22:58:14 +00:00
|
|
|
}
|
2014-07-22 21:27:00 +00:00
|
|
|
|
2014-09-28 11:00:38 +00:00
|
|
|
func ensureExistingDevices(devices []FolderDeviceConfiguration, existingDevices map[protocol.DeviceID]bool) []FolderDeviceConfiguration {
|
|
|
|
count := len(devices)
|
2014-07-22 21:27:00 +00:00
|
|
|
i := 0
|
2014-07-27 23:08:15 +00:00
|
|
|
loop:
|
|
|
|
for i < count {
|
2014-09-28 11:00:38 +00:00
|
|
|
if _, ok := existingDevices[devices[i].DeviceID]; !ok {
|
|
|
|
devices[i] = devices[count-1]
|
2014-07-27 23:08:15 +00:00
|
|
|
count--
|
|
|
|
continue loop
|
2014-07-22 21:27:00 +00:00
|
|
|
}
|
2014-07-27 23:08:15 +00:00
|
|
|
i++
|
2014-07-22 21:27:00 +00:00
|
|
|
}
|
2014-09-28 11:00:38 +00:00
|
|
|
return devices[0:count]
|
2014-07-22 21:27:00 +00:00
|
|
|
}
|
2014-07-27 23:15:16 +00:00
|
|
|
|
2015-12-31 08:17:17 +00:00
|
|
|
func ensureNoDuplicateFolderDevices(devices []FolderDeviceConfiguration) []FolderDeviceConfiguration {
|
|
|
|
count := len(devices)
|
|
|
|
i := 0
|
|
|
|
seenDevices := make(map[protocol.DeviceID]bool)
|
|
|
|
loop:
|
|
|
|
for i < count {
|
|
|
|
id := devices[i].DeviceID
|
|
|
|
if _, ok := seenDevices[id]; ok {
|
|
|
|
devices[i] = devices[count-1]
|
|
|
|
count--
|
|
|
|
continue loop
|
|
|
|
}
|
|
|
|
seenDevices[id] = true
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
return devices[0:count]
|
|
|
|
}
|
|
|
|
|
2019-07-17 05:19:14 +00:00
|
|
|
func ensureNoDuplicateOrEmptyIDDevices(devices []DeviceConfiguration) []DeviceConfiguration {
|
2014-09-28 11:00:38 +00:00
|
|
|
count := len(devices)
|
2014-07-27 23:15:16 +00:00
|
|
|
i := 0
|
2014-09-28 11:00:38 +00:00
|
|
|
seenDevices := make(map[protocol.DeviceID]bool)
|
2014-07-27 23:15:16 +00:00
|
|
|
loop:
|
|
|
|
for i < count {
|
2014-09-28 11:00:38 +00:00
|
|
|
id := devices[i].DeviceID
|
2019-07-17 05:19:14 +00:00
|
|
|
if _, ok := seenDevices[id]; ok || id == protocol.EmptyDeviceID {
|
2014-09-28 11:00:38 +00:00
|
|
|
devices[i] = devices[count-1]
|
2014-07-27 23:15:16 +00:00
|
|
|
count--
|
|
|
|
continue loop
|
|
|
|
}
|
2014-09-28 11:00:38 +00:00
|
|
|
seenDevices[id] = true
|
2014-07-27 23:15:16 +00:00
|
|
|
i++
|
|
|
|
}
|
2014-09-28 11:00:38 +00:00
|
|
|
return devices[0:count]
|
2014-07-27 23:15:16 +00:00
|
|
|
}
|
2017-08-08 13:13:08 +00:00
|
|
|
|
2017-08-19 14:36:56 +00:00
|
|
|
func cleanSymlinks(filesystem fs.Filesystem, dir string) {
|
2022-07-28 17:36:39 +00:00
|
|
|
if build.IsWindows {
|
2017-08-08 13:13:08 +00:00
|
|
|
// We don't do symlinks on Windows. Additionally, there may
|
|
|
|
// be things that look like symlinks that are not, which we
|
|
|
|
// should leave alone. Deduplicated files, for example.
|
|
|
|
return
|
|
|
|
}
|
2019-02-02 11:16:27 +00:00
|
|
|
filesystem.Walk(dir, func(path string, info fs.FileInfo, err error) error {
|
2017-08-08 13:13:08 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-19 14:36:56 +00:00
|
|
|
if info.IsSymlink() {
|
2017-08-08 13:13:08 +00:00
|
|
|
l.Infoln("Removing incorrectly versioned symlink", path)
|
2019-02-02 11:16:27 +00:00
|
|
|
filesystem.Remove(path)
|
2017-08-19 14:36:56 +00:00
|
|
|
return fs.SkipDir
|
2017-08-08 13:13:08 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
}
|
2018-02-09 10:40:57 +00:00
|
|
|
|
|
|
|
// filterURLSchemePrefix returns the list of addresses after removing all
|
|
|
|
// entries whose URL scheme matches the given prefix.
|
|
|
|
func filterURLSchemePrefix(addrs []string, prefix string) []string {
|
|
|
|
for i := 0; i < len(addrs); i++ {
|
|
|
|
uri, err := url.Parse(addrs[i])
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if strings.HasPrefix(uri.Scheme, prefix) {
|
|
|
|
// Remove this entry
|
|
|
|
copy(addrs[i:], addrs[i+1:])
|
|
|
|
addrs = addrs[:len(addrs)-1]
|
|
|
|
i--
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return addrs
|
|
|
|
}
|
2019-02-02 11:43:57 +00:00
|
|
|
|
|
|
|
// tried in succession and the first to succeed is returned. If none succeed,
|
|
|
|
// a random high port is returned.
|
|
|
|
func getFreePort(host string, ports ...int) (int, error) {
|
|
|
|
for _, port := range ports {
|
2022-07-28 20:06:55 +00:00
|
|
|
c, err := net.Listen("tcp", net.JoinHostPort(host, strconv.Itoa(port)))
|
2019-02-02 11:43:57 +00:00
|
|
|
if err == nil {
|
|
|
|
c.Close()
|
|
|
|
return port, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
c, err := net.Listen("tcp", host+":0")
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
addr := c.Addr().(*net.TCPAddr)
|
|
|
|
c.Close()
|
|
|
|
return addr.Port, nil
|
|
|
|
}
|
2021-02-04 20:10:41 +00:00
|
|
|
|
|
|
|
func (defaults *Defaults) prepare(myID protocol.DeviceID, existingDevices map[protocol.DeviceID]bool) {
|
|
|
|
ensureZeroForNodefault(&FolderConfiguration{}, &defaults.Folder)
|
|
|
|
ensureZeroForNodefault(&DeviceConfiguration{}, &defaults.Device)
|
|
|
|
defaults.Folder.prepare(myID, existingDevices)
|
|
|
|
defaults.Device.prepare(nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func ensureZeroForNodefault(empty interface{}, target interface{}) {
|
|
|
|
util.CopyMatchingTag(empty, target, "nodefault", func(v string) bool {
|
|
|
|
if len(v) > 0 && v != "true" {
|
|
|
|
panic(fmt.Sprintf(`unexpected tag value: %s. expected untagged or "true"`, v))
|
|
|
|
}
|
|
|
|
return len(v) > 0
|
|
|
|
})
|
|
|
|
}
|
2022-01-13 22:38:21 +00:00
|
|
|
|
|
|
|
func (i Ignores) Copy() Ignores {
|
|
|
|
out := Ignores{Lines: make([]string, len(i.Lines))}
|
|
|
|
copy(out.Lines, i.Lines)
|
|
|
|
return out
|
|
|
|
}
|