2019-04-29 21:25:05 +00:00
|
|
|
// Copyright 2018 The gVisor Authors.
|
2018-07-09 21:03:03 +00:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2018-04-27 17:37:02 +00:00
|
|
|
|
|
|
|
package udp
|
|
|
|
|
|
|
|
import (
|
2018-10-10 21:09:24 +00:00
|
|
|
"math"
|
2018-04-27 17:37:02 +00:00
|
|
|
"sync"
|
|
|
|
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/sleep"
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/tcpip"
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/tcpip/buffer"
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/tcpip/header"
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/tcpip/stack"
|
|
|
|
"gvisor.googlesource.com/gvisor/pkg/waiter"
|
|
|
|
)
|
|
|
|
|
2018-08-02 17:41:44 +00:00
|
|
|
// +stateify savable
|
2018-04-27 17:37:02 +00:00
|
|
|
type udpPacket struct {
|
|
|
|
udpPacketEntry
|
|
|
|
senderAddress tcpip.FullAddress
|
|
|
|
data buffer.VectorisedView `state:".(buffer.VectorisedView)"`
|
2018-05-02 05:11:07 +00:00
|
|
|
timestamp int64
|
2018-04-27 17:37:02 +00:00
|
|
|
// views is used as buffer for data when its length is large
|
|
|
|
// enough to store a VectorisedView.
|
|
|
|
views [8]buffer.View `state:"nosave"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type endpointState int
|
|
|
|
|
|
|
|
const (
|
|
|
|
stateInitial endpointState = iota
|
|
|
|
stateBound
|
|
|
|
stateConnected
|
|
|
|
stateClosed
|
|
|
|
)
|
|
|
|
|
|
|
|
// endpoint represents a UDP endpoint. This struct serves as the interface
|
|
|
|
// between users of the endpoint and the protocol implementation; it is legal to
|
|
|
|
// have concurrent goroutines make calls into the endpoint, they are properly
|
|
|
|
// synchronized.
|
2018-08-02 17:41:44 +00:00
|
|
|
//
|
2019-05-22 20:44:07 +00:00
|
|
|
// It implements tcpip.Endpoint.
|
|
|
|
//
|
2018-08-02 17:41:44 +00:00
|
|
|
// +stateify savable
|
2018-04-27 17:37:02 +00:00
|
|
|
type endpoint struct {
|
|
|
|
// The following fields are initialized at creation time and do not
|
|
|
|
// change throughout the lifetime of the endpoint.
|
|
|
|
stack *stack.Stack `state:"manual"`
|
|
|
|
netProto tcpip.NetworkProtocolNumber
|
|
|
|
waiterQueue *waiter.Queue
|
|
|
|
|
|
|
|
// The following fields are used to manage the receive queue, and are
|
|
|
|
// protected by rcvMu.
|
|
|
|
rcvMu sync.Mutex `state:"nosave"`
|
|
|
|
rcvReady bool
|
|
|
|
rcvList udpPacketList
|
|
|
|
rcvBufSizeMax int `state:".(int)"`
|
|
|
|
rcvBufSize int
|
|
|
|
rcvClosed bool
|
|
|
|
|
|
|
|
// The following fields are protected by the mu mutex.
|
2019-02-16 02:39:10 +00:00
|
|
|
mu sync.RWMutex `state:"nosave"`
|
|
|
|
sndBufSize int
|
|
|
|
id stack.TransportEndpointID
|
|
|
|
state endpointState
|
|
|
|
bindNICID tcpip.NICID
|
|
|
|
regNICID tcpip.NICID
|
|
|
|
route stack.Route `state:"manual"`
|
|
|
|
dstPort uint16
|
|
|
|
v6only bool
|
|
|
|
multicastTTL uint8
|
|
|
|
multicastAddr tcpip.Address
|
|
|
|
multicastNICID tcpip.NICID
|
2019-03-08 23:48:16 +00:00
|
|
|
multicastLoop bool
|
2019-02-16 02:39:10 +00:00
|
|
|
reusePort bool
|
2019-02-20 20:53:07 +00:00
|
|
|
broadcast bool
|
2018-04-27 17:37:02 +00:00
|
|
|
|
2018-08-07 14:56:08 +00:00
|
|
|
// shutdownFlags represent the current shutdown state of the endpoint.
|
|
|
|
shutdownFlags tcpip.ShutdownFlags
|
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
// multicastMemberships that need to be remvoed when the endpoint is
|
|
|
|
// closed. Protected by the mu mutex.
|
|
|
|
multicastMemberships []multicastMembership
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
// effectiveNetProtos contains the network protocols actually in use. In
|
|
|
|
// most cases it will only contain "netProto", but in cases like IPv6
|
|
|
|
// endpoints with v6only set to false, this could include multiple
|
|
|
|
// protocols (e.g., IPv6 and IPv4) or a single different protocol (e.g.,
|
|
|
|
// IPv4 when IPv6 endpoint is bound or connected to an IPv4 mapped
|
|
|
|
// address).
|
|
|
|
effectiveNetProtos []tcpip.NetworkProtocolNumber
|
|
|
|
}
|
|
|
|
|
2019-02-08 07:14:06 +00:00
|
|
|
// +stateify savable
|
2018-09-13 03:38:27 +00:00
|
|
|
type multicastMembership struct {
|
|
|
|
nicID tcpip.NICID
|
|
|
|
multicastAddr tcpip.Address
|
|
|
|
}
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
func newEndpoint(stack *stack.Stack, netProto tcpip.NetworkProtocolNumber, waiterQueue *waiter.Queue) *endpoint {
|
|
|
|
return &endpoint{
|
2018-09-13 03:38:27 +00:00
|
|
|
stack: stack,
|
|
|
|
netProto: netProto,
|
|
|
|
waiterQueue: waiterQueue,
|
|
|
|
// RFC 1075 section 5.4 recommends a TTL of 1 for membership
|
|
|
|
// requests.
|
|
|
|
//
|
|
|
|
// RFC 5135 4.2.1 appears to assume that IGMP messages have a
|
|
|
|
// TTL of 1.
|
|
|
|
//
|
|
|
|
// RFC 5135 Appendix A defines TTL=1: A multicast source that
|
|
|
|
// wants its traffic to not traverse a router (e.g., leave a
|
|
|
|
// home network) may find it useful to send traffic with IP
|
|
|
|
// TTL=1.
|
|
|
|
//
|
|
|
|
// Linux defaults to TTL=1.
|
|
|
|
multicastTTL: 1,
|
2019-03-08 23:48:16 +00:00
|
|
|
multicastLoop: true,
|
2018-04-27 17:37:02 +00:00
|
|
|
rcvBufSizeMax: 32 * 1024,
|
|
|
|
sndBufSize: 32 * 1024,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close puts the endpoint in a closed state and frees all resources
|
|
|
|
// associated with it.
|
|
|
|
func (e *endpoint) Close() {
|
|
|
|
e.mu.Lock()
|
2018-08-07 14:56:08 +00:00
|
|
|
e.shutdownFlags = tcpip.ShutdownRead | tcpip.ShutdownWrite
|
2018-04-27 17:37:02 +00:00
|
|
|
|
|
|
|
switch e.state {
|
|
|
|
case stateBound, stateConnected:
|
2018-12-28 19:26:01 +00:00
|
|
|
e.stack.UnregisterTransportEndpoint(e.regNICID, e.effectiveNetProtos, ProtocolNumber, e.id, e)
|
2018-09-12 16:37:57 +00:00
|
|
|
e.stack.ReleasePort(e.effectiveNetProtos, ProtocolNumber, e.id.LocalAddress, e.id.LocalPort)
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
for _, mem := range e.multicastMemberships {
|
|
|
|
e.stack.LeaveGroup(e.netProto, mem.nicID, mem.multicastAddr)
|
|
|
|
}
|
|
|
|
e.multicastMemberships = nil
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
// Close the receive list and drain it.
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
e.rcvClosed = true
|
|
|
|
e.rcvBufSize = 0
|
|
|
|
for !e.rcvList.Empty() {
|
|
|
|
p := e.rcvList.Front()
|
|
|
|
e.rcvList.Remove(p)
|
|
|
|
}
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
e.route.Release()
|
|
|
|
|
|
|
|
// Update the state.
|
|
|
|
e.state = stateClosed
|
2018-07-10 04:19:58 +00:00
|
|
|
|
|
|
|
e.mu.Unlock()
|
|
|
|
|
|
|
|
e.waiterQueue.Notify(waiter.EventHUp | waiter.EventErr | waiter.EventIn | waiter.EventOut)
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read reads data from the endpoint. This method does not block if
|
|
|
|
// there is no data pending.
|
2018-05-02 05:11:07 +00:00
|
|
|
func (e *endpoint) Read(addr *tcpip.FullAddress) (buffer.View, tcpip.ControlMessages, *tcpip.Error) {
|
2018-04-27 17:37:02 +00:00
|
|
|
e.rcvMu.Lock()
|
|
|
|
|
|
|
|
if e.rcvList.Empty() {
|
|
|
|
err := tcpip.ErrWouldBlock
|
|
|
|
if e.rcvClosed {
|
|
|
|
err = tcpip.ErrClosedForReceive
|
|
|
|
}
|
|
|
|
e.rcvMu.Unlock()
|
2018-05-02 05:11:07 +00:00
|
|
|
return buffer.View{}, tcpip.ControlMessages{}, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
p := e.rcvList.Front()
|
|
|
|
e.rcvList.Remove(p)
|
|
|
|
e.rcvBufSize -= p.data.Size()
|
|
|
|
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
if addr != nil {
|
|
|
|
*addr = p.senderAddress
|
|
|
|
}
|
|
|
|
|
2019-02-15 19:17:51 +00:00
|
|
|
return p.data.ToView(), tcpip.ControlMessages{HasTimestamp: true, Timestamp: p.timestamp}, nil
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// prepareForWrite prepares the endpoint for sending data. In particular, it
|
|
|
|
// binds it if it's still in the initial state. To do so, it must first
|
|
|
|
// reacquire the mutex in exclusive mode.
|
|
|
|
//
|
|
|
|
// Returns true for retry if preparation should be retried.
|
|
|
|
func (e *endpoint) prepareForWrite(to *tcpip.FullAddress) (retry bool, err *tcpip.Error) {
|
|
|
|
switch e.state {
|
|
|
|
case stateInitial:
|
|
|
|
case stateConnected:
|
|
|
|
return false, nil
|
|
|
|
|
|
|
|
case stateBound:
|
|
|
|
if to == nil {
|
|
|
|
return false, tcpip.ErrDestinationRequired
|
|
|
|
}
|
|
|
|
return false, nil
|
|
|
|
default:
|
|
|
|
return false, tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
e.mu.RUnlock()
|
|
|
|
defer e.mu.RLock()
|
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
|
|
|
// The state changed when we released the shared locked and re-acquired
|
|
|
|
// it in exclusive mode. Try again.
|
|
|
|
if e.state != stateInitial {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// The state is still 'initial', so try to bind the endpoint.
|
2019-03-05 22:52:35 +00:00
|
|
|
if err := e.bindLocked(tcpip.FullAddress{}); err != nil {
|
2018-04-27 17:37:02 +00:00
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
2019-02-16 02:39:10 +00:00
|
|
|
// connectRoute establishes a route to the specified interface or the
|
|
|
|
// configured multicast interface if no interface is specified and the
|
|
|
|
// specified address is a multicast address.
|
|
|
|
func (e *endpoint) connectRoute(nicid tcpip.NICID, addr tcpip.FullAddress) (stack.Route, tcpip.NICID, tcpip.NetworkProtocolNumber, *tcpip.Error) {
|
|
|
|
netProto, err := e.checkV4Mapped(&addr, false)
|
|
|
|
if err != nil {
|
|
|
|
return stack.Route{}, 0, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
localAddr := e.id.LocalAddress
|
|
|
|
if header.IsV4MulticastAddress(addr.Addr) || header.IsV6MulticastAddress(addr.Addr) {
|
|
|
|
if nicid == 0 {
|
|
|
|
nicid = e.multicastNICID
|
|
|
|
}
|
|
|
|
if localAddr == "" {
|
|
|
|
localAddr = e.multicastAddr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find a route to the desired destination.
|
2019-03-08 23:48:16 +00:00
|
|
|
r, err := e.stack.FindRoute(nicid, localAddr, addr.Addr, netProto, e.multicastLoop)
|
2019-02-16 02:39:10 +00:00
|
|
|
if err != nil {
|
|
|
|
return stack.Route{}, 0, 0, err
|
|
|
|
}
|
|
|
|
return r, nicid, netProto, nil
|
|
|
|
}
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
// Write writes data to the endpoint's peer. This method does not block
|
|
|
|
// if the data cannot be written.
|
2018-09-28 17:59:21 +00:00
|
|
|
func (e *endpoint) Write(p tcpip.Payload, opts tcpip.WriteOptions) (uintptr, <-chan struct{}, *tcpip.Error) {
|
2018-04-27 17:37:02 +00:00
|
|
|
// MSG_MORE is unimplemented. (This also means that MSG_EOR is a no-op.)
|
|
|
|
if opts.More {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, tcpip.ErrInvalidOptionValue
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
2018-10-10 21:09:24 +00:00
|
|
|
if p.Size() > math.MaxUint16 {
|
|
|
|
// Payload can't possibly fit in a packet.
|
|
|
|
return 0, nil, tcpip.ErrMessageTooLong
|
|
|
|
}
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
to := opts.To
|
|
|
|
|
|
|
|
e.mu.RLock()
|
|
|
|
defer e.mu.RUnlock()
|
|
|
|
|
2018-08-07 14:56:08 +00:00
|
|
|
// If we've shutdown with SHUT_WR we are in an invalid state for sending.
|
|
|
|
if e.shutdownFlags&tcpip.ShutdownWrite != 0 {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, tcpip.ErrClosedForSend
|
2018-08-07 14:56:08 +00:00
|
|
|
}
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
// Prepare for write.
|
|
|
|
for {
|
|
|
|
retry, err := e.prepareForWrite(to)
|
|
|
|
if err != nil {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if !retry {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var route *stack.Route
|
|
|
|
var dstPort uint16
|
|
|
|
if to == nil {
|
|
|
|
route = &e.route
|
|
|
|
dstPort = e.dstPort
|
|
|
|
|
|
|
|
if route.IsResolutionRequired() {
|
|
|
|
// Promote lock to exclusive if using a shared route, given that it may need to
|
|
|
|
// change in Route.Resolve() call below.
|
|
|
|
e.mu.RUnlock()
|
|
|
|
defer e.mu.RLock()
|
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
|
|
|
// Recheck state after lock was re-acquired.
|
|
|
|
if e.state != stateConnected {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, tcpip.ErrInvalidEndpointState
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Reject destination address if it goes through a different
|
|
|
|
// NIC than the endpoint was bound to.
|
|
|
|
nicid := to.NIC
|
|
|
|
if e.bindNICID != 0 {
|
|
|
|
if nicid != 0 && nicid != e.bindNICID {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, tcpip.ErrNoRoute
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nicid = e.bindNICID
|
|
|
|
}
|
|
|
|
|
2019-02-20 20:53:07 +00:00
|
|
|
if to.Addr == header.IPv4Broadcast && !e.broadcast {
|
|
|
|
return 0, nil, tcpip.ErrBroadcastDisabled
|
|
|
|
}
|
|
|
|
|
2019-02-16 02:39:10 +00:00
|
|
|
r, _, _, err := e.connectRoute(nicid, *to)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
defer r.Release()
|
|
|
|
|
|
|
|
route = &r
|
|
|
|
dstPort = to.Port
|
|
|
|
}
|
|
|
|
|
|
|
|
if route.IsResolutionRequired() {
|
|
|
|
waker := &sleep.Waker{}
|
2018-09-28 17:59:21 +00:00
|
|
|
if ch, err := route.Resolve(waker); err != nil {
|
2018-04-27 17:37:02 +00:00
|
|
|
if err == tcpip.ErrWouldBlock {
|
|
|
|
// Link address needs to be resolved. Resolution was triggered the background.
|
|
|
|
// Better luck next time.
|
|
|
|
route.RemoveWaker(waker)
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, ch, tcpip.ErrNoLinkAddress
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
v, err := p.Get(p.Size())
|
|
|
|
if err != nil {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
2018-08-27 22:28:38 +00:00
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
ttl := route.DefaultTTL()
|
|
|
|
if header.IsV4MulticastAddress(route.RemoteAddress) || header.IsV6MulticastAddress(route.RemoteAddress) {
|
|
|
|
ttl = e.multicastTTL
|
|
|
|
}
|
|
|
|
|
2018-09-13 04:57:04 +00:00
|
|
|
if err := sendUDP(route, buffer.View(v).ToVectorisedView(), e.id.LocalPort, dstPort, ttl); err != nil {
|
2018-09-28 17:59:21 +00:00
|
|
|
return 0, nil, err
|
2018-08-27 22:28:38 +00:00
|
|
|
}
|
2018-09-28 17:59:21 +00:00
|
|
|
return uintptr(len(v)), nil, nil
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Peek only returns data from a single datagram, so do nothing here.
|
2018-05-02 05:11:07 +00:00
|
|
|
func (e *endpoint) Peek([][]byte) (uintptr, tcpip.ControlMessages, *tcpip.Error) {
|
|
|
|
return 0, tcpip.ControlMessages{}, nil
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// SetSockOpt sets a socket option. Currently not supported.
|
|
|
|
func (e *endpoint) SetSockOpt(opt interface{}) *tcpip.Error {
|
|
|
|
switch v := opt.(type) {
|
|
|
|
case tcpip.V6OnlyOption:
|
|
|
|
// We only recognize this option on v6 endpoints.
|
|
|
|
if e.netProto != header.IPv6ProtocolNumber {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
|
|
|
// We only allow this to be set when we're in the initial state.
|
|
|
|
if e.state != stateInitial {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
e.v6only = v != 0
|
2018-05-02 05:11:07 +00:00
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
case tcpip.MulticastTTLOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
e.multicastTTL = uint8(v)
|
2018-09-22 01:13:38 +00:00
|
|
|
e.mu.Unlock()
|
2018-09-13 03:38:27 +00:00
|
|
|
|
2019-02-16 02:39:10 +00:00
|
|
|
case tcpip.MulticastInterfaceOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
|
|
|
fa := tcpip.FullAddress{Addr: v.InterfaceAddr}
|
|
|
|
netProto, err := e.checkV4Mapped(&fa, false)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
nic := v.NIC
|
|
|
|
addr := fa.Addr
|
|
|
|
|
|
|
|
if nic == 0 && addr == "" {
|
|
|
|
e.multicastAddr = ""
|
|
|
|
e.multicastNICID = 0
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
if nic != 0 {
|
|
|
|
if !e.stack.CheckNIC(nic) {
|
|
|
|
return tcpip.ErrBadLocalAddress
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
nic = e.stack.CheckLocalAddress(0, netProto, addr)
|
|
|
|
if nic == 0 {
|
|
|
|
return tcpip.ErrBadLocalAddress
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if e.bindNICID != 0 && e.bindNICID != nic {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
e.multicastNICID = nic
|
|
|
|
e.multicastAddr = addr
|
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
case tcpip.AddMembershipOption:
|
2019-03-09 03:04:29 +00:00
|
|
|
if !header.IsV4MulticastAddress(v.MulticastAddr) && !header.IsV6MulticastAddress(v.MulticastAddr) {
|
|
|
|
return tcpip.ErrInvalidOptionValue
|
|
|
|
}
|
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
nicID := v.NIC
|
2019-03-08 23:48:16 +00:00
|
|
|
if v.InterfaceAddr == header.IPv4Any {
|
|
|
|
if nicID == 0 {
|
|
|
|
r, err := e.stack.FindRoute(0, "", v.MulticastAddr, header.IPv4ProtocolNumber, false /* multicastLoop */)
|
|
|
|
if err == nil {
|
|
|
|
nicID = r.NICID()
|
|
|
|
r.Release()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2018-09-13 03:38:27 +00:00
|
|
|
nicID = e.stack.CheckLocalAddress(nicID, e.netProto, v.InterfaceAddr)
|
|
|
|
}
|
|
|
|
if nicID == 0 {
|
2019-03-08 23:48:16 +00:00
|
|
|
return tcpip.ErrUnknownDevice
|
2018-09-13 03:38:27 +00:00
|
|
|
}
|
|
|
|
|
2019-05-03 02:39:55 +00:00
|
|
|
memToInsert := multicastMembership{nicID: nicID, multicastAddr: v.MulticastAddr}
|
2018-09-13 03:38:27 +00:00
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
2019-05-03 02:39:55 +00:00
|
|
|
for _, mem := range e.multicastMemberships {
|
|
|
|
if mem == memToInsert {
|
|
|
|
return tcpip.ErrPortInUse
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := e.stack.JoinGroup(e.netProto, nicID, v.MulticastAddr); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
e.multicastMemberships = append(e.multicastMemberships, memToInsert)
|
2018-09-13 03:38:27 +00:00
|
|
|
|
|
|
|
case tcpip.RemoveMembershipOption:
|
2019-03-09 03:04:29 +00:00
|
|
|
if !header.IsV4MulticastAddress(v.MulticastAddr) && !header.IsV6MulticastAddress(v.MulticastAddr) {
|
|
|
|
return tcpip.ErrInvalidOptionValue
|
|
|
|
}
|
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
nicID := v.NIC
|
2019-03-08 23:48:16 +00:00
|
|
|
if v.InterfaceAddr == header.IPv4Any {
|
|
|
|
if nicID == 0 {
|
|
|
|
r, err := e.stack.FindRoute(0, "", v.MulticastAddr, header.IPv4ProtocolNumber, false /* multicastLoop */)
|
|
|
|
if err == nil {
|
|
|
|
nicID = r.NICID()
|
|
|
|
r.Release()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2018-09-13 03:38:27 +00:00
|
|
|
nicID = e.stack.CheckLocalAddress(nicID, e.netProto, v.InterfaceAddr)
|
|
|
|
}
|
|
|
|
if nicID == 0 {
|
2019-03-08 23:48:16 +00:00
|
|
|
return tcpip.ErrUnknownDevice
|
2018-09-13 03:38:27 +00:00
|
|
|
}
|
|
|
|
|
2019-05-03 02:39:55 +00:00
|
|
|
memToRemove := multicastMembership{nicID: nicID, multicastAddr: v.MulticastAddr}
|
|
|
|
memToRemoveIndex := -1
|
2018-09-13 03:38:27 +00:00
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
2019-05-03 02:39:55 +00:00
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
for i, mem := range e.multicastMemberships {
|
2019-05-03 02:39:55 +00:00
|
|
|
if mem == memToRemove {
|
|
|
|
memToRemoveIndex = i
|
2018-09-13 03:38:27 +00:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2019-05-03 02:39:55 +00:00
|
|
|
if memToRemoveIndex == -1 {
|
|
|
|
return tcpip.ErrBadLocalAddress
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := e.stack.LeaveGroup(e.netProto, nicID, v.MulticastAddr); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
e.multicastMemberships[memToRemoveIndex] = e.multicastMemberships[len(e.multicastMemberships)-1]
|
|
|
|
e.multicastMemberships = e.multicastMemberships[:len(e.multicastMemberships)-1]
|
2018-12-28 19:26:01 +00:00
|
|
|
|
2019-03-08 23:48:16 +00:00
|
|
|
case tcpip.MulticastLoopOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
e.multicastLoop = bool(v)
|
|
|
|
e.mu.Unlock()
|
|
|
|
|
2018-12-28 19:26:01 +00:00
|
|
|
case tcpip.ReusePortOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
e.reusePort = v != 0
|
|
|
|
e.mu.Unlock()
|
2019-02-20 20:53:07 +00:00
|
|
|
|
|
|
|
case tcpip.BroadcastOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
e.broadcast = v != 0
|
|
|
|
e.mu.Unlock()
|
|
|
|
|
|
|
|
return nil
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetSockOpt implements tcpip.Endpoint.GetSockOpt.
|
|
|
|
func (e *endpoint) GetSockOpt(opt interface{}) *tcpip.Error {
|
|
|
|
switch o := opt.(type) {
|
|
|
|
case tcpip.ErrorOption:
|
|
|
|
return nil
|
|
|
|
|
|
|
|
case *tcpip.SendBufferSizeOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
*o = tcpip.SendBufferSizeOption(e.sndBufSize)
|
|
|
|
e.mu.Unlock()
|
|
|
|
return nil
|
|
|
|
|
|
|
|
case *tcpip.ReceiveBufferSizeOption:
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
*o = tcpip.ReceiveBufferSizeOption(e.rcvBufSizeMax)
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
return nil
|
|
|
|
|
|
|
|
case *tcpip.V6OnlyOption:
|
|
|
|
// We only recognize this option on v6 endpoints.
|
|
|
|
if e.netProto != header.IPv6ProtocolNumber {
|
|
|
|
return tcpip.ErrUnknownProtocolOption
|
|
|
|
}
|
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
v := e.v6only
|
|
|
|
e.mu.Unlock()
|
|
|
|
|
|
|
|
*o = 0
|
|
|
|
if v {
|
|
|
|
*o = 1
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
|
|
|
|
case *tcpip.ReceiveQueueSizeOption:
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
if e.rcvList.Empty() {
|
|
|
|
*o = 0
|
|
|
|
} else {
|
|
|
|
p := e.rcvList.Front()
|
|
|
|
*o = tcpip.ReceiveQueueSizeOption(p.data.Size())
|
|
|
|
}
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
return nil
|
2018-05-02 05:11:07 +00:00
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
case *tcpip.MulticastTTLOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
*o = tcpip.MulticastTTLOption(e.multicastTTL)
|
|
|
|
e.mu.Unlock()
|
|
|
|
return nil
|
2018-04-27 17:37:02 +00:00
|
|
|
|
2019-02-16 02:39:10 +00:00
|
|
|
case *tcpip.MulticastInterfaceOption:
|
|
|
|
e.mu.Lock()
|
|
|
|
*o = tcpip.MulticastInterfaceOption{
|
|
|
|
e.multicastNICID,
|
|
|
|
e.multicastAddr,
|
|
|
|
}
|
|
|
|
e.mu.Unlock()
|
|
|
|
return nil
|
|
|
|
|
2019-03-08 23:48:16 +00:00
|
|
|
case *tcpip.MulticastLoopOption:
|
|
|
|
e.mu.RLock()
|
|
|
|
v := e.multicastLoop
|
|
|
|
e.mu.RUnlock()
|
|
|
|
|
|
|
|
*o = tcpip.MulticastLoopOption(v)
|
|
|
|
return nil
|
|
|
|
|
2018-12-28 19:26:01 +00:00
|
|
|
case *tcpip.ReusePortOption:
|
|
|
|
e.mu.RLock()
|
|
|
|
v := e.reusePort
|
|
|
|
e.mu.RUnlock()
|
|
|
|
|
|
|
|
*o = 0
|
|
|
|
if v {
|
|
|
|
*o = 1
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
|
2018-12-21 21:12:32 +00:00
|
|
|
case *tcpip.KeepaliveEnabledOption:
|
|
|
|
*o = 0
|
|
|
|
return nil
|
|
|
|
|
2019-02-20 20:53:07 +00:00
|
|
|
case *tcpip.BroadcastOption:
|
|
|
|
e.mu.RLock()
|
|
|
|
v := e.broadcast
|
|
|
|
e.mu.RUnlock()
|
|
|
|
|
|
|
|
*o = 0
|
|
|
|
if v {
|
|
|
|
*o = 1
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
|
2018-12-21 21:12:32 +00:00
|
|
|
default:
|
|
|
|
return tcpip.ErrUnknownProtocolOption
|
|
|
|
}
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// sendUDP sends a UDP segment via the provided network endpoint and under the
|
|
|
|
// provided identity.
|
2018-09-13 03:38:27 +00:00
|
|
|
func sendUDP(r *stack.Route, data buffer.VectorisedView, localPort, remotePort uint16, ttl uint8) *tcpip.Error {
|
2018-04-27 17:37:02 +00:00
|
|
|
// Allocate a buffer for the UDP header.
|
|
|
|
hdr := buffer.NewPrependable(header.UDPMinimumSize + int(r.MaxHeaderLength()))
|
|
|
|
|
|
|
|
// Initialize the header.
|
|
|
|
udp := header.UDP(hdr.Prepend(header.UDPMinimumSize))
|
|
|
|
|
2018-09-06 00:33:18 +00:00
|
|
|
length := uint16(hdr.UsedLength() + data.Size())
|
2018-04-27 17:37:02 +00:00
|
|
|
udp.Encode(&header.UDPFields{
|
|
|
|
SrcPort: localPort,
|
|
|
|
DstPort: remotePort,
|
|
|
|
Length: length,
|
|
|
|
})
|
|
|
|
|
|
|
|
// Only calculate the checksum if offloading isn't supported.
|
2019-04-09 18:22:28 +00:00
|
|
|
if r.Capabilities()&stack.CapabilityTXChecksumOffload == 0 {
|
2019-03-27 00:14:04 +00:00
|
|
|
xsum := r.PseudoHeaderChecksum(ProtocolNumber, length)
|
2018-09-06 00:33:18 +00:00
|
|
|
for _, v := range data.Views() {
|
|
|
|
xsum = header.Checksum(v, xsum)
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
2019-03-27 00:14:04 +00:00
|
|
|
udp.SetChecksum(^udp.CalculateChecksum(xsum))
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
2018-08-27 22:28:38 +00:00
|
|
|
// Track count of packets sent.
|
|
|
|
r.Stats().UDP.PacketsSent.Increment()
|
|
|
|
|
2019-03-28 18:02:23 +00:00
|
|
|
return r.WritePacket(nil /* gso */, hdr, data, ProtocolNumber, ttl)
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (e *endpoint) checkV4Mapped(addr *tcpip.FullAddress, allowMismatch bool) (tcpip.NetworkProtocolNumber, *tcpip.Error) {
|
|
|
|
netProto := e.netProto
|
|
|
|
if header.IsV4MappedAddress(addr.Addr) {
|
|
|
|
// Fail if using a v4 mapped address on a v6only endpoint.
|
|
|
|
if e.v6only {
|
|
|
|
return 0, tcpip.ErrNoRoute
|
|
|
|
}
|
|
|
|
|
|
|
|
netProto = header.IPv4ProtocolNumber
|
|
|
|
addr.Addr = addr.Addr[header.IPv6AddressSize-header.IPv4AddressSize:]
|
|
|
|
if addr.Addr == "\x00\x00\x00\x00" {
|
|
|
|
addr.Addr = ""
|
|
|
|
}
|
2018-05-17 19:49:16 +00:00
|
|
|
|
|
|
|
// Fail if we are bound to an IPv6 address.
|
|
|
|
if !allowMismatch && len(e.id.LocalAddress) == 16 {
|
|
|
|
return 0, tcpip.ErrNetworkUnreachable
|
|
|
|
}
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Fail if we're bound to an address length different from the one we're
|
|
|
|
// checking.
|
2018-05-17 19:49:16 +00:00
|
|
|
if l := len(e.id.LocalAddress); l != 0 && l != len(addr.Addr) {
|
2018-04-27 17:37:02 +00:00
|
|
|
return 0, tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
return netProto, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Connect connects the endpoint to its peer. Specifying a NIC is optional.
|
|
|
|
func (e *endpoint) Connect(addr tcpip.FullAddress) *tcpip.Error {
|
|
|
|
if addr.Port == 0 {
|
|
|
|
// We don't support connecting to port zero.
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
|
|
|
nicid := addr.NIC
|
2018-09-12 16:37:57 +00:00
|
|
|
var localPort uint16
|
2018-04-27 17:37:02 +00:00
|
|
|
switch e.state {
|
|
|
|
case stateInitial:
|
|
|
|
case stateBound, stateConnected:
|
|
|
|
localPort = e.id.LocalPort
|
|
|
|
if e.bindNICID == 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
if nicid != 0 && nicid != e.bindNICID {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
nicid = e.bindNICID
|
|
|
|
default:
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
2019-02-16 02:39:10 +00:00
|
|
|
r, nicid, netProto, err := e.connectRoute(nicid, addr)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer r.Release()
|
|
|
|
|
|
|
|
id := stack.TransportEndpointID{
|
|
|
|
LocalAddress: r.LocalAddress,
|
|
|
|
LocalPort: localPort,
|
|
|
|
RemotePort: addr.Port,
|
|
|
|
RemoteAddress: r.RemoteAddress,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Even if we're connected, this endpoint can still be used to send
|
|
|
|
// packets on a different network protocol, so we register both even if
|
|
|
|
// v6only is set to false and this is an ipv6 endpoint.
|
|
|
|
netProtos := []tcpip.NetworkProtocolNumber{netProto}
|
2018-09-12 16:37:57 +00:00
|
|
|
if netProto == header.IPv6ProtocolNumber && !e.v6only {
|
2018-04-27 17:37:02 +00:00
|
|
|
netProtos = []tcpip.NetworkProtocolNumber{
|
|
|
|
header.IPv4ProtocolNumber,
|
|
|
|
header.IPv6ProtocolNumber,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
id, err = e.registerWithStack(nicid, netProtos, id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the old registration.
|
|
|
|
if e.id.LocalPort != 0 {
|
2018-12-28 19:26:01 +00:00
|
|
|
e.stack.UnregisterTransportEndpoint(e.regNICID, e.effectiveNetProtos, ProtocolNumber, e.id, e)
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
e.id = id
|
|
|
|
e.route = r.Clone()
|
|
|
|
e.dstPort = addr.Port
|
|
|
|
e.regNICID = nicid
|
|
|
|
e.effectiveNetProtos = netProtos
|
|
|
|
|
|
|
|
e.state = stateConnected
|
|
|
|
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
e.rcvReady = true
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ConnectEndpoint is not supported.
|
|
|
|
func (*endpoint) ConnectEndpoint(tcpip.Endpoint) *tcpip.Error {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
|
|
|
// Shutdown closes the read and/or write end of the endpoint connection
|
|
|
|
// to its peer.
|
|
|
|
func (e *endpoint) Shutdown(flags tcpip.ShutdownFlags) *tcpip.Error {
|
2018-08-07 14:56:08 +00:00
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
2018-04-27 17:37:02 +00:00
|
|
|
|
2018-09-13 03:38:27 +00:00
|
|
|
// A socket in the bound state can still receive multicast messages,
|
|
|
|
// so we need to notify waiters on shutdown.
|
|
|
|
if e.state != stateBound && e.state != stateConnected {
|
2018-04-27 17:37:02 +00:00
|
|
|
return tcpip.ErrNotConnected
|
|
|
|
}
|
|
|
|
|
2018-08-07 14:56:08 +00:00
|
|
|
e.shutdownFlags |= flags
|
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
if flags&tcpip.ShutdownRead != 0 {
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
wasClosed := e.rcvClosed
|
|
|
|
e.rcvClosed = true
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
if !wasClosed {
|
|
|
|
e.waiterQueue.Notify(waiter.EventIn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Listen is not supported by UDP, it just fails.
|
|
|
|
func (*endpoint) Listen(int) *tcpip.Error {
|
|
|
|
return tcpip.ErrNotSupported
|
|
|
|
}
|
|
|
|
|
|
|
|
// Accept is not supported by UDP, it just fails.
|
|
|
|
func (*endpoint) Accept() (tcpip.Endpoint, *waiter.Queue, *tcpip.Error) {
|
|
|
|
return nil, nil, tcpip.ErrNotSupported
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *endpoint) registerWithStack(nicid tcpip.NICID, netProtos []tcpip.NetworkProtocolNumber, id stack.TransportEndpointID) (stack.TransportEndpointID, *tcpip.Error) {
|
2018-09-12 16:37:57 +00:00
|
|
|
if e.id.LocalPort == 0 {
|
2018-12-28 19:26:01 +00:00
|
|
|
port, err := e.stack.ReservePort(netProtos, ProtocolNumber, id.LocalAddress, id.LocalPort, e.reusePort)
|
2018-09-12 16:37:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return id, err
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
2018-09-12 16:37:57 +00:00
|
|
|
id.LocalPort = port
|
|
|
|
}
|
2018-04-27 17:37:02 +00:00
|
|
|
|
2018-12-28 19:26:01 +00:00
|
|
|
err := e.stack.RegisterTransportEndpoint(nicid, netProtos, ProtocolNumber, id, e, e.reusePort)
|
2018-09-12 16:37:57 +00:00
|
|
|
if err != nil {
|
|
|
|
e.stack.ReleasePort(netProtos, ProtocolNumber, id.LocalAddress, id.LocalPort)
|
|
|
|
}
|
2018-04-27 17:37:02 +00:00
|
|
|
return id, err
|
|
|
|
}
|
|
|
|
|
2019-03-05 22:52:35 +00:00
|
|
|
func (e *endpoint) bindLocked(addr tcpip.FullAddress) *tcpip.Error {
|
2018-04-27 17:37:02 +00:00
|
|
|
// Don't allow binding once endpoint is not in the initial state
|
|
|
|
// anymore.
|
|
|
|
if e.state != stateInitial {
|
|
|
|
return tcpip.ErrInvalidEndpointState
|
|
|
|
}
|
|
|
|
|
2018-05-17 19:49:16 +00:00
|
|
|
netProto, err := e.checkV4Mapped(&addr, true)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Expand netProtos to include v4 and v6 if the caller is binding to a
|
|
|
|
// wildcard (empty) address, and this is an IPv6 endpoint with v6only
|
|
|
|
// set to false.
|
|
|
|
netProtos := []tcpip.NetworkProtocolNumber{netProto}
|
|
|
|
if netProto == header.IPv6ProtocolNumber && !e.v6only && addr.Addr == "" {
|
|
|
|
netProtos = []tcpip.NetworkProtocolNumber{
|
|
|
|
header.IPv6ProtocolNumber,
|
|
|
|
header.IPv4ProtocolNumber,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-08 07:14:06 +00:00
|
|
|
nicid := addr.NIC
|
2018-04-27 17:37:02 +00:00
|
|
|
if len(addr.Addr) != 0 {
|
|
|
|
// A local address was specified, verify that it's valid.
|
2019-02-08 07:14:06 +00:00
|
|
|
nicid = e.stack.CheckLocalAddress(addr.NIC, netProto, addr.Addr)
|
|
|
|
if nicid == 0 {
|
2018-04-27 17:37:02 +00:00
|
|
|
return tcpip.ErrBadLocalAddress
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
id := stack.TransportEndpointID{
|
|
|
|
LocalPort: addr.Port,
|
|
|
|
LocalAddress: addr.Addr,
|
|
|
|
}
|
2019-02-08 07:14:06 +00:00
|
|
|
id, err = e.registerWithStack(nicid, netProtos, id)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
e.id = id
|
2019-02-08 07:14:06 +00:00
|
|
|
e.regNICID = nicid
|
2018-04-27 17:37:02 +00:00
|
|
|
e.effectiveNetProtos = netProtos
|
|
|
|
|
|
|
|
// Mark endpoint as bound.
|
|
|
|
e.state = stateBound
|
|
|
|
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
e.rcvReady = true
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bind binds the endpoint to a specific local address and port.
|
|
|
|
// Specifying a NIC is optional.
|
2019-03-05 22:52:35 +00:00
|
|
|
func (e *endpoint) Bind(addr tcpip.FullAddress) *tcpip.Error {
|
2018-04-27 17:37:02 +00:00
|
|
|
e.mu.Lock()
|
|
|
|
defer e.mu.Unlock()
|
|
|
|
|
2019-03-05 22:52:35 +00:00
|
|
|
err := e.bindLocked(addr)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-02-08 07:14:06 +00:00
|
|
|
// Save the effective NICID generated by bindLocked.
|
|
|
|
e.bindNICID = e.regNICID
|
2018-04-27 17:37:02 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLocalAddress returns the address to which the endpoint is bound.
|
|
|
|
func (e *endpoint) GetLocalAddress() (tcpip.FullAddress, *tcpip.Error) {
|
|
|
|
e.mu.RLock()
|
|
|
|
defer e.mu.RUnlock()
|
|
|
|
|
|
|
|
return tcpip.FullAddress{
|
|
|
|
NIC: e.regNICID,
|
|
|
|
Addr: e.id.LocalAddress,
|
|
|
|
Port: e.id.LocalPort,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetRemoteAddress returns the address to which the endpoint is connected.
|
|
|
|
func (e *endpoint) GetRemoteAddress() (tcpip.FullAddress, *tcpip.Error) {
|
|
|
|
e.mu.RLock()
|
|
|
|
defer e.mu.RUnlock()
|
|
|
|
|
|
|
|
if e.state != stateConnected {
|
|
|
|
return tcpip.FullAddress{}, tcpip.ErrNotConnected
|
|
|
|
}
|
|
|
|
|
|
|
|
return tcpip.FullAddress{
|
|
|
|
NIC: e.regNICID,
|
|
|
|
Addr: e.id.RemoteAddress,
|
|
|
|
Port: e.id.RemotePort,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Readiness returns the current readiness of the endpoint. For example, if
|
|
|
|
// waiter.EventIn is set, the endpoint is immediately readable.
|
|
|
|
func (e *endpoint) Readiness(mask waiter.EventMask) waiter.EventMask {
|
|
|
|
// The endpoint is always writable.
|
|
|
|
result := waiter.EventOut & mask
|
|
|
|
|
|
|
|
// Determine if the endpoint is readable if requested.
|
|
|
|
if (mask & waiter.EventIn) != 0 {
|
|
|
|
e.rcvMu.Lock()
|
|
|
|
if !e.rcvList.Empty() || e.rcvClosed {
|
|
|
|
result |= waiter.EventIn
|
|
|
|
}
|
|
|
|
e.rcvMu.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
|
|
|
// HandlePacket is called by the stack when new packets arrive to this transport
|
|
|
|
// endpoint.
|
2019-04-02 18:12:29 +00:00
|
|
|
func (e *endpoint) HandlePacket(r *stack.Route, id stack.TransportEndpointID, vv buffer.VectorisedView) {
|
2018-04-27 17:37:02 +00:00
|
|
|
// Get the header then trim it from the view.
|
|
|
|
hdr := header.UDP(vv.First())
|
|
|
|
if int(hdr.Length()) > vv.Size() {
|
|
|
|
// Malformed packet.
|
2018-08-27 22:28:38 +00:00
|
|
|
e.stack.Stats().UDP.MalformedPacketsReceived.Increment()
|
2018-04-27 17:37:02 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
vv.TrimFront(header.UDPMinimumSize)
|
|
|
|
|
|
|
|
e.rcvMu.Lock()
|
2018-08-27 22:28:38 +00:00
|
|
|
e.stack.Stats().UDP.PacketsReceived.Increment()
|
2018-04-27 17:37:02 +00:00
|
|
|
|
|
|
|
// Drop the packet if our buffer is currently full.
|
|
|
|
if !e.rcvReady || e.rcvClosed || e.rcvBufSize >= e.rcvBufSizeMax {
|
2018-08-27 22:28:38 +00:00
|
|
|
e.stack.Stats().UDP.ReceiveBufferErrors.Increment()
|
2018-04-27 17:37:02 +00:00
|
|
|
e.rcvMu.Unlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
wasEmpty := e.rcvBufSize == 0
|
|
|
|
|
|
|
|
// Push new packet into receive list and increment the buffer size.
|
|
|
|
pkt := &udpPacket{
|
|
|
|
senderAddress: tcpip.FullAddress{
|
|
|
|
NIC: r.NICID(),
|
|
|
|
Addr: id.RemoteAddress,
|
|
|
|
Port: hdr.SourcePort(),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
pkt.data = vv.Clone(pkt.views[:])
|
|
|
|
e.rcvList.PushBack(pkt)
|
|
|
|
e.rcvBufSize += vv.Size()
|
|
|
|
|
2019-02-15 19:17:51 +00:00
|
|
|
pkt.timestamp = e.stack.NowNanoseconds()
|
2018-05-02 05:11:07 +00:00
|
|
|
|
2018-04-27 17:37:02 +00:00
|
|
|
e.rcvMu.Unlock()
|
|
|
|
|
|
|
|
// Notify any waiters that there's data to be read now.
|
|
|
|
if wasEmpty {
|
|
|
|
e.waiterQueue.Notify(waiter.EventIn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// HandleControlPacket implements stack.TransportEndpoint.HandleControlPacket.
|
2018-09-13 04:57:04 +00:00
|
|
|
func (e *endpoint) HandleControlPacket(id stack.TransportEndpointID, typ stack.ControlType, extra uint32, vv buffer.VectorisedView) {
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|