mirror of
https://github.com/pion/ice.git
synced 2025-10-01 22:02:07 +08:00
e0db6d259e
A controlled Agent would discard incoming Binding Requests if it didn't cause the pair to be selected. For UDP Candidate this would be interpreted as packet loss. For TCP Candidates not responding with a Binding Success could be interpreted as a failure. Firefox's ICE Agent would disconnect TCP Candidates because of this behavior. Resolves to pion/webrtc#2125 Resolves to pion/webrtc#1356 See https://bugzilla.mozilla.org/show_bug.cgi?id=1756460
100 lines
2.3 KiB
Go
100 lines
2.3 KiB
Go
package ice
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/pion/stun"
|
|
)
|
|
|
|
func newCandidatePair(local, remote Candidate, controlling bool) *CandidatePair {
|
|
return &CandidatePair{
|
|
iceRoleControlling: controlling,
|
|
Remote: remote,
|
|
Local: local,
|
|
state: CandidatePairStateWaiting,
|
|
}
|
|
}
|
|
|
|
// CandidatePair is a combination of a
|
|
// local and remote candidate
|
|
type CandidatePair struct {
|
|
iceRoleControlling bool
|
|
Remote Candidate
|
|
Local Candidate
|
|
bindingRequestCount uint16
|
|
state CandidatePairState
|
|
nominated bool
|
|
nominateOnBindingSuccess bool
|
|
}
|
|
|
|
func (p *CandidatePair) String() string {
|
|
if p == nil {
|
|
return ""
|
|
}
|
|
|
|
return fmt.Sprintf("prio %d (local, prio %d) %s <-> %s (remote, prio %d)",
|
|
p.priority(), p.Local.Priority(), p.Local, p.Remote, p.Remote.Priority())
|
|
}
|
|
|
|
func (p *CandidatePair) equal(other *CandidatePair) bool {
|
|
if p == nil && other == nil {
|
|
return true
|
|
}
|
|
if p == nil || other == nil {
|
|
return false
|
|
}
|
|
return p.Local.Equal(other.Local) && p.Remote.Equal(other.Remote)
|
|
}
|
|
|
|
// RFC 5245 - 5.7.2. Computing Pair Priority and Ordering Pairs
|
|
// Let G be the priority for the candidate provided by the controlling
|
|
// agent. Let D be the priority for the candidate provided by the
|
|
// controlled agent.
|
|
// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
|
|
func (p *CandidatePair) priority() uint64 {
|
|
var g, d uint32
|
|
if p.iceRoleControlling {
|
|
g = p.Local.Priority()
|
|
d = p.Remote.Priority()
|
|
} else {
|
|
g = p.Remote.Priority()
|
|
d = p.Local.Priority()
|
|
}
|
|
|
|
// Just implement these here rather
|
|
// than fooling around with the math package
|
|
min := func(x, y uint32) uint64 {
|
|
if x < y {
|
|
return uint64(x)
|
|
}
|
|
return uint64(y)
|
|
}
|
|
max := func(x, y uint32) uint64 {
|
|
if x > y {
|
|
return uint64(x)
|
|
}
|
|
return uint64(y)
|
|
}
|
|
cmp := func(x, y uint32) uint64 {
|
|
if x > y {
|
|
return uint64(1)
|
|
}
|
|
return uint64(0)
|
|
}
|
|
|
|
// 1<<32 overflows uint32; and if both g && d are
|
|
// maxUint32, this result would overflow uint64
|
|
return (1<<32-1)*min(g, d) + 2*max(g, d) + cmp(g, d)
|
|
}
|
|
|
|
func (p *CandidatePair) Write(b []byte) (int, error) {
|
|
return p.Local.writeTo(b, p.Remote)
|
|
}
|
|
|
|
func (a *Agent) sendSTUN(msg *stun.Message, local, remote Candidate) {
|
|
_, err := local.writeTo(msg.Raw, remote)
|
|
if err != nil {
|
|
a.log.Tracef("failed to send STUN message: %s", err)
|
|
}
|
|
}
|