src/connectivity/network/netstack/link/bridge/bridge.go - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //go:build !build_with_native_toolchain
 // +build !build_with_native_toolchain

 // link/bridge implements a bridging LinkEndpoint
 // It can be writable.
 package bridge

 import (
 	"fmt"
 	"hash/fnv"
 	"math"
 	"sort"
 	"strings"
 	"sync"

 	"fidl/fuchsia/hardware/network"

 	"go.fuchsia.dev/fuchsia/src/connectivity/network/netstack/link"
 	syslog "go.fuchsia.dev/fuchsia/src/lib/syslog/go"

 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 )

 var _ stack.LinkEndpoint = (*Endpoint)(nil)
 var _ link.Controller = (*Endpoint)(nil)

 type Endpoint struct {
 	links           map[tcpip.LinkAddress]*BridgeableEndpoint
 	mtu             uint32
 	capabilities    stack.LinkEndpointCapabilities
 	maxHeaderLength uint16
 	linkAddress     tcpip.LinkAddress

 	mu struct {
 		sync.RWMutex

 		dispatcher stack.NetworkDispatcher
 	}
 }

 // New creates a new link from a list of BridgeableEndpoints that bridges
 // packets written to it and received from any of its constituent links.
 //
 // `links` must be non-empty, as properties of the new link are derived from
 // the constituent links: it will have the minimum of the MTUs, the maximum
 // of the max header lengths, and the minimum set of capabilities.
 func New(links []*BridgeableEndpoint) (*Endpoint, error) {
 	if len(links) == 0 {
 		return nil, fmt.Errorf("creating bridge with no attached endpoints is invalid")
 	}
 	{
 		// TODO(https://fxbug.dev/57022): Make sure links are all using the same kind of link.
 		links := append([]*BridgeableEndpoint(nil), links...)
 		sort.Slice(links, func(i, j int) bool {
 			return strings.Compare(string(links[i].LinkAddress()), string(links[j].LinkAddress())) > 0
 		})
 		ep := &Endpoint{
 			links: make(map[tcpip.LinkAddress]*BridgeableEndpoint),
 			mtu:   math.MaxUint32,
 		}
 		h := fnv.New64()
 		for _, l := range links {
 			linkAddress := l.LinkAddress()
 			ep.links[linkAddress] = l

 			// mtu is the maximum write size, which is the minimum of any link's mtu.
 			if mtu := l.MTU(); mtu < ep.mtu {
 				ep.mtu = mtu
 			}

 			// Resolution is required if any link requires it.
 			ep.capabilities |= l.Capabilities() & stack.CapabilityResolutionRequired

 			// maxHeaderLength is the space to reserve for possible addition
 			// headers. We want to reserve enough to suffice for all links.
 			if maxHeaderLength := l.MaxHeaderLength(); maxHeaderLength > ep.maxHeaderLength {
 				ep.maxHeaderLength = maxHeaderLength
 			}

 			if _, err := h.Write([]byte(linkAddress)); err != nil {
 				panic(err)
 			}
 		}
 		b := h.Sum(nil)[:6]
 		// Set the second-least-significant bit of the first byte so the address is locally-administered.
 		b[0] |= 1 << 1
 		// Clear the least-significant bit of the first byte so the address is unicast.
 		b[0] &^= 1
 		ep.linkAddress = tcpip.LinkAddress(b)
 		return ep, nil
 	}
 }

 func (*Endpoint) Up() error {
 	return nil
 }

 // TODO(https://fxbug.dev/86388): Implement disabling the bridge.
 func (*Endpoint) Down() error {
 	_ = syslog.Warnf("disabling bridges is unimplemented, the bridge will still be usable")
 	return nil
 }

 // SetPromiscuousMode on a bridge is a no-op, since all of the constituent
 // links on a bridge need to already be in promiscuous mode for bridging to
 // work.
 func (*Endpoint) SetPromiscuousMode(bool) error {
 	return nil
 }

 func (*Endpoint) DeviceClass() network.DeviceClass {
 	return network.DeviceClassBridge
 }

 func (ep *Endpoint) MTU() uint32 {
 	return ep.mtu
 }

 func (ep *Endpoint) Capabilities() stack.LinkEndpointCapabilities {
 	return ep.capabilities
 }

 func (ep *Endpoint) MaxHeaderLength() uint16 {
 	return ep.maxHeaderLength
 }

 func (ep *Endpoint) LinkAddress() tcpip.LinkAddress {
 	return ep.linkAddress
 }

 func (ep *Endpoint) WritePacket(r stack.RouteInfo, protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
 	ep.AddHeader(ep.LinkAddress(), r.RemoteLinkAddress, protocol, pkt)
 	return ep.WriteRawPacket(pkt)
 }

 // WritePackets returns the number of packets in hdrs that were successfully
 // written to all links.
 func (ep *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
 	cnt := 0
 	for pkt := pkts.Front(); pkt != nil; pkt = pkt.Next() {
 		switch err := ep.WritePacket(r, protocol, pkt); err.(type) {
 		case nil:
 			cnt++
 		default:
 			return cnt, err
 		}
 	}
 	return cnt, nil
 }

 func (ep *Endpoint) WriteRawPacket(pkt *stack.PacketBuffer) tcpip.Error {
 	i := 0
 	for _, l := range ep.links {
 		i++
 		// Need to clone when writing to all but the last endpoint, since callee
 		// takes ownership.
 		pkt := pkt
 		if i != len(ep.links) {
 			pkt = pkt.Clone()
 		}
 		switch err := l.WriteRawPacket(pkt); err.(type) {
 		case nil:
 		case *tcpip.ErrClosedForSend:
 			// TODO(https://fxbug.dev/86959): Handle bridged interface removal.
 			_ = syslog.Warnf("WriteRawPacket on bridged endpoint returned ClosedForSend")
 		default:
 			return err
 		}
 	}
 	return nil
 }

 func (ep *Endpoint) Attach(d stack.NetworkDispatcher) {
 	ep.mu.Lock()
 	defer ep.mu.Unlock()

 	ep.mu.dispatcher = d
 	if d == nil {
 		for _, l := range ep.links {
 			l.SetBridge(nil)
 		}
 	}
 }

 func (ep *Endpoint) IsAttached() bool {
 	ep.mu.RLock()
 	defer ep.mu.RUnlock()
 	return ep.mu.dispatcher != nil
 }

 // DeliverNetworkPacketToBridge delivers a network packet to the bridged network.
 //
 // Endpoint does not implement stack.NetworkEndpoint.DeliverNetworkPacket because we need
 // to know which BridgeableEndpoint the packet was delivered from to prevent packet loops.
 func (ep *Endpoint) DeliverNetworkPacketToBridge(rxEP *BridgeableEndpoint, srcLinkAddr, dstLinkAddr tcpip.LinkAddress, protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {
 	ep.mu.RLock()
 	dispatcher := ep.mu.dispatcher
 	ep.mu.RUnlock()

 	if dstLinkAddr == ep.linkAddress {
 		if dispatcher != nil {
 			dispatcher.DeliverNetworkPacket(srcLinkAddr, dstLinkAddr, protocol, pkt)
 		}
 		return
 	}

 	if len(dstLinkAddr) != header.EthernetAddressSize {
 		panic(fmt.Sprintf("DeliverNetworkPacket(%p, %s, %s, %d, _) called with non-MAC dst link addr", rxEP, srcLinkAddr, dstLinkAddr, protocol))
 	}

 	if header.IsMulticastEthernetAddress(dstLinkAddr) {
 		// The bridge `ep` isn't included in ep.links below.
 		//
 		// Need to clone as callee takes ownership and the packet still needs to be
 		// written to constituent links.
 		if dispatcher != nil {
 			dispatcher.DeliverNetworkPacket(srcLinkAddr, dstLinkAddr, protocol, pkt.Clone())
 		}
 	}

 	// TODO(https://fxbug.dev/20778): Learn which destinations are on
 	// which links and restrict transmission, like a bridge.
 	i := 0
 	rxFound := false
 	for _, l := range ep.links {
 		i++
 		// Don't write back out the interface from which the frame arrived
 		// because that causes interoperability issues with a router.
 		if l == rxEP {
 			rxFound = true
 			continue
 		}

 		// Shadow pkt so that changes the link makes to the packet buffer
 		// are not visible to links we write the packet to after.
 		pkt := pkt
 		switch i {
 		case len(ep.links):
 			// The last call never needs cloning.
 		case len(ep.links) - 1:
 			// The second-to-last call needs cloning iff the last endpoint is not rxEP.
 			if !rxFound {
 				break
 			}
 			fallthrough
 		default:
 			pkt = pkt.Clone()
 		}

 		switch err := l.WriteRawPacket(pkt); err.(type) {
 		case nil:
 		case *tcpip.ErrClosedForSend:
 			// TODO(https://fxbug.dev/86959): Handle bridged interface removal.
 		default:
 			_ = syslog.Warnf("failed to write to bridged endpoint %p: %s", l, err)
 		}
 	}
 }

 // Wait implements stack.LinkEndpoint.
 func (*Endpoint) Wait() {}

 // ARPHardwareType implements stack.LinkEndpoint.
 func (e *Endpoint) ARPHardwareType() header.ARPHardwareType {
 	// Use the first bridged endpoint.
 	for _, link := range e.links {
 		return link.ARPHardwareType()
 	}

 	return header.ARPHardwareNone
 }

 // AddHeader implements stack.LinkEndpoint.
 func (e *Endpoint) AddHeader(local, remote tcpip.LinkAddress, protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {
 	// Use the first bridged endpoint.
 	for _, link := range e.links {
 		link.AddHeader(local, remote, protocol, pkt)
 		return
 	}
 }
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//go:build !build_with_native_toolchain
	// +build !build_with_native_toolchain

	// link/bridge implements a bridging LinkEndpoint
	// It can be writable.
	package bridge

	import (
	"fmt"
	"hash/fnv"
	"math"
	"sort"
	"strings"
	"sync"

	"fidl/fuchsia/hardware/network"

	"go.fuchsia.dev/fuchsia/src/connectivity/network/netstack/link"
	syslog "go.fuchsia.dev/fuchsia/src/lib/syslog/go"

	"gvisor.dev/gvisor/pkg/tcpip"
	"gvisor.dev/gvisor/pkg/tcpip/header"
	"gvisor.dev/gvisor/pkg/tcpip/stack"
	)

	var _ stack.LinkEndpoint = (*Endpoint)(nil)
	var _ link.Controller = (*Endpoint)(nil)

	type Endpoint struct {
	links map[tcpip.LinkAddress]*BridgeableEndpoint
	mtu uint32
	capabilities stack.LinkEndpointCapabilities
	maxHeaderLength uint16
	linkAddress tcpip.LinkAddress

	mu struct {
	sync.RWMutex

	dispatcher stack.NetworkDispatcher
	}
	}

	// New creates a new link from a list of BridgeableEndpoints that bridges
	// packets written to it and received from any of its constituent links.
	//
	// `links` must be non-empty, as properties of the new link are derived from
	// the constituent links: it will have the minimum of the MTUs, the maximum
	// of the max header lengths, and the minimum set of capabilities.
	func New(links []BridgeableEndpoint) (Endpoint, error) {
	if len(links) == 0 {
	return nil, fmt.Errorf("creating bridge with no attached endpoints is invalid")
	}
	{
	// TODO(https://fxbug.dev/57022): Make sure links are all using the same kind of link.
	links := append([]*BridgeableEndpoint(nil), links...)
	sort.Slice(links, func(i, j int) bool {
	return strings.Compare(string(links[i].LinkAddress()), string(links[j].LinkAddress())) > 0
	})
	ep := &Endpoint{
	links: make(map[tcpip.LinkAddress]*BridgeableEndpoint),
	mtu: math.MaxUint32,
	}
	h := fnv.New64()
	for _, l := range links {
	linkAddress := l.LinkAddress()
	ep.links[linkAddress] = l

	// mtu is the maximum write size, which is the minimum of any link's mtu.
	if mtu := l.MTU(); mtu < ep.mtu {
	ep.mtu = mtu
	}

	// Resolution is required if any link requires it.
	ep.capabilities \|= l.Capabilities() & stack.CapabilityResolutionRequired

	// maxHeaderLength is the space to reserve for possible addition
	// headers. We want to reserve enough to suffice for all links.
	if maxHeaderLength := l.MaxHeaderLength(); maxHeaderLength > ep.maxHeaderLength {
	ep.maxHeaderLength = maxHeaderLength
	}

	if _, err := h.Write([]byte(linkAddress)); err != nil {
	panic(err)
	}
	}
	b := h.Sum(nil)[:6]
	// Set the second-least-significant bit of the first byte so the address is locally-administered.
	b[0] \|= 1 << 1
	// Clear the least-significant bit of the first byte so the address is unicast.
	b[0] &^= 1
	ep.linkAddress = tcpip.LinkAddress(b)
	return ep, nil
	}
	}

	func (*Endpoint) Up() error {
	return nil
	}

	// TODO(https://fxbug.dev/86388): Implement disabling the bridge.
	func (*Endpoint) Down() error {
	_ = syslog.Warnf("disabling bridges is unimplemented, the bridge will still be usable")
	return nil
	}

	// SetPromiscuousMode on a bridge is a no-op, since all of the constituent
	// links on a bridge need to already be in promiscuous mode for bridging to
	// work.
	func (*Endpoint) SetPromiscuousMode(bool) error {
	return nil
	}

	func (*Endpoint) DeviceClass() network.DeviceClass {
	return network.DeviceClassBridge
	}

	func (ep *Endpoint) MTU() uint32 {
	return ep.mtu
	}

	func (ep *Endpoint) Capabilities() stack.LinkEndpointCapabilities {
	return ep.capabilities
	}

	func (ep *Endpoint) MaxHeaderLength() uint16 {
	return ep.maxHeaderLength
	}

	func (ep *Endpoint) LinkAddress() tcpip.LinkAddress {
	return ep.linkAddress
	}

	func (ep Endpoint) WritePacket(r stack.RouteInfo, protocol tcpip.NetworkProtocolNumber, pkt stack.PacketBuffer) tcpip.Error {
	ep.AddHeader(ep.LinkAddress(), r.RemoteLinkAddress, protocol, pkt)
	return ep.WriteRawPacket(pkt)
	}

	// WritePackets returns the number of packets in hdrs that were successfully
	// written to all links.
	func (ep *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
	cnt := 0
	for pkt := pkts.Front(); pkt != nil; pkt = pkt.Next() {
	switch err := ep.WritePacket(r, protocol, pkt); err.(type) {
	case nil:
	cnt++
	default:
	return cnt, err
	}
	}
	return cnt, nil
	}

	func (ep Endpoint) WriteRawPacket(pkt stack.PacketBuffer) tcpip.Error {
	i := 0
	for _, l := range ep.links {
	i++
	// Need to clone when writing to all but the last endpoint, since callee
	// takes ownership.
	pkt := pkt
	if i != len(ep.links) {
	pkt = pkt.Clone()
	}
	switch err := l.WriteRawPacket(pkt); err.(type) {
	case nil:
	case *tcpip.ErrClosedForSend:
	// TODO(https://fxbug.dev/86959): Handle bridged interface removal.
	_ = syslog.Warnf("WriteRawPacket on bridged endpoint returned ClosedForSend")
	default:
	return err
	}
	}
	return nil
	}

	func (ep *Endpoint) Attach(d stack.NetworkDispatcher) {
	ep.mu.Lock()
	defer ep.mu.Unlock()

	ep.mu.dispatcher = d
	if d == nil {
	for _, l := range ep.links {
	l.SetBridge(nil)
	}
	}
	}

	func (ep *Endpoint) IsAttached() bool {
	ep.mu.RLock()
	defer ep.mu.RUnlock()
	return ep.mu.dispatcher != nil
	}

	// DeliverNetworkPacketToBridge delivers a network packet to the bridged network.
	//
	// Endpoint does not implement stack.NetworkEndpoint.DeliverNetworkPacket because we need
	// to know which BridgeableEndpoint the packet was delivered from to prevent packet loops.
	func (ep Endpoint) DeliverNetworkPacketToBridge(rxEP BridgeableEndpoint, srcLinkAddr, dstLinkAddr tcpip.LinkAddress, protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {
	ep.mu.RLock()
	dispatcher := ep.mu.dispatcher
	ep.mu.RUnlock()

	if dstLinkAddr == ep.linkAddress {
	if dispatcher != nil {
	dispatcher.DeliverNetworkPacket(srcLinkAddr, dstLinkAddr, protocol, pkt)
	}
	return
	}

	if len(dstLinkAddr) != header.EthernetAddressSize {
	panic(fmt.Sprintf("DeliverNetworkPacket(%p, %s, %s, %d, _) called with non-MAC dst link addr", rxEP, srcLinkAddr, dstLinkAddr, protocol))
	}

	if header.IsMulticastEthernetAddress(dstLinkAddr) {
	// The bridge `ep` isn't included in ep.links below.
	//
	// Need to clone as callee takes ownership and the packet still needs to be
	// written to constituent links.
	if dispatcher != nil {
	dispatcher.DeliverNetworkPacket(srcLinkAddr, dstLinkAddr, protocol, pkt.Clone())
	}
	}

	// TODO(https://fxbug.dev/20778): Learn which destinations are on
	// which links and restrict transmission, like a bridge.
	i := 0
	rxFound := false
	for _, l := range ep.links {
	i++
	// Don't write back out the interface from which the frame arrived
	// because that causes interoperability issues with a router.
	if l == rxEP {
	rxFound = true
	continue
	}

	// Shadow pkt so that changes the link makes to the packet buffer
	// are not visible to links we write the packet to after.
	pkt := pkt
	switch i {
	case len(ep.links):
	// The last call never needs cloning.
	case len(ep.links) - 1:
	// The second-to-last call needs cloning iff the last endpoint is not rxEP.
	if !rxFound {
	break
	}
	fallthrough
	default:
	pkt = pkt.Clone()
	}

	switch err := l.WriteRawPacket(pkt); err.(type) {
	case nil:
	case *tcpip.ErrClosedForSend:
	// TODO(https://fxbug.dev/86959): Handle bridged interface removal.
	default:
	_ = syslog.Warnf("failed to write to bridged endpoint %p: %s", l, err)
	}
	}
	}

	// Wait implements stack.LinkEndpoint.
	func (*Endpoint) Wait() {}

	// ARPHardwareType implements stack.LinkEndpoint.
	func (e *Endpoint) ARPHardwareType() header.ARPHardwareType {
	// Use the first bridged endpoint.
	for _, link := range e.links {
	return link.ARPHardwareType()
	}

	return header.ARPHardwareNone
	}

	// AddHeader implements stack.LinkEndpoint.
	func (e Endpoint) AddHeader(local, remote tcpip.LinkAddress, protocol tcpip.NetworkProtocolNumber, pkt stack.PacketBuffer) {
	// Use the first bridged endpoint.
	for _, link := range e.links {
	link.AddHeader(local, remote, protocol, pkt)
	return
	}
	}