mirror of
https://github.com/octoleo/syncthing.git
synced 2024-11-10 07:11:08 +00:00
8265dac127
The locking protocol in nat.Mapping was racy:
* Mapping.addressMap RLock'd, but then returned a map shared between
caller and Mapping, so the lock didn't do anything.
* Operations inside Service.{verifyExistingMappings,acquireNewMappings}
would lock the map for every update, but that means callers to
Mapping.ExternalAddresses can be looping over the map while the
Service methods are concurrently modifying it. When the Go runtime
detects that happening, it panics.
* Mapping.expires was read and updated without locking.
The Service methods now lock the map once and release the lock only when
done.
Also, subscribers no longer get the added and removed addresses, because
none of them were using the information. This was changed for a previous
attempt to retain the fine-grained locking and not reverted because it
simplifies the code.
131 lines
3.0 KiB
Go
131 lines
3.0 KiB
Go
// Copyright (C) 2015 The Syncthing Authors.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
|
|
package nat
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/syncthing/syncthing/lib/sync"
|
|
)
|
|
|
|
type MappingChangeSubscriber func()
|
|
|
|
type Mapping struct {
|
|
protocol Protocol
|
|
address Address
|
|
|
|
extAddresses map[string]Address // NAT ID -> Address
|
|
expires time.Time
|
|
subscribers []MappingChangeSubscriber
|
|
mut sync.RWMutex
|
|
}
|
|
|
|
func (m *Mapping) setAddressLocked(id string, address Address) {
|
|
l.Infof("New NAT port mapping: external %s address %s to local address %s.", m.protocol, address, m.address)
|
|
m.extAddresses[id] = address
|
|
}
|
|
|
|
func (m *Mapping) removeAddressLocked(id string) {
|
|
addr, ok := m.extAddresses[id]
|
|
if ok {
|
|
l.Infof("Removing NAT port mapping: external %s address %s, NAT %s is no longer available.", m.protocol, addr, id)
|
|
delete(m.extAddresses, id)
|
|
}
|
|
}
|
|
|
|
func (m *Mapping) clearAddresses() {
|
|
m.mut.Lock()
|
|
change := len(m.extAddresses) > 0
|
|
for id, addr := range m.extAddresses {
|
|
l.Debugf("Clearing mapping %s: ID: %s Address: %s", m, id, addr)
|
|
delete(m.extAddresses, id)
|
|
}
|
|
m.expires = time.Time{}
|
|
m.mut.Unlock()
|
|
if change {
|
|
m.notify()
|
|
}
|
|
}
|
|
|
|
func (m *Mapping) notify() {
|
|
m.mut.RLock()
|
|
for _, subscriber := range m.subscribers {
|
|
subscriber()
|
|
}
|
|
m.mut.RUnlock()
|
|
}
|
|
|
|
func (m *Mapping) Protocol() Protocol {
|
|
return m.protocol
|
|
}
|
|
|
|
func (m *Mapping) Address() Address {
|
|
return m.address
|
|
}
|
|
|
|
func (m *Mapping) ExternalAddresses() []Address {
|
|
m.mut.RLock()
|
|
addrs := make([]Address, 0, len(m.extAddresses))
|
|
for _, addr := range m.extAddresses {
|
|
addrs = append(addrs, addr)
|
|
}
|
|
m.mut.RUnlock()
|
|
return addrs
|
|
}
|
|
|
|
func (m *Mapping) OnChanged(subscribed MappingChangeSubscriber) {
|
|
m.mut.Lock()
|
|
m.subscribers = append(m.subscribers, subscribed)
|
|
m.mut.Unlock()
|
|
}
|
|
|
|
func (m *Mapping) String() string {
|
|
return fmt.Sprintf("%s %s", m.protocol, m.address)
|
|
}
|
|
|
|
func (m *Mapping) GoString() string {
|
|
return m.String()
|
|
}
|
|
|
|
// Checks if the mappings local IP address matches the IP address of the gateway
|
|
// For example, if we are explicitly listening on 192.168.0.12, there is no
|
|
// point trying to acquire a mapping on a gateway to which the local IP is
|
|
// 10.0.0.1. Fallback to true if any of the IPs is not there.
|
|
func (m *Mapping) validGateway(ip net.IP) bool {
|
|
if m.address.IP == nil || ip == nil || m.address.IP.IsUnspecified() || ip.IsUnspecified() {
|
|
return true
|
|
}
|
|
return m.address.IP.Equal(ip)
|
|
}
|
|
|
|
// Address is essentially net.TCPAddr yet is more general, and has a few helper
|
|
// methods which reduce boilerplate code.
|
|
type Address struct {
|
|
IP net.IP
|
|
Port int
|
|
}
|
|
|
|
func (a Address) Equal(b Address) bool {
|
|
return a.Port == b.Port && a.IP.Equal(b.IP)
|
|
}
|
|
|
|
func (a Address) String() string {
|
|
var ipStr string
|
|
if a.IP == nil {
|
|
ipStr = net.IPv4zero.String()
|
|
} else {
|
|
ipStr = a.IP.String()
|
|
}
|
|
return net.JoinHostPort(ipStr, fmt.Sprintf("%d", a.Port))
|
|
}
|
|
|
|
func (a Address) GoString() string {
|
|
return a.String()
|
|
}
|