diff options
| -rw-r--r-- | pkg/tcpip/link/muxed/BUILD | 31 | ||||
| -rw-r--r-- | pkg/tcpip/link/muxed/injectable.go | 103 | ||||
| -rw-r--r-- | pkg/tcpip/link/muxed/injectable_test.go | 78 | ||||
| -rw-r--r-- | pkg/tcpip/stack/registration.go | 9 |
4 files changed, 221 insertions, 0 deletions
diff --git a/pkg/tcpip/link/muxed/BUILD b/pkg/tcpip/link/muxed/BUILD new file mode 100644 index 000000000..92d2e3290 --- /dev/null +++ b/pkg/tcpip/link/muxed/BUILD @@ -0,0 +1,31 @@ +load("//tools/go_stateify:defs.bzl", "go_library", "go_test") + +package(licenses = ["notice"]) # Apache 2.0 + +go_library( + name = "injectable", + srcs = ["injectable.go"], + importpath = "gvisor.googlesource.com/gvisor/pkg/tcpip/link/injectable", + visibility = [ + "//visibility:public", + ], + deps = [ + "//pkg/tcpip", + "//pkg/tcpip/buffer", + "//pkg/tcpip/stack", + ], +) + +go_test( + name = "injectable_test", + size = "small", + srcs = ["injectable_test.go"], + embed = [":injectable"], + deps = [ + "//pkg/tcpip", + "//pkg/tcpip/buffer", + "//pkg/tcpip/link/fdbased", + "//pkg/tcpip/network/ipv4", + "//pkg/tcpip/stack", + ], +) diff --git a/pkg/tcpip/link/muxed/injectable.go b/pkg/tcpip/link/muxed/injectable.go new file mode 100644 index 000000000..1215ba1e7 --- /dev/null +++ b/pkg/tcpip/link/muxed/injectable.go @@ -0,0 +1,103 @@ +// Copyright 2019 Google LLC +// +// 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. + +// Package injectable provides a muxed injectable endpoint. +package injectable + +import ( + "gvisor.googlesource.com/gvisor/pkg/tcpip" + "gvisor.googlesource.com/gvisor/pkg/tcpip/buffer" + "gvisor.googlesource.com/gvisor/pkg/tcpip/stack" +) + +// MuxedInjectableEndpoint is an injectable multi endpoint. The endpoint has +// trivial routing rules that determine which InjectableEndpoint a given packet +// will be written to. Note that HandleLocal works differently for this +// endpoint (see WritePacket). +type MuxedInjectableEndpoint struct { + routes map[tcpip.Address]stack.InjectableLinkEndpoint + dispatcher stack.NetworkDispatcher +} + +// MTU implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) MTU() uint32 { + minMTU := ^uint32(0) + for _, endpoint := range m.routes { + if endpointMTU := endpoint.MTU(); endpointMTU < minMTU { + minMTU = endpointMTU + } + } + return minMTU +} + +// Capabilities implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) Capabilities() stack.LinkEndpointCapabilities { + minCapabilities := stack.LinkEndpointCapabilities(^uint(0)) + for _, endpoint := range m.routes { + minCapabilities &= endpoint.Capabilities() + } + return minCapabilities +} + +// MaxHeaderLength implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) MaxHeaderLength() uint16 { + minHeaderLen := ^uint16(0) + for _, endpoint := range m.routes { + if headerLen := endpoint.MaxHeaderLength(); headerLen < minHeaderLen { + minHeaderLen = headerLen + } + } + return minHeaderLen +} + +// LinkAddress implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) LinkAddress() tcpip.LinkAddress { + return "" +} + +// Attach implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) Attach(dispatcher stack.NetworkDispatcher) { + for _, endpoint := range m.routes { + endpoint.Attach(dispatcher) + } + m.dispatcher = dispatcher +} + +// IsAttached implements stack.LinkEndpoint. +func (m *MuxedInjectableEndpoint) IsAttached() bool { + return m.dispatcher != nil +} + +// Inject implements stack.InjectableLinkEndpoint. +func (m *MuxedInjectableEndpoint) Inject(protocol tcpip.NetworkProtocolNumber, vv buffer.VectorisedView) { + m.dispatcher.DeliverNetworkPacket(m, "" /* remote */, "" /* local */, protocol, vv) +} + +// WritePacket writes outbound packets to the appropriate LinkInjectableEndpoint +// based on the RemoteAddress. HandleLocal only works if r.RemoteAddress has a +// route registered in this endpoint. +func (m *MuxedInjectableEndpoint) WritePacket(r *stack.Route, hdr buffer.Prependable, payload buffer.VectorisedView, protocol tcpip.NetworkProtocolNumber) *tcpip.Error { + if endpoint, ok := m.routes[r.RemoteAddress]; ok { + return endpoint.WritePacket(r, hdr, payload, protocol) + } + return tcpip.ErrNoRoute +} + +// NewMuxedInjectableEndpoint creates a new multi-fd-based injectable endpoint. +func NewMuxedInjectableEndpoint(routes map[tcpip.Address]stack.InjectableLinkEndpoint, mtu uint32) (tcpip.LinkEndpointID, *MuxedInjectableEndpoint) { + e := &MuxedInjectableEndpoint{ + routes: routes, + } + return stack.RegisterLinkEndpoint(e), e +} diff --git a/pkg/tcpip/link/muxed/injectable_test.go b/pkg/tcpip/link/muxed/injectable_test.go new file mode 100644 index 000000000..8a1a863ff --- /dev/null +++ b/pkg/tcpip/link/muxed/injectable_test.go @@ -0,0 +1,78 @@ +// Copyright 2019 Google LLC +// +// 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. + +package injectable + +import ( + "bytes" + "net" + "os" + "syscall" + "testing" + + "gvisor.googlesource.com/gvisor/pkg/tcpip" + "gvisor.googlesource.com/gvisor/pkg/tcpip/buffer" + "gvisor.googlesource.com/gvisor/pkg/tcpip/link/fdbased" + "gvisor.googlesource.com/gvisor/pkg/tcpip/network/ipv4" + "gvisor.googlesource.com/gvisor/pkg/tcpip/stack" +) + +func TestMuxedEndpointDispatch(t *testing.T) { + endpoint, sock, dstIP := makeMuxedTestEndpoint(t) + hdr := buffer.NewPrependable(1) + hdr.Prepend(1)[0] = 0xFA + packetRoute := stack.Route{RemoteAddress: dstIP} + + endpoint.WritePacket(&packetRoute, hdr, + buffer.NewViewFromBytes([]byte{0xFB}).ToVectorisedView(), ipv4.ProtocolNumber) + + buf := make([]byte, 6500) + bytesRead, err := sock.Read(buf) + if err != nil { + t.Fatalf("Unable to read from socketpair: %v", err) + } + if got, want := buf[:bytesRead], []byte{0xFA, 0xFB}; !bytes.Equal(got, want) { + t.Fatalf("Read %v from the socketpair, wanted %v", got, want) + } +} + +func TestMuxedEndpointDispatchHdrOnly(t *testing.T) { + endpoint, sock, dstIP := makeMuxedTestEndpoint(t) + hdr := buffer.NewPrependable(1) + hdr.Prepend(1)[0] = 0xFA + packetRoute := stack.Route{RemoteAddress: dstIP} + endpoint.WritePacket(&packetRoute, hdr, + buffer.NewView(0).ToVectorisedView(), ipv4.ProtocolNumber) + buf := make([]byte, 6500) + bytesRead, err := sock.Read(buf) + if err != nil { + t.Fatalf("Unable to read from socketpair: %v", err) + } + if got, want := buf[:bytesRead], []byte{0xFA}; !bytes.Equal(got, want) { + t.Fatalf("Read %v from the socketpair, wanted %v", got, want) + } +} + +func makeMuxedTestEndpoint(t *testing.T) (*MuxedInjectableEndpoint, *os.File, tcpip.Address) { + dstIP := tcpip.Address(net.ParseIP("1.2.3.4").To4()) + pair, err := syscall.Socketpair(syscall.AF_UNIX, + syscall.SOCK_SEQPACKET|syscall.SOCK_CLOEXEC|syscall.SOCK_NONBLOCK, 0) + if err != nil { + t.Fatal("Failed to create socket pair:", err) + } + _, underlyingEndpoint := fdbased.NewInjectable(pair[1], 6500) + routes := map[tcpip.Address]stack.InjectableLinkEndpoint{dstIP: underlyingEndpoint} + _, endpoint := NewMuxedInjectableEndpoint(routes, 6500) + return endpoint, os.NewFile(uintptr(pair[0]), "test route end"), dstIP +} diff --git a/pkg/tcpip/stack/registration.go b/pkg/tcpip/stack/registration.go index 6becd9426..010d51886 100644 --- a/pkg/tcpip/stack/registration.go +++ b/pkg/tcpip/stack/registration.go @@ -253,6 +253,15 @@ type LinkEndpoint interface { IsAttached() bool } +// InjectableLinkEndpoint is a LinkEndpoint where inbound packets are +// delivered via the Inject method. +type InjectableLinkEndpoint interface { + LinkEndpoint + + // Inject injects an inbound packet. + Inject(protocol tcpip.NetworkProtocolNumber, vv buffer.VectorisedView) +} + // A LinkAddressResolver is an extension to a NetworkProtocol that // can resolve link addresses. type LinkAddressResolver interface { |