visor/pkg/sentry/socket/rpcinet/stack.go

// Copyright 2018 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 rpcinet

import (
	"fmt"
	"syscall"

	"gvisor.dev/gvisor/pkg/sentry/inet"
	"gvisor.dev/gvisor/pkg/sentry/socket/hostinet"
	"gvisor.dev/gvisor/pkg/sentry/socket/rpcinet/conn"
	"gvisor.dev/gvisor/pkg/sentry/socket/rpcinet/notifier"
	"gvisor.dev/gvisor/pkg/syserr"
	"gvisor.dev/gvisor/pkg/unet"
)

// Stack implements inet.Stack for RPC backed sockets.
type Stack struct {
	interfaces     map[int32]inet.Interface
	interfaceAddrs map[int32][]inet.InterfaceAddr
	routes         []inet.Route
	rpcConn        *conn.RPCConnection
	notifier       *notifier.Notifier
}

// NewStack returns a Stack containing the current state of the host network
// stack.
func NewStack(fd int32) (*Stack, error) {
	sock, err := unet.NewSocket(int(fd))
	if err != nil {
		return nil, err
	}

	stack := &Stack{
		interfaces:     make(map[int32]inet.Interface),
		interfaceAddrs: make(map[int32][]inet.InterfaceAddr),
		rpcConn:        conn.NewRPCConnection(sock),
	}

	var e error
	stack.notifier, e = notifier.NewRPCNotifier(stack.rpcConn)
	if e != nil {
		return nil, e
	}

	links, err := stack.DoNetlinkRouteRequest(syscall.RTM_GETLINK)
	if err != nil {
		return nil, fmt.Errorf("RTM_GETLINK failed: %v", err)
	}

	addrs, err := stack.DoNetlinkRouteRequest(syscall.RTM_GETADDR)
	if err != nil {
		return nil, fmt.Errorf("RTM_GETADDR failed: %v", err)
	}

	e = hostinet.ExtractHostInterfaces(links, addrs, stack.interfaces, stack.interfaceAddrs)
	if e != nil {
		return nil, e
	}

	routes, err := stack.DoNetlinkRouteRequest(syscall.RTM_GETROUTE)
	if err != nil {
		return nil, fmt.Errorf("RTM_GETROUTE failed: %v", err)
	}

	stack.routes, e = hostinet.ExtractHostRoutes(routes)
	if e != nil {
		return nil, e
	}

	return stack, nil
}

// RPCReadFile will execute the ReadFile helper RPC method which avoids the
// common pattern of open(2), read(2), close(2) by doing all three operations
// as a single RPC. It will read the entire file or return EFBIG if the file
// was too large.
func (s *Stack) RPCReadFile(path string) ([]byte, *syserr.Error) {
	return s.rpcConn.RPCReadFile(path)
}

// RPCWriteFile will execute the WriteFile helper RPC method which avoids the
// common pattern of open(2), write(2), write(2), close(2) by doing all
// operations as a single RPC.
func (s *Stack) RPCWriteFile(path string, data []byte) (int64, *syserr.Error) {
	return s.rpcConn.RPCWriteFile(path, data)
}

// Interfaces implements inet.Stack.Interfaces.
func (s *Stack) Interfaces() map[int32]inet.Interface {
	interfaces := make(map[int32]inet.Interface)
	for k, v := range s.interfaces {
		interfaces[k] = v
	}
	return interfaces
}

// InterfaceAddrs implements inet.Stack.InterfaceAddrs.
func (s *Stack) InterfaceAddrs() map[int32][]inet.InterfaceAddr {
	addrs := make(map[int32][]inet.InterfaceAddr)
	for k, v := range s.interfaceAddrs {
		addrs[k] = append([]inet.InterfaceAddr(nil), v...)
	}
	return addrs
}

// SupportsIPv6 implements inet.Stack.SupportsIPv6.
func (s *Stack) SupportsIPv6() bool {
	panic("rpcinet handles procfs directly this method should not be called")
}

// TCPReceiveBufferSize implements inet.Stack.TCPReceiveBufferSize.
func (s *Stack) TCPReceiveBufferSize() (inet.TCPBufferSize, error) {
	panic("rpcinet handles procfs directly this method should not be called")
}

// SetTCPReceiveBufferSize implements inet.Stack.SetTCPReceiveBufferSize.
func (s *Stack) SetTCPReceiveBufferSize(size inet.TCPBufferSize) error {
	panic("rpcinet handles procfs directly this method should not be called")

}

// TCPSendBufferSize implements inet.Stack.TCPSendBufferSize.
func (s *Stack) TCPSendBufferSize() (inet.TCPBufferSize, error) {
	panic("rpcinet handles procfs directly this method should not be called")

}

// SetTCPSendBufferSize implements inet.Stack.SetTCPSendBufferSize.
func (s *Stack) SetTCPSendBufferSize(size inet.TCPBufferSize) error {
	panic("rpcinet handles procfs directly this method should not be called")
}

// TCPSACKEnabled implements inet.Stack.TCPSACKEnabled.
func (s *Stack) TCPSACKEnabled() (bool, error) {
	panic("rpcinet handles procfs directly this method should not be called")
}

// SetTCPSACKEnabled implements inet.Stack.SetTCPSACKEnabled.
func (s *Stack) SetTCPSACKEnabled(enabled bool) error {
	panic("rpcinet handles procfs directly this method should not be called")
}

// Statistics implements inet.Stack.Statistics.
func (s *Stack) Statistics(stat interface{}, arg string) error {
	return syserr.ErrEndpointOperation.ToError()
}

// RouteTable implements inet.Stack.RouteTable.
func (s *Stack) RouteTable() []inet.Route {
	return append([]inet.Route(nil), s.routes...)
}

// Resume implements inet.Stack.Resume.
func (s *Stack) Resume() {}