2020-03-17 15:52:14 +00:00
|
|
|
// Copyright 2020 The gVisor Authors.
|
|
|
|
//
|
|
|
|
// 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 testbench has utilities to send and receive packets and also command
|
|
|
|
// the DUT to run POSIX functions.
|
|
|
|
package testbench
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"math/rand"
|
|
|
|
"net"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/mohae/deepcopy"
|
2020-04-16 22:14:44 +00:00
|
|
|
"go.uber.org/multierr"
|
2020-03-17 15:52:14 +00:00
|
|
|
"golang.org/x/sys/unix"
|
|
|
|
"gvisor.dev/gvisor/pkg/tcpip"
|
|
|
|
"gvisor.dev/gvisor/pkg/tcpip/header"
|
|
|
|
"gvisor.dev/gvisor/pkg/tcpip/seqnum"
|
|
|
|
)
|
|
|
|
|
2020-04-29 01:49:19 +00:00
|
|
|
func portFromSockaddr(sa unix.Sockaddr) (uint16, error) {
|
|
|
|
switch sa := sa.(type) {
|
|
|
|
case *unix.SockaddrInet4:
|
|
|
|
return uint16(sa.Port), nil
|
|
|
|
case *unix.SockaddrInet6:
|
|
|
|
return uint16(sa.Port), nil
|
|
|
|
}
|
|
|
|
return 0, fmt.Errorf("sockaddr type %T does not contain port", sa)
|
|
|
|
}
|
|
|
|
|
2020-07-10 05:37:11 +00:00
|
|
|
// pickPort makes a new socket and returns the socket FD and port. The domain
|
|
|
|
// should be AF_INET or AF_INET6. The caller must close the FD when done with
|
2020-04-24 22:55:11 +00:00
|
|
|
// the port if there is no error.
|
2020-07-14 18:48:26 +00:00
|
|
|
func pickPort(domain, typ int) (fd int, port uint16, err error) {
|
|
|
|
fd, err = unix.Socket(domain, typ, 0)
|
2020-03-17 15:52:14 +00:00
|
|
|
if err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
return -1, 0, fmt.Errorf("creating socket: %w", err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-24 22:55:11 +00:00
|
|
|
defer func() {
|
|
|
|
if err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
if cerr := unix.Close(fd); cerr != nil {
|
|
|
|
err = multierr.Append(err, fmt.Errorf("failed to close socket %d: %w", fd, cerr))
|
|
|
|
}
|
2020-04-24 22:55:11 +00:00
|
|
|
}
|
|
|
|
}()
|
2020-06-11 20:46:56 +00:00
|
|
|
var sa unix.Sockaddr
|
2020-04-24 22:55:11 +00:00
|
|
|
switch domain {
|
|
|
|
case unix.AF_INET:
|
|
|
|
var sa4 unix.SockaddrInet4
|
2020-05-11 22:52:42 +00:00
|
|
|
copy(sa4.Addr[:], net.ParseIP(LocalIPv4).To4())
|
2020-04-24 22:55:11 +00:00
|
|
|
sa = &sa4
|
|
|
|
case unix.AF_INET6:
|
2020-07-14 18:48:26 +00:00
|
|
|
sa6 := unix.SockaddrInet6{ZoneId: uint32(LocalInterfaceID)}
|
2020-05-11 22:52:42 +00:00
|
|
|
copy(sa6.Addr[:], net.ParseIP(LocalIPv6).To16())
|
2020-04-24 22:55:11 +00:00
|
|
|
sa = &sa6
|
|
|
|
default:
|
2020-06-11 20:46:56 +00:00
|
|
|
return -1, 0, fmt.Errorf("invalid domain %d, it should be one of unix.AF_INET or unix.AF_INET6", domain)
|
2020-04-24 22:55:11 +00:00
|
|
|
}
|
|
|
|
if err = unix.Bind(fd, sa); err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
return -1, 0, fmt.Errorf("binding to %+v: %w", sa, err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-29 01:49:19 +00:00
|
|
|
sa, err = unix.Getsockname(fd)
|
2020-03-17 15:52:14 +00:00
|
|
|
if err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
return -1, 0, fmt.Errorf("Getsocketname(%d): %w", fd, err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-07-14 18:48:26 +00:00
|
|
|
port, err = portFromSockaddr(sa)
|
2020-06-11 20:46:56 +00:00
|
|
|
if err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
return -1, 0, fmt.Errorf("extracting port from socket address %+v: %w", sa, err)
|
2020-06-11 20:46:56 +00:00
|
|
|
}
|
|
|
|
return fd, port, nil
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// layerState stores the state of a layer of a connection.
|
|
|
|
type layerState interface {
|
2020-04-24 22:02:33 +00:00
|
|
|
// outgoing returns an outgoing layer to be sent in a frame. It should not
|
|
|
|
// update layerState, that is done in layerState.sent.
|
2020-04-15 19:59:58 +00:00
|
|
|
outgoing() Layer
|
|
|
|
|
|
|
|
// incoming creates an expected Layer for comparing against a received Layer.
|
|
|
|
// Because the expectation can depend on values in the received Layer, it is
|
|
|
|
// an input to incoming. For example, the ACK number needs to be checked in a
|
2020-04-24 22:02:33 +00:00
|
|
|
// TCP packet but only if the ACK flag is set in the received packet. It
|
|
|
|
// should not update layerState, that is done in layerState.received. The
|
|
|
|
// caller takes ownership of the returned Layer.
|
2020-04-15 19:59:58 +00:00
|
|
|
incoming(received Layer) Layer
|
|
|
|
|
|
|
|
// sent updates the layerState based on the Layer that was sent. The input is
|
|
|
|
// a Layer with all prev and next pointers populated so that the entire frame
|
|
|
|
// as it was sent is available.
|
|
|
|
sent(sent Layer) error
|
|
|
|
|
|
|
|
// received updates the layerState based on a Layer that is receieved. The
|
|
|
|
// input is a Layer with all prev and next pointers populated so that the
|
|
|
|
// entire frame as it was receieved is available.
|
|
|
|
received(received Layer) error
|
|
|
|
|
|
|
|
// close frees associated resources held by the LayerState.
|
|
|
|
close() error
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// etherState maintains state about an Ethernet connection.
|
|
|
|
type etherState struct {
|
|
|
|
out, in Ether
|
|
|
|
}
|
2020-03-17 15:52:14 +00:00
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
var _ layerState = (*etherState)(nil)
|
|
|
|
|
|
|
|
// newEtherState creates a new etherState.
|
|
|
|
func newEtherState(out, in Ether) (*etherState, error) {
|
2020-05-11 22:52:42 +00:00
|
|
|
lMAC, err := tcpip.ParseMACAddress(LocalMAC)
|
2020-03-17 15:52:14 +00:00
|
|
|
if err != nil {
|
2020-05-27 00:39:19 +00:00
|
|
|
return nil, fmt.Errorf("parsing local MAC: %q: %w", LocalMAC, err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-05-11 22:52:42 +00:00
|
|
|
rMAC, err := tcpip.ParseMACAddress(RemoteMAC)
|
2020-03-17 15:52:14 +00:00
|
|
|
if err != nil {
|
2020-05-27 00:39:19 +00:00
|
|
|
return nil, fmt.Errorf("parsing remote MAC: %q: %w", RemoteMAC, err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
s := etherState{
|
|
|
|
out: Ether{SrcAddr: &lMAC, DstAddr: &rMAC},
|
|
|
|
in: Ether{SrcAddr: &rMAC, DstAddr: &lMAC},
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if err := s.out.merge(&out); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if err := s.in.merge(&in); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &s, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *etherState) outgoing() Layer {
|
2020-04-24 22:55:11 +00:00
|
|
|
return deepcopy.Copy(&s.out).(Layer)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 14:27:34 +00:00
|
|
|
// incoming implements layerState.incoming.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *etherState) incoming(Layer) Layer {
|
|
|
|
return deepcopy.Copy(&s.in).(Layer)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*etherState) sent(Layer) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*etherState) received(Layer) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*etherState) close() error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ipv4State maintains state about an IPv4 connection.
|
|
|
|
type ipv4State struct {
|
|
|
|
out, in IPv4
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ layerState = (*ipv4State)(nil)
|
|
|
|
|
|
|
|
// newIPv4State creates a new ipv4State.
|
|
|
|
func newIPv4State(out, in IPv4) (*ipv4State, error) {
|
2020-05-11 22:52:42 +00:00
|
|
|
lIP := tcpip.Address(net.ParseIP(LocalIPv4).To4())
|
|
|
|
rIP := tcpip.Address(net.ParseIP(RemoteIPv4).To4())
|
2020-04-15 19:59:58 +00:00
|
|
|
s := ipv4State{
|
|
|
|
out: IPv4{SrcAddr: &lIP, DstAddr: &rIP},
|
|
|
|
in: IPv4{SrcAddr: &rIP, DstAddr: &lIP},
|
|
|
|
}
|
|
|
|
if err := s.out.merge(&out); err != nil {
|
|
|
|
return nil, err
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if err := s.in.merge(&in); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &s, nil
|
|
|
|
}
|
2020-03-17 15:52:14 +00:00
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *ipv4State) outgoing() Layer {
|
2020-04-24 22:55:11 +00:00
|
|
|
return deepcopy.Copy(&s.out).(Layer)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 14:27:34 +00:00
|
|
|
// incoming implements layerState.incoming.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *ipv4State) incoming(Layer) Layer {
|
|
|
|
return deepcopy.Copy(&s.in).(Layer)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*ipv4State) sent(Layer) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*ipv4State) received(Layer) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*ipv4State) close() error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-24 22:55:11 +00:00
|
|
|
// ipv6State maintains state about an IPv6 connection.
|
|
|
|
type ipv6State struct {
|
|
|
|
out, in IPv6
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ layerState = (*ipv6State)(nil)
|
|
|
|
|
|
|
|
// newIPv6State creates a new ipv6State.
|
|
|
|
func newIPv6State(out, in IPv6) (*ipv6State, error) {
|
2020-05-11 22:52:42 +00:00
|
|
|
lIP := tcpip.Address(net.ParseIP(LocalIPv6).To16())
|
|
|
|
rIP := tcpip.Address(net.ParseIP(RemoteIPv6).To16())
|
2020-04-24 22:55:11 +00:00
|
|
|
s := ipv6State{
|
|
|
|
out: IPv6{SrcAddr: &lIP, DstAddr: &rIP},
|
|
|
|
in: IPv6{SrcAddr: &rIP, DstAddr: &lIP},
|
|
|
|
}
|
|
|
|
if err := s.out.merge(&out); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if err := s.in.merge(&in); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &s, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// outgoing returns an outgoing layer to be sent in a frame.
|
|
|
|
func (s *ipv6State) outgoing() Layer {
|
|
|
|
return deepcopy.Copy(&s.out).(Layer)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *ipv6State) incoming(Layer) Layer {
|
|
|
|
return deepcopy.Copy(&s.in).(Layer)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *ipv6State) sent(Layer) error {
|
|
|
|
// Nothing to do.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *ipv6State) received(Layer) error {
|
|
|
|
// Nothing to do.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// close cleans up any resources held.
|
|
|
|
func (s *ipv6State) close() error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// tcpState maintains state about a TCP connection.
|
|
|
|
type tcpState struct {
|
|
|
|
out, in TCP
|
|
|
|
localSeqNum, remoteSeqNum *seqnum.Value
|
|
|
|
synAck *TCP
|
|
|
|
portPickerFD int
|
2020-04-16 19:21:06 +00:00
|
|
|
finSent bool
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var _ layerState = (*tcpState)(nil)
|
|
|
|
|
|
|
|
// SeqNumValue is a helper routine that allocates a new seqnum.Value value to
|
|
|
|
// store v and returns a pointer to it.
|
|
|
|
func SeqNumValue(v seqnum.Value) *seqnum.Value {
|
|
|
|
return &v
|
|
|
|
}
|
|
|
|
|
|
|
|
// newTCPState creates a new TCPState.
|
2020-06-11 20:46:56 +00:00
|
|
|
func newTCPState(domain int, out, in TCP) (*tcpState, error) {
|
|
|
|
portPickerFD, localPort, err := pickPort(domain, unix.SOCK_STREAM)
|
2020-03-17 15:52:14 +00:00
|
|
|
if err != nil {
|
2020-06-11 20:46:56 +00:00
|
|
|
return nil, err
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
s := tcpState{
|
|
|
|
out: TCP{SrcPort: &localPort},
|
|
|
|
in: TCP{DstPort: &localPort},
|
|
|
|
localSeqNum: SeqNumValue(seqnum.Value(rand.Uint32())),
|
|
|
|
portPickerFD: portPickerFD,
|
2020-04-16 19:21:06 +00:00
|
|
|
finSent: false,
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
if err := s.out.merge(&out); err != nil {
|
2020-06-11 20:46:56 +00:00
|
|
|
return nil, err
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if err := s.in.merge(&in); err != nil {
|
2020-06-11 20:46:56 +00:00
|
|
|
return nil, err
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
2020-06-11 20:46:56 +00:00
|
|
|
return &s, nil
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
2020-03-17 15:52:14 +00:00
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *tcpState) outgoing() Layer {
|
|
|
|
newOutgoing := deepcopy.Copy(s.out).(TCP)
|
|
|
|
if s.localSeqNum != nil {
|
|
|
|
newOutgoing.SeqNum = Uint32(uint32(*s.localSeqNum))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if s.remoteSeqNum != nil {
|
|
|
|
newOutgoing.AckNum = Uint32(uint32(*s.remoteSeqNum))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
return &newOutgoing
|
|
|
|
}
|
|
|
|
|
2020-04-22 14:27:34 +00:00
|
|
|
// incoming implements layerState.incoming.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *tcpState) incoming(received Layer) Layer {
|
|
|
|
tcpReceived, ok := received.(*TCP)
|
|
|
|
if !ok {
|
|
|
|
return nil
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
newIn := deepcopy.Copy(s.in).(TCP)
|
|
|
|
if s.remoteSeqNum != nil {
|
|
|
|
newIn.SeqNum = Uint32(uint32(*s.remoteSeqNum))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if s.localSeqNum != nil && (*tcpReceived.Flags&header.TCPFlagAck) != 0 {
|
|
|
|
// The caller didn't specify an AckNum so we'll expect the calculated one,
|
|
|
|
// but only if the ACK flag is set because the AckNum is not valid in a
|
|
|
|
// header if ACK is not set.
|
|
|
|
newIn.AckNum = Uint32(uint32(*s.localSeqNum))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
return &newIn
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *tcpState) sent(sent Layer) error {
|
|
|
|
tcp, ok := sent.(*TCP)
|
|
|
|
if !ok {
|
|
|
|
return fmt.Errorf("can't update tcpState with %T Layer", sent)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-16 19:21:06 +00:00
|
|
|
if !s.finSent {
|
|
|
|
// update localSeqNum by the payload only when FIN is not yet sent by us
|
|
|
|
for current := tcp.next(); current != nil; current = current.next() {
|
|
|
|
s.localSeqNum.UpdateForward(seqnum.Size(current.length()))
|
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
if tcp.Flags != nil && *tcp.Flags&(header.TCPFlagSyn|header.TCPFlagFin) != 0 {
|
|
|
|
s.localSeqNum.UpdateForward(1)
|
|
|
|
}
|
2020-04-16 19:21:06 +00:00
|
|
|
if *tcp.Flags&(header.TCPFlagFin) != 0 {
|
|
|
|
s.finSent = true
|
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
return nil
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *tcpState) received(l Layer) error {
|
|
|
|
tcp, ok := l.(*TCP)
|
|
|
|
if !ok {
|
|
|
|
return fmt.Errorf("can't update tcpState with %T Layer", l)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
s.remoteSeqNum = SeqNumValue(seqnum.Value(*tcp.SeqNum))
|
|
|
|
if *tcp.Flags&(header.TCPFlagSyn|header.TCPFlagFin) != 0 {
|
|
|
|
s.remoteSeqNum.UpdateForward(1)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
for current := tcp.next(); current != nil; current = current.next() {
|
|
|
|
s.remoteSeqNum.UpdateForward(seqnum.Size(current.length()))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
return nil
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// close frees the port associated with this connection.
|
|
|
|
func (s *tcpState) close() error {
|
|
|
|
if err := unix.Close(s.portPickerFD); err != nil {
|
|
|
|
return err
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
s.portPickerFD = -1
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// udpState maintains state about a UDP connection.
|
|
|
|
type udpState struct {
|
|
|
|
out, in UDP
|
|
|
|
portPickerFD int
|
|
|
|
}
|
2020-03-17 15:52:14 +00:00
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
var _ layerState = (*udpState)(nil)
|
|
|
|
|
|
|
|
// newUDPState creates a new udpState.
|
2020-06-11 20:46:56 +00:00
|
|
|
func newUDPState(domain int, out, in UDP) (*udpState, error) {
|
|
|
|
portPickerFD, localPort, err := pickPort(domain, unix.SOCK_DGRAM)
|
2020-04-15 19:59:58 +00:00
|
|
|
if err != nil {
|
2020-07-14 18:48:26 +00:00
|
|
|
return nil, fmt.Errorf("picking port: %w", err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
s := udpState{
|
|
|
|
out: UDP{SrcPort: &localPort},
|
|
|
|
in: UDP{DstPort: &localPort},
|
|
|
|
portPickerFD: portPickerFD,
|
|
|
|
}
|
|
|
|
if err := s.out.merge(&out); err != nil {
|
2020-06-11 20:46:56 +00:00
|
|
|
return nil, err
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
if err := s.in.merge(&in); err != nil {
|
2020-06-11 20:46:56 +00:00
|
|
|
return nil, err
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-06-11 20:46:56 +00:00
|
|
|
return &s, nil
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *udpState) outgoing() Layer {
|
2020-04-24 22:55:11 +00:00
|
|
|
return deepcopy.Copy(&s.out).(Layer)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 14:27:34 +00:00
|
|
|
// incoming implements layerState.incoming.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (s *udpState) incoming(Layer) Layer {
|
|
|
|
return deepcopy.Copy(&s.in).(Layer)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*udpState) sent(l Layer) error {
|
|
|
|
return nil
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
func (*udpState) received(l Layer) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// close frees the port associated with this connection.
|
|
|
|
func (s *udpState) close() error {
|
|
|
|
if err := unix.Close(s.portPickerFD); err != nil {
|
|
|
|
return err
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
s.portPickerFD = -1
|
2020-04-08 00:48:06 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// Connection holds a collection of layer states for maintaining a connection
|
|
|
|
// along with sockets for sniffer and injecting packets.
|
|
|
|
type Connection struct {
|
|
|
|
layerStates []layerState
|
|
|
|
injector Injector
|
|
|
|
sniffer Sniffer
|
|
|
|
t *testing.T
|
|
|
|
}
|
|
|
|
|
2020-04-24 22:02:33 +00:00
|
|
|
// Returns the default incoming frame against which to match. If received is
|
|
|
|
// longer than layerStates then that may still count as a match. The reverse is
|
|
|
|
// never a match and nil is returned.
|
|
|
|
func (conn *Connection) incoming(received Layers) Layers {
|
|
|
|
if len(received) < len(conn.layerStates) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
in := Layers{}
|
|
|
|
for i, s := range conn.layerStates {
|
|
|
|
toMatch := s.incoming(received[i])
|
|
|
|
if toMatch == nil {
|
|
|
|
return nil
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-24 22:02:33 +00:00
|
|
|
in = append(in, toMatch)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
2020-04-24 22:02:33 +00:00
|
|
|
return in
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *Connection) match(override, received Layers) bool {
|
|
|
|
toMatch := conn.incoming(received)
|
|
|
|
if toMatch == nil {
|
|
|
|
return false // Not enough layers in gotLayers for matching.
|
|
|
|
}
|
|
|
|
if err := toMatch.merge(override); err != nil {
|
|
|
|
return false // Failing to merge is not matching.
|
|
|
|
}
|
|
|
|
return toMatch.match(received)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Close frees associated resources held by the Connection.
|
|
|
|
func (conn *Connection) Close() {
|
2020-04-16 22:14:44 +00:00
|
|
|
errs := multierr.Combine(conn.sniffer.close(), conn.injector.close())
|
2020-04-15 19:59:58 +00:00
|
|
|
for _, s := range conn.layerStates {
|
|
|
|
if err := s.close(); err != nil {
|
2020-04-16 22:14:44 +00:00
|
|
|
errs = multierr.Append(errs, fmt.Errorf("unable to close %+v: %s", s, err))
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
}
|
2020-04-16 22:14:44 +00:00
|
|
|
if errs != nil {
|
|
|
|
conn.t.Fatalf("unable to close %+v: %s", conn, errs)
|
|
|
|
}
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// CreateFrame builds a frame for the connection with defaults overriden
|
|
|
|
// from the innermost layer out, and additionalLayers added after it.
|
|
|
|
//
|
|
|
|
// Note that overrideLayers can have a length that is less than the number
|
|
|
|
// of layers in this connection, and in such cases the innermost layers are
|
|
|
|
// overriden first. As an example, valid values of overrideLayers for a TCP-
|
|
|
|
// over-IPv4-over-Ethernet connection are: nil, [TCP], [IPv4, TCP], and
|
|
|
|
// [Ethernet, IPv4, TCP].
|
|
|
|
func (conn *Connection) CreateFrame(overrideLayers Layers, additionalLayers ...Layer) Layers {
|
2020-04-15 19:59:58 +00:00
|
|
|
var layersToSend Layers
|
2020-06-11 20:46:56 +00:00
|
|
|
for i, s := range conn.layerStates {
|
|
|
|
layer := s.outgoing()
|
|
|
|
// overrideLayers and conn.layerStates have their tails aligned, so
|
|
|
|
// to find the index we move backwards by the distance i is to the
|
|
|
|
// end.
|
|
|
|
if j := len(overrideLayers) - (len(conn.layerStates) - i); j >= 0 {
|
|
|
|
if err := layer.merge(overrideLayers[j]); err != nil {
|
|
|
|
conn.t.Fatalf("can't merge %+v into %+v: %s", layer, overrideLayers[j], err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
layersToSend = append(layersToSend, layer)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
layersToSend = append(layersToSend, additionalLayers...)
|
|
|
|
return layersToSend
|
2020-04-14 06:04:01 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// SendFrameStateless sends a frame without updating any of the layer states.
|
|
|
|
//
|
|
|
|
// This method is useful for sending out-of-band control messages such as
|
|
|
|
// ICMP packets, where it would not make sense to update the transport layer's
|
|
|
|
// state using the ICMP header.
|
|
|
|
func (conn *Connection) SendFrameStateless(frame Layers) {
|
|
|
|
outBytes, err := frame.ToBytes()
|
|
|
|
if err != nil {
|
|
|
|
conn.t.Fatalf("can't build outgoing packet: %s", err)
|
|
|
|
}
|
|
|
|
conn.injector.Send(outBytes)
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// SendFrame sends a frame on the wire and updates the state of all layers.
|
|
|
|
func (conn *Connection) SendFrame(frame Layers) {
|
2020-04-24 22:55:11 +00:00
|
|
|
outBytes, err := frame.ToBytes()
|
2020-04-15 19:59:58 +00:00
|
|
|
if err != nil {
|
2020-04-29 01:49:19 +00:00
|
|
|
conn.t.Fatalf("can't build outgoing packet: %s", err)
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
conn.injector.Send(outBytes)
|
|
|
|
|
|
|
|
// frame might have nil values where the caller wanted to use default values.
|
|
|
|
// sentFrame will have no nil values in it because it comes from parsing the
|
|
|
|
// bytes that were actually sent.
|
|
|
|
sentFrame := parse(parseEther, outBytes)
|
|
|
|
// Update the state of each layer based on what was sent.
|
|
|
|
for i, s := range conn.layerStates {
|
|
|
|
if err := s.sent(sentFrame[i]); err != nil {
|
|
|
|
conn.t.Fatalf("Unable to update the state of %+v with %s: %s", s, sentFrame[i], err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// send sends a packet, possibly with layers of this connection overridden and
|
|
|
|
// additional layers added.
|
|
|
|
//
|
|
|
|
// Types defined with Connection as the underlying type should expose
|
|
|
|
// type-safe versions of this method.
|
|
|
|
func (conn *Connection) send(overrideLayers Layers, additionalLayers ...Layer) {
|
|
|
|
conn.SendFrame(conn.CreateFrame(overrideLayers, additionalLayers...))
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// recvFrame gets the next successfully parsed frame (of type Layers) within the
|
|
|
|
// timeout provided. If no parsable frame arrives before the timeout, it returns
|
|
|
|
// nil.
|
|
|
|
func (conn *Connection) recvFrame(timeout time.Duration) Layers {
|
|
|
|
if timeout <= 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
b := conn.sniffer.Recv(timeout)
|
|
|
|
if b == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return parse(parseEther, b)
|
|
|
|
}
|
|
|
|
|
2020-04-24 22:02:33 +00:00
|
|
|
// layersError stores the Layers that we got and the Layers that we wanted to
|
|
|
|
// match.
|
|
|
|
type layersError struct {
|
|
|
|
got, want Layers
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *layersError) Error() string {
|
|
|
|
return e.got.diff(e.want)
|
|
|
|
}
|
|
|
|
|
2020-04-29 01:49:19 +00:00
|
|
|
// Expect expects a frame with the final layerStates layer matching the
|
|
|
|
// provided Layer within the timeout specified. If it doesn't arrive in time,
|
|
|
|
// an error is returned.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (conn *Connection) Expect(layer Layer, timeout time.Duration) (Layer, error) {
|
|
|
|
// Make a frame that will ignore all but the final layer.
|
|
|
|
layers := make([]Layer, len(conn.layerStates))
|
|
|
|
layers[len(layers)-1] = layer
|
|
|
|
|
|
|
|
gotFrame, err := conn.ExpectFrame(layers, timeout)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if len(conn.layerStates)-1 < len(gotFrame) {
|
|
|
|
return gotFrame[len(conn.layerStates)-1], nil
|
|
|
|
}
|
|
|
|
conn.t.Fatal("the received frame should be at least as long as the expected layers")
|
2020-04-24 22:02:33 +00:00
|
|
|
panic("unreachable")
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ExpectFrame expects a frame that matches the provided Layers within the
|
2020-04-24 22:02:33 +00:00
|
|
|
// timeout specified. If one arrives in time, the Layers is returned without an
|
|
|
|
// error. If it doesn't arrive in time, it returns nil and error is non-nil.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (conn *Connection) ExpectFrame(layers Layers, timeout time.Duration) (Layers, error) {
|
2020-04-08 00:48:06 +00:00
|
|
|
deadline := time.Now().Add(timeout)
|
2020-04-24 22:02:33 +00:00
|
|
|
var errs error
|
2020-04-08 00:48:06 +00:00
|
|
|
for {
|
2020-04-15 19:59:58 +00:00
|
|
|
var gotLayers Layers
|
|
|
|
if timeout = time.Until(deadline); timeout > 0 {
|
|
|
|
gotLayers = conn.recvFrame(timeout)
|
|
|
|
}
|
|
|
|
if gotLayers == nil {
|
2020-04-24 22:02:33 +00:00
|
|
|
if errs == nil {
|
|
|
|
return nil, fmt.Errorf("got no frames matching %v during %s", layers, timeout)
|
|
|
|
}
|
|
|
|
return nil, fmt.Errorf("got no frames matching %v during %s: got %w", layers, timeout, errs)
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
if conn.match(layers, gotLayers) {
|
|
|
|
for i, s := range conn.layerStates {
|
|
|
|
if err := s.received(gotLayers[i]); err != nil {
|
|
|
|
conn.t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return gotLayers, nil
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
2020-04-24 22:02:33 +00:00
|
|
|
errs = multierr.Combine(errs, &layersError{got: gotLayers, want: conn.incoming(gotLayers)})
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// Drain drains the sniffer's receive buffer by receiving packets until there's
|
|
|
|
// nothing else to receive.
|
|
|
|
func (conn *Connection) Drain() {
|
|
|
|
conn.sniffer.Drain()
|
|
|
|
}
|
|
|
|
|
|
|
|
// TCPIPv4 maintains the state for all the layers in a TCP/IPv4 connection.
|
|
|
|
type TCPIPv4 Connection
|
|
|
|
|
|
|
|
// NewTCPIPv4 creates a new TCPIPv4 connection with reasonable defaults.
|
|
|
|
func NewTCPIPv4(t *testing.T, outgoingTCP, incomingTCP TCP) TCPIPv4 {
|
|
|
|
etherState, err := newEtherState(Ether{}, Ether{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make etherState: %s", err)
|
|
|
|
}
|
|
|
|
ipv4State, err := newIPv4State(IPv4{}, IPv4{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make ipv4State: %s", err)
|
|
|
|
}
|
2020-06-11 20:46:56 +00:00
|
|
|
tcpState, err := newTCPState(unix.AF_INET, outgoingTCP, incomingTCP)
|
2020-04-15 19:59:58 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make tcpState: %s", err)
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
injector, err := NewInjector(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make injector: %s", err)
|
|
|
|
}
|
|
|
|
sniffer, err := NewSniffer(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make sniffer: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return TCPIPv4{
|
|
|
|
layerStates: []layerState{etherState, ipv4State, tcpState},
|
|
|
|
injector: injector,
|
|
|
|
sniffer: sniffer,
|
|
|
|
t: t,
|
2020-04-08 00:48:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-04 21:22:46 +00:00
|
|
|
// Connect performs a TCP 3-way handshake. The input Connection should have a
|
2020-04-15 19:59:58 +00:00
|
|
|
// final TCP Layer.
|
2020-06-04 21:22:46 +00:00
|
|
|
func (conn *TCPIPv4) Connect() {
|
|
|
|
conn.t.Helper()
|
|
|
|
|
2020-03-17 15:52:14 +00:00
|
|
|
// Send the SYN.
|
|
|
|
conn.Send(TCP{Flags: Uint8(header.TCPFlagSyn)})
|
|
|
|
|
|
|
|
// Wait for the SYN-ACK.
|
2020-04-08 13:41:52 +00:00
|
|
|
synAck, err := conn.Expect(TCP{Flags: Uint8(header.TCPFlagSyn | header.TCPFlagAck)}, time.Second)
|
2020-06-04 21:22:46 +00:00
|
|
|
if err != nil {
|
|
|
|
conn.t.Fatalf("didn't get synack during handshake: %s", err)
|
|
|
|
}
|
|
|
|
conn.layerStates[len(conn.layerStates)-1].(*tcpState).synAck = synAck
|
|
|
|
|
|
|
|
// Send an ACK.
|
|
|
|
conn.Send(TCP{Flags: Uint8(header.TCPFlagAck)})
|
|
|
|
}
|
|
|
|
|
|
|
|
// ConnectWithOptions performs a TCP 3-way handshake with given TCP options.
|
|
|
|
// The input Connection should have a final TCP Layer.
|
|
|
|
func (conn *TCPIPv4) ConnectWithOptions(options []byte) {
|
|
|
|
conn.t.Helper()
|
|
|
|
|
|
|
|
// Send the SYN.
|
|
|
|
conn.Send(TCP{Flags: Uint8(header.TCPFlagSyn), Options: options})
|
|
|
|
|
|
|
|
// Wait for the SYN-ACK.
|
|
|
|
synAck, err := conn.Expect(TCP{Flags: Uint8(header.TCPFlagSyn | header.TCPFlagAck)}, time.Second)
|
|
|
|
if err != nil {
|
2020-04-08 13:41:52 +00:00
|
|
|
conn.t.Fatalf("didn't get synack during handshake: %s", err)
|
2020-03-17 15:52:14 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
conn.layerStates[len(conn.layerStates)-1].(*tcpState).synAck = synAck
|
2020-03-17 15:52:14 +00:00
|
|
|
|
|
|
|
// Send an ACK.
|
|
|
|
conn.Send(TCP{Flags: Uint8(header.TCPFlagAck)})
|
|
|
|
}
|
2020-04-01 02:51:52 +00:00
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// ExpectData is a convenient method that expects a Layer and the Layer after
|
|
|
|
// it. If it doens't arrive in time, it returns nil.
|
|
|
|
func (conn *TCPIPv4) ExpectData(tcp *TCP, payload *Payload, timeout time.Duration) (Layers, error) {
|
|
|
|
expected := make([]Layer, len(conn.layerStates))
|
|
|
|
expected[len(expected)-1] = tcp
|
|
|
|
if payload != nil {
|
|
|
|
expected = append(expected, payload)
|
|
|
|
}
|
|
|
|
return (*Connection)(conn).ExpectFrame(expected, timeout)
|
|
|
|
}
|
|
|
|
|
2020-06-04 21:22:46 +00:00
|
|
|
// ExpectNextData attempts to receive the next incoming segment for the
|
|
|
|
// connection and expects that to match the given layers.
|
|
|
|
//
|
|
|
|
// It differs from ExpectData() in that here we are only interested in the next
|
|
|
|
// received segment, while ExpectData() can receive multiple segments for the
|
|
|
|
// connection until there is a match with given layers or a timeout.
|
|
|
|
func (conn *TCPIPv4) ExpectNextData(tcp *TCP, payload *Payload, timeout time.Duration) (Layers, error) {
|
|
|
|
// Receive the first incoming TCP segment for this connection.
|
|
|
|
got, err := conn.ExpectData(&TCP{}, nil, timeout)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
expected := make([]Layer, len(conn.layerStates))
|
|
|
|
expected[len(expected)-1] = tcp
|
|
|
|
if payload != nil {
|
|
|
|
expected = append(expected, payload)
|
|
|
|
tcp.SeqNum = Uint32(uint32(*conn.RemoteSeqNum()) - uint32(payload.Length()))
|
|
|
|
}
|
|
|
|
if !(*Connection)(conn).match(expected, got) {
|
|
|
|
return nil, fmt.Errorf("next frame is not matching %s during %s: got %s", expected, timeout, got)
|
|
|
|
}
|
|
|
|
return got, nil
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// Send a packet with reasonable defaults. Potentially override the TCP layer in
|
|
|
|
// the connection with the provided layer and add additionLayers.
|
|
|
|
func (conn *TCPIPv4) Send(tcp TCP, additionalLayers ...Layer) {
|
2020-06-11 20:46:56 +00:00
|
|
|
(*Connection)(conn).send(Layers{&tcp}, additionalLayers...)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// Close frees associated resources held by the TCPIPv4 connection.
|
|
|
|
func (conn *TCPIPv4) Close() {
|
|
|
|
(*Connection)(conn).Close()
|
|
|
|
}
|
|
|
|
|
2020-04-29 01:49:19 +00:00
|
|
|
// Expect expects a frame with the TCP layer matching the provided TCP within
|
|
|
|
// the timeout specified. If it doesn't arrive in time, an error is returned.
|
2020-04-15 19:59:58 +00:00
|
|
|
func (conn *TCPIPv4) Expect(tcp TCP, timeout time.Duration) (*TCP, error) {
|
|
|
|
layer, err := (*Connection)(conn).Expect(&tcp, timeout)
|
|
|
|
if layer == nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
gotTCP, ok := layer.(*TCP)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("expected %s to be TCP", layer)
|
|
|
|
}
|
|
|
|
return gotTCP, err
|
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
func (conn *TCPIPv4) tcpState() *tcpState {
|
|
|
|
state, ok := conn.layerStates[2].(*tcpState)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("got transport-layer state type=%T, expected tcpState", conn.layerStates[2])
|
|
|
|
}
|
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *TCPIPv4) ipv4State() *ipv4State {
|
|
|
|
state, ok := conn.layerStates[1].(*ipv4State)
|
2020-04-15 19:59:58 +00:00
|
|
|
if !ok {
|
2020-06-11 20:46:56 +00:00
|
|
|
conn.t.Fatalf("expected network-layer state type=%T, expected ipv4State", conn.layerStates[1])
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
2020-04-16 02:36:03 +00:00
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
|
|
|
// RemoteSeqNum returns the next expected sequence number from the DUT.
|
|
|
|
func (conn *TCPIPv4) RemoteSeqNum() *seqnum.Value {
|
2020-06-11 20:46:56 +00:00
|
|
|
return conn.tcpState().remoteSeqNum
|
2020-04-16 02:36:03 +00:00
|
|
|
}
|
|
|
|
|
2020-04-16 19:21:06 +00:00
|
|
|
// LocalSeqNum returns the next sequence number to send from the testbench.
|
2020-04-16 02:36:03 +00:00
|
|
|
func (conn *TCPIPv4) LocalSeqNum() *seqnum.Value {
|
2020-06-11 20:46:56 +00:00
|
|
|
return conn.tcpState().localSeqNum
|
2020-04-16 02:36:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// SynAck returns the SynAck that was part of the handshake.
|
|
|
|
func (conn *TCPIPv4) SynAck() *TCP {
|
2020-06-11 20:46:56 +00:00
|
|
|
return conn.tcpState().synAck
|
2020-04-15 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
2020-05-30 00:22:56 +00:00
|
|
|
// LocalAddr gets the local socket address of this connection.
|
2020-06-11 20:46:56 +00:00
|
|
|
func (conn *TCPIPv4) LocalAddr() *unix.SockaddrInet4 {
|
|
|
|
sa := &unix.SockaddrInet4{Port: int(*conn.tcpState().out.SrcPort)}
|
|
|
|
copy(sa.Addr[:], *conn.ipv4State().out.SrcAddr)
|
|
|
|
return sa
|
|
|
|
}
|
|
|
|
|
|
|
|
// Drain drains the sniffer's receive buffer by receiving packets until there's
|
|
|
|
// nothing else to receive.
|
|
|
|
func (conn *TCPIPv4) Drain() {
|
|
|
|
conn.sniffer.Drain()
|
2020-05-30 00:22:56 +00:00
|
|
|
}
|
|
|
|
|
2020-04-24 22:55:11 +00:00
|
|
|
// IPv6Conn maintains the state for all the layers in a IPv6 connection.
|
|
|
|
type IPv6Conn Connection
|
|
|
|
|
|
|
|
// NewIPv6Conn creates a new IPv6Conn connection with reasonable defaults.
|
|
|
|
func NewIPv6Conn(t *testing.T, outgoingIPv6, incomingIPv6 IPv6) IPv6Conn {
|
|
|
|
etherState, err := newEtherState(Ether{}, Ether{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make EtherState: %s", err)
|
|
|
|
}
|
|
|
|
ipv6State, err := newIPv6State(outgoingIPv6, incomingIPv6)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make IPv6State: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
injector, err := NewInjector(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make injector: %s", err)
|
|
|
|
}
|
|
|
|
sniffer, err := NewSniffer(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make sniffer: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return IPv6Conn{
|
|
|
|
layerStates: []layerState{etherState, ipv6State},
|
|
|
|
injector: injector,
|
|
|
|
sniffer: sniffer,
|
|
|
|
t: t,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// Send sends a frame with ipv6 overriding the IPv6 layer defaults and
|
|
|
|
// additionalLayers added after it.
|
|
|
|
func (conn *IPv6Conn) Send(ipv6 IPv6, additionalLayers ...Layer) {
|
|
|
|
(*Connection)(conn).send(Layers{&ipv6}, additionalLayers...)
|
2020-04-24 22:55:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Close to clean up any resources held.
|
|
|
|
func (conn *IPv6Conn) Close() {
|
|
|
|
(*Connection)(conn).Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExpectFrame expects a frame that matches the provided Layers within the
|
2020-04-29 01:49:19 +00:00
|
|
|
// timeout specified. If it doesn't arrive in time, an error is returned.
|
2020-04-24 22:55:11 +00:00
|
|
|
func (conn *IPv6Conn) ExpectFrame(frame Layers, timeout time.Duration) (Layers, error) {
|
|
|
|
return (*Connection)(conn).ExpectFrame(frame, timeout)
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// UDPIPv4 maintains the state for all the layers in a UDP/IPv4 connection.
|
|
|
|
type UDPIPv4 Connection
|
2020-04-01 02:51:52 +00:00
|
|
|
|
|
|
|
// NewUDPIPv4 creates a new UDPIPv4 connection with reasonable defaults.
|
|
|
|
func NewUDPIPv4(t *testing.T, outgoingUDP, incomingUDP UDP) UDPIPv4 {
|
2020-04-15 19:59:58 +00:00
|
|
|
etherState, err := newEtherState(Ether{}, Ether{})
|
2020-04-01 02:51:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 19:59:58 +00:00
|
|
|
t.Fatalf("can't make etherState: %s", err)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
ipv4State, err := newIPv4State(IPv4{}, IPv4{})
|
2020-04-01 02:51:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 19:59:58 +00:00
|
|
|
t.Fatalf("can't make ipv4State: %s", err)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
2020-06-11 20:46:56 +00:00
|
|
|
udpState, err := newUDPState(unix.AF_INET, outgoingUDP, incomingUDP)
|
2020-04-01 02:51:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 19:59:58 +00:00
|
|
|
t.Fatalf("can't make udpState: %s", err)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
injector, err := NewInjector(t)
|
2020-04-01 02:51:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 19:59:58 +00:00
|
|
|
t.Fatalf("can't make injector: %s", err)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
2020-04-15 19:59:58 +00:00
|
|
|
sniffer, err := NewSniffer(t)
|
2020-04-01 02:51:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 19:59:58 +00:00
|
|
|
t.Fatalf("can't make sniffer: %s", err)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return UDPIPv4{
|
2020-04-29 01:49:19 +00:00
|
|
|
layerStates: []layerState{etherState, ipv4State, udpState},
|
2020-04-15 19:59:58 +00:00
|
|
|
injector: injector,
|
|
|
|
sniffer: sniffer,
|
|
|
|
t: t,
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
func (conn *UDPIPv4) udpState() *udpState {
|
|
|
|
state, ok := conn.layerStates[2].(*udpState)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("got transport-layer state type=%T, expected udpState", conn.layerStates[2])
|
|
|
|
}
|
|
|
|
return state
|
2020-04-29 01:49:19 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
func (conn *UDPIPv4) ipv4State() *ipv4State {
|
|
|
|
state, ok := conn.layerStates[1].(*ipv4State)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("got network-layer state type=%T, expected ipv4State", conn.layerStates[1])
|
|
|
|
}
|
|
|
|
return state
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// LocalAddr gets the local socket address of this connection.
|
|
|
|
func (conn *UDPIPv4) LocalAddr() *unix.SockaddrInet4 {
|
|
|
|
sa := &unix.SockaddrInet4{Port: int(*conn.udpState().out.SrcPort)}
|
|
|
|
copy(sa.Addr[:], *conn.ipv4State().out.SrcAddr)
|
|
|
|
return sa
|
2020-04-29 01:49:19 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// Send sends a packet with reasonable defaults, potentially overriding the UDP
|
|
|
|
// layer and adding additionLayers.
|
|
|
|
func (conn *UDPIPv4) Send(udp UDP, additionalLayers ...Layer) {
|
|
|
|
(*Connection)(conn).send(Layers{&udp}, additionalLayers...)
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-06-11 20:46:56 +00:00
|
|
|
// SendIP sends a packet with reasonable defaults, potentially overriding the
|
|
|
|
// UDP and IPv4 headers and adding additionLayers.
|
|
|
|
func (conn *UDPIPv4) SendIP(ip IPv4, udp UDP, additionalLayers ...Layer) {
|
|
|
|
(*Connection)(conn).send(Layers{&ip, &udp}, additionalLayers...)
|
2020-04-29 01:49:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Expect expects a frame with the UDP layer matching the provided UDP within
|
|
|
|
// the timeout specified. If it doesn't arrive in time, an error is returned.
|
|
|
|
func (conn *UDPIPv4) Expect(udp UDP, timeout time.Duration) (*UDP, error) {
|
2020-05-08 22:38:42 +00:00
|
|
|
conn.t.Helper()
|
2020-04-29 01:49:19 +00:00
|
|
|
layer, err := (*Connection)(conn).Expect(&udp, timeout)
|
2020-07-14 18:48:26 +00:00
|
|
|
if err != nil {
|
2020-04-29 01:49:19 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
gotUDP, ok := layer.(*UDP)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("expected %s to be UDP", layer)
|
|
|
|
}
|
2020-07-14 18:48:26 +00:00
|
|
|
return gotUDP, nil
|
2020-04-29 01:49:19 +00:00
|
|
|
}
|
|
|
|
|
2020-05-08 22:38:42 +00:00
|
|
|
// ExpectData is a convenient method that expects a Layer and the Layer after
|
|
|
|
// it. If it doens't arrive in time, it returns nil.
|
|
|
|
func (conn *UDPIPv4) ExpectData(udp UDP, payload Payload, timeout time.Duration) (Layers, error) {
|
|
|
|
conn.t.Helper()
|
|
|
|
expected := make([]Layer, len(conn.layerStates))
|
|
|
|
expected[len(expected)-1] = &udp
|
|
|
|
if payload.length() != 0 {
|
|
|
|
expected = append(expected, &payload)
|
|
|
|
}
|
|
|
|
return (*Connection)(conn).ExpectFrame(expected, timeout)
|
|
|
|
}
|
|
|
|
|
2020-04-15 19:59:58 +00:00
|
|
|
// Close frees associated resources held by the UDPIPv4 connection.
|
|
|
|
func (conn *UDPIPv4) Close() {
|
|
|
|
(*Connection)(conn).Close()
|
2020-04-01 02:51:52 +00:00
|
|
|
}
|
|
|
|
|
2020-04-14 06:04:01 +00:00
|
|
|
// Drain drains the sniffer's receive buffer by receiving packets until there's
|
|
|
|
// nothing else to receive.
|
|
|
|
func (conn *UDPIPv4) Drain() {
|
|
|
|
conn.sniffer.Drain()
|
|
|
|
}
|
2020-07-14 18:48:26 +00:00
|
|
|
|
|
|
|
// UDPIPv6 maintains the state for all the layers in a UDP/IPv6 connection.
|
|
|
|
type UDPIPv6 Connection
|
|
|
|
|
|
|
|
// NewUDPIPv6 creates a new UDPIPv6 connection with reasonable defaults.
|
|
|
|
func NewUDPIPv6(t *testing.T, outgoingUDP, incomingUDP UDP) UDPIPv6 {
|
|
|
|
etherState, err := newEtherState(Ether{}, Ether{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make etherState: %s", err)
|
|
|
|
}
|
|
|
|
ipv6State, err := newIPv6State(IPv6{}, IPv6{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make IPv6State: %s", err)
|
|
|
|
}
|
|
|
|
udpState, err := newUDPState(unix.AF_INET6, outgoingUDP, incomingUDP)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make udpState: %s", err)
|
|
|
|
}
|
|
|
|
injector, err := NewInjector(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make injector: %s", err)
|
|
|
|
}
|
|
|
|
sniffer, err := NewSniffer(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make sniffer: %s", err)
|
|
|
|
}
|
|
|
|
return UDPIPv6{
|
|
|
|
layerStates: []layerState{etherState, ipv6State, udpState},
|
|
|
|
injector: injector,
|
|
|
|
sniffer: sniffer,
|
|
|
|
t: t,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *UDPIPv6) udpState() *udpState {
|
|
|
|
state, ok := conn.layerStates[2].(*udpState)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("got transport-layer state type=%T, expected udpState", conn.layerStates[2])
|
|
|
|
}
|
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *UDPIPv6) ipv6State() *ipv6State {
|
|
|
|
state, ok := conn.layerStates[1].(*ipv6State)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("got network-layer state type=%T, expected ipv6State", conn.layerStates[1])
|
|
|
|
}
|
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
|
|
|
// LocalAddr gets the local socket address of this connection.
|
|
|
|
func (conn *UDPIPv6) LocalAddr() *unix.SockaddrInet6 {
|
|
|
|
sa := &unix.SockaddrInet6{
|
|
|
|
Port: int(*conn.udpState().out.SrcPort),
|
|
|
|
// Local address is in perspective to the remote host, so it's scoped to the
|
|
|
|
// ID of the remote interface.
|
|
|
|
ZoneId: uint32(RemoteInterfaceID),
|
|
|
|
}
|
|
|
|
copy(sa.Addr[:], *conn.ipv6State().out.SrcAddr)
|
|
|
|
return sa
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send sends a packet with reasonable defaults, potentially overriding the UDP
|
|
|
|
// layer and adding additionLayers.
|
|
|
|
func (conn *UDPIPv6) Send(udp UDP, additionalLayers ...Layer) {
|
|
|
|
(*Connection)(conn).send(Layers{&udp}, additionalLayers...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendIPv6 sends a packet with reasonable defaults, potentially overriding the
|
|
|
|
// UDP and IPv6 headers and adding additionLayers.
|
|
|
|
func (conn *UDPIPv6) SendIPv6(ip IPv6, udp UDP, additionalLayers ...Layer) {
|
|
|
|
(*Connection)(conn).send(Layers{&ip, &udp}, additionalLayers...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Expect expects a frame with the UDP layer matching the provided UDP within
|
|
|
|
// the timeout specified. If it doesn't arrive in time, an error is returned.
|
|
|
|
func (conn *UDPIPv6) Expect(udp UDP, timeout time.Duration) (*UDP, error) {
|
|
|
|
conn.t.Helper()
|
|
|
|
layer, err := (*Connection)(conn).Expect(&udp, timeout)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
gotUDP, ok := layer.(*UDP)
|
|
|
|
if !ok {
|
|
|
|
conn.t.Fatalf("expected %s to be UDP", layer)
|
|
|
|
}
|
|
|
|
return gotUDP, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExpectData is a convenient method that expects a Layer and the Layer after
|
|
|
|
// it. If it doens't arrive in time, it returns nil.
|
|
|
|
func (conn *UDPIPv6) ExpectData(udp UDP, payload Payload, timeout time.Duration) (Layers, error) {
|
|
|
|
conn.t.Helper()
|
|
|
|
expected := make([]Layer, len(conn.layerStates))
|
|
|
|
expected[len(expected)-1] = &udp
|
|
|
|
if payload.length() != 0 {
|
|
|
|
expected = append(expected, &payload)
|
|
|
|
}
|
|
|
|
return (*Connection)(conn).ExpectFrame(expected, timeout)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close frees associated resources held by the UDPIPv6 connection.
|
|
|
|
func (conn *UDPIPv6) Close() {
|
|
|
|
(*Connection)(conn).Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Drain drains the sniffer's receive buffer by receiving packets until there's
|
|
|
|
// nothing else to receive.
|
|
|
|
func (conn *UDPIPv6) Drain() {
|
|
|
|
conn.sniffer.Drain()
|
|
|
|
}
|
2020-07-10 05:37:11 +00:00
|
|
|
|
|
|
|
// TCPIPv6 maintains the state for all the layers in a TCP/IPv6 connection.
|
|
|
|
type TCPIPv6 Connection
|
|
|
|
|
|
|
|
// NewTCPIPv6 creates a new TCPIPv6 connection with reasonable defaults.
|
|
|
|
func NewTCPIPv6(t *testing.T, outgoingTCP, incomingTCP TCP) TCPIPv6 {
|
|
|
|
etherState, err := newEtherState(Ether{}, Ether{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make etherState: %s", err)
|
|
|
|
}
|
|
|
|
ipv6State, err := newIPv6State(IPv6{}, IPv6{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make ipv6State: %s", err)
|
|
|
|
}
|
|
|
|
tcpState, err := newTCPState(unix.AF_INET6, outgoingTCP, incomingTCP)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make tcpState: %s", err)
|
|
|
|
}
|
|
|
|
injector, err := NewInjector(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make injector: %s", err)
|
|
|
|
}
|
|
|
|
sniffer, err := NewSniffer(t)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("can't make sniffer: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return TCPIPv6{
|
|
|
|
layerStates: []layerState{etherState, ipv6State, tcpState},
|
|
|
|
injector: injector,
|
|
|
|
sniffer: sniffer,
|
|
|
|
t: t,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *TCPIPv6) SrcPort() uint16 {
|
|
|
|
state := conn.layerStates[2].(*tcpState)
|
|
|
|
return *state.out.SrcPort
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExpectData is a convenient method that expects a Layer and the Layer after
|
|
|
|
// it. If it doens't arrive in time, it returns nil.
|
|
|
|
func (conn *TCPIPv6) ExpectData(tcp *TCP, payload *Payload, timeout time.Duration) (Layers, error) {
|
|
|
|
expected := make([]Layer, len(conn.layerStates))
|
|
|
|
expected[len(expected)-1] = tcp
|
|
|
|
if payload != nil {
|
|
|
|
expected = append(expected, payload)
|
|
|
|
}
|
|
|
|
return (*Connection)(conn).ExpectFrame(expected, timeout)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close frees associated resources held by the TCPIPv6 connection.
|
|
|
|
func (conn *TCPIPv6) Close() {
|
|
|
|
(*Connection)(conn).Close()
|
|
|
|
}
|