556 lines
14 KiB
Go
556 lines
14 KiB
Go
// Copyright 2021 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 tcpip
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// Error represents an error in the netstack error space.
|
|
//
|
|
// The error interface is intentionally omitted to avoid loss of type
|
|
// information that would occur if these errors were passed as error.
|
|
type Error interface {
|
|
isError()
|
|
|
|
// IgnoreStats indicates whether this error should be included in failure
|
|
// counts in tcpip.Stats structs.
|
|
IgnoreStats() bool
|
|
|
|
fmt.Stringer
|
|
}
|
|
|
|
// LINT.IfChange
|
|
|
|
// ErrAborted indicates the operation was aborted.
|
|
//
|
|
// +stateify savable
|
|
type ErrAborted struct{}
|
|
|
|
func (*ErrAborted) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrAborted) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrAborted) String() string {
|
|
return "operation aborted"
|
|
}
|
|
|
|
// ErrAddressFamilyNotSupported indicates the operation does not support the
|
|
// given address family.
|
|
//
|
|
// +stateify savable
|
|
type ErrAddressFamilyNotSupported struct{}
|
|
|
|
func (*ErrAddressFamilyNotSupported) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrAddressFamilyNotSupported) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrAddressFamilyNotSupported) String() string {
|
|
return "address family not supported by protocol"
|
|
}
|
|
|
|
// ErrAlreadyBound indicates the endpoint is already bound.
|
|
//
|
|
// +stateify savable
|
|
type ErrAlreadyBound struct{}
|
|
|
|
func (*ErrAlreadyBound) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrAlreadyBound) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrAlreadyBound) String() string { return "endpoint already bound" }
|
|
|
|
// ErrAlreadyConnected indicates the endpoint is already connected.
|
|
//
|
|
// +stateify savable
|
|
type ErrAlreadyConnected struct{}
|
|
|
|
func (*ErrAlreadyConnected) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrAlreadyConnected) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrAlreadyConnected) String() string { return "endpoint is already connected" }
|
|
|
|
// ErrAlreadyConnecting indicates the endpoint is already connecting.
|
|
//
|
|
// +stateify savable
|
|
type ErrAlreadyConnecting struct{}
|
|
|
|
func (*ErrAlreadyConnecting) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrAlreadyConnecting) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrAlreadyConnecting) String() string { return "endpoint is already connecting" }
|
|
|
|
// ErrBadAddress indicates a bad address was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrBadAddress struct{}
|
|
|
|
func (*ErrBadAddress) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrBadAddress) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrBadAddress) String() string { return "bad address" }
|
|
|
|
// ErrBadBuffer indicates a bad buffer was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrBadBuffer struct{}
|
|
|
|
func (*ErrBadBuffer) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrBadBuffer) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrBadBuffer) String() string { return "bad buffer" }
|
|
|
|
// ErrBadLocalAddress indicates a bad local address was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrBadLocalAddress struct{}
|
|
|
|
func (*ErrBadLocalAddress) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrBadLocalAddress) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrBadLocalAddress) String() string { return "bad local address" }
|
|
|
|
// ErrBroadcastDisabled indicates broadcast is not enabled on the endpoint.
|
|
//
|
|
// +stateify savable
|
|
type ErrBroadcastDisabled struct{}
|
|
|
|
func (*ErrBroadcastDisabled) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrBroadcastDisabled) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrBroadcastDisabled) String() string { return "broadcast socket option disabled" }
|
|
|
|
// ErrClosedForReceive indicates the endpoint is closed for incoming data.
|
|
//
|
|
// +stateify savable
|
|
type ErrClosedForReceive struct{}
|
|
|
|
func (*ErrClosedForReceive) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrClosedForReceive) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrClosedForReceive) String() string { return "endpoint is closed for receive" }
|
|
|
|
// ErrClosedForSend indicates the endpoint is closed for outgoing data.
|
|
//
|
|
// +stateify savable
|
|
type ErrClosedForSend struct{}
|
|
|
|
func (*ErrClosedForSend) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrClosedForSend) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrClosedForSend) String() string { return "endpoint is closed for send" }
|
|
|
|
// ErrConnectStarted indicates the endpoint is connecting asynchronously.
|
|
//
|
|
// +stateify savable
|
|
type ErrConnectStarted struct{}
|
|
|
|
func (*ErrConnectStarted) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrConnectStarted) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrConnectStarted) String() string { return "connection attempt started" }
|
|
|
|
// ErrConnectionAborted indicates the connection was aborted.
|
|
//
|
|
// +stateify savable
|
|
type ErrConnectionAborted struct{}
|
|
|
|
func (*ErrConnectionAborted) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrConnectionAborted) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrConnectionAborted) String() string { return "connection aborted" }
|
|
|
|
// ErrConnectionRefused indicates the connection was refused.
|
|
//
|
|
// +stateify savable
|
|
type ErrConnectionRefused struct{}
|
|
|
|
func (*ErrConnectionRefused) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrConnectionRefused) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrConnectionRefused) String() string { return "connection was refused" }
|
|
|
|
// ErrConnectionReset indicates the connection was reset.
|
|
//
|
|
// +stateify savable
|
|
type ErrConnectionReset struct{}
|
|
|
|
func (*ErrConnectionReset) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrConnectionReset) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrConnectionReset) String() string { return "connection reset by peer" }
|
|
|
|
// ErrDestinationRequired indicates the operation requires a destination
|
|
// address, and one was not provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrDestinationRequired struct{}
|
|
|
|
func (*ErrDestinationRequired) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrDestinationRequired) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrDestinationRequired) String() string { return "destination address is required" }
|
|
|
|
// ErrDuplicateAddress indicates the operation encountered a duplicate address.
|
|
//
|
|
// +stateify savable
|
|
type ErrDuplicateAddress struct{}
|
|
|
|
func (*ErrDuplicateAddress) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrDuplicateAddress) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrDuplicateAddress) String() string { return "duplicate address" }
|
|
|
|
// ErrDuplicateNICID indicates the operation encountered a duplicate NIC ID.
|
|
//
|
|
// +stateify savable
|
|
type ErrDuplicateNICID struct{}
|
|
|
|
func (*ErrDuplicateNICID) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrDuplicateNICID) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrDuplicateNICID) String() string { return "duplicate nic id" }
|
|
|
|
// ErrInvalidEndpointState indicates the endpoint is in an invalid state.
|
|
//
|
|
// +stateify savable
|
|
type ErrInvalidEndpointState struct{}
|
|
|
|
func (*ErrInvalidEndpointState) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrInvalidEndpointState) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrInvalidEndpointState) String() string { return "endpoint is in invalid state" }
|
|
|
|
// ErrInvalidOptionValue indicates an invalid option value was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrInvalidOptionValue struct{}
|
|
|
|
func (*ErrInvalidOptionValue) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrInvalidOptionValue) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrInvalidOptionValue) String() string { return "invalid option value specified" }
|
|
|
|
// ErrInvalidPortRange indicates an attempt to set an invalid port range.
|
|
//
|
|
// +stateify savable
|
|
type ErrInvalidPortRange struct{}
|
|
|
|
func (*ErrInvalidPortRange) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrInvalidPortRange) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrInvalidPortRange) String() string { return "invalid port range" }
|
|
|
|
// ErrMalformedHeader indicates the operation encountered a malformed header.
|
|
//
|
|
// +stateify savable
|
|
type ErrMalformedHeader struct{}
|
|
|
|
func (*ErrMalformedHeader) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrMalformedHeader) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrMalformedHeader) String() string { return "header is malformed" }
|
|
|
|
// ErrMessageTooLong indicates the operation encountered a message whose length
|
|
// exceeds the maximum permitted.
|
|
//
|
|
// +stateify savable
|
|
type ErrMessageTooLong struct{}
|
|
|
|
func (*ErrMessageTooLong) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrMessageTooLong) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrMessageTooLong) String() string { return "message too long" }
|
|
|
|
// ErrNetworkUnreachable indicates the operation is not able to reach the
|
|
// destination network.
|
|
//
|
|
// +stateify savable
|
|
type ErrNetworkUnreachable struct{}
|
|
|
|
func (*ErrNetworkUnreachable) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNetworkUnreachable) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNetworkUnreachable) String() string { return "network is unreachable" }
|
|
|
|
// ErrNoBufferSpace indicates no buffer space is available.
|
|
//
|
|
// +stateify savable
|
|
type ErrNoBufferSpace struct{}
|
|
|
|
func (*ErrNoBufferSpace) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNoBufferSpace) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNoBufferSpace) String() string { return "no buffer space available" }
|
|
|
|
// ErrNoPortAvailable indicates no port could be allocated for the operation.
|
|
//
|
|
// +stateify savable
|
|
type ErrNoPortAvailable struct{}
|
|
|
|
func (*ErrNoPortAvailable) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNoPortAvailable) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNoPortAvailable) String() string { return "no ports are available" }
|
|
|
|
// ErrNoRoute indicates the operation is not able to find a route to the
|
|
// destination.
|
|
//
|
|
// +stateify savable
|
|
type ErrNoRoute struct{}
|
|
|
|
func (*ErrNoRoute) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNoRoute) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNoRoute) String() string { return "no route" }
|
|
|
|
// ErrNoSuchFile is used to indicate that ENOENT should be returned the to
|
|
// calling application.
|
|
//
|
|
// +stateify savable
|
|
type ErrNoSuchFile struct{}
|
|
|
|
func (*ErrNoSuchFile) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNoSuchFile) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNoSuchFile) String() string { return "no such file" }
|
|
|
|
// ErrNotConnected indicates the endpoint is not connected.
|
|
//
|
|
// +stateify savable
|
|
type ErrNotConnected struct{}
|
|
|
|
func (*ErrNotConnected) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNotConnected) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNotConnected) String() string { return "endpoint not connected" }
|
|
|
|
// ErrNotPermitted indicates the operation is not permitted.
|
|
//
|
|
// +stateify savable
|
|
type ErrNotPermitted struct{}
|
|
|
|
func (*ErrNotPermitted) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNotPermitted) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNotPermitted) String() string { return "operation not permitted" }
|
|
|
|
// ErrNotSupported indicates the operation is not supported.
|
|
//
|
|
// +stateify savable
|
|
type ErrNotSupported struct{}
|
|
|
|
func (*ErrNotSupported) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrNotSupported) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrNotSupported) String() string { return "operation not supported" }
|
|
|
|
// ErrPortInUse indicates the provided port is in use.
|
|
//
|
|
// +stateify savable
|
|
type ErrPortInUse struct{}
|
|
|
|
func (*ErrPortInUse) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrPortInUse) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrPortInUse) String() string { return "port is in use" }
|
|
|
|
// ErrQueueSizeNotSupported indicates the endpoint does not allow queue size
|
|
// operation.
|
|
//
|
|
// +stateify savable
|
|
type ErrQueueSizeNotSupported struct{}
|
|
|
|
func (*ErrQueueSizeNotSupported) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrQueueSizeNotSupported) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrQueueSizeNotSupported) String() string { return "queue size querying not supported" }
|
|
|
|
// ErrTimeout indicates the operation timed out.
|
|
//
|
|
// +stateify savable
|
|
type ErrTimeout struct{}
|
|
|
|
func (*ErrTimeout) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrTimeout) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrTimeout) String() string { return "operation timed out" }
|
|
|
|
// ErrUnknownDevice indicates an unknown device identifier was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrUnknownDevice struct{}
|
|
|
|
func (*ErrUnknownDevice) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrUnknownDevice) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrUnknownDevice) String() string { return "unknown device" }
|
|
|
|
// ErrUnknownNICID indicates an unknown NIC ID was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrUnknownNICID struct{}
|
|
|
|
func (*ErrUnknownNICID) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrUnknownNICID) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrUnknownNICID) String() string { return "unknown nic id" }
|
|
|
|
// ErrUnknownProtocol indicates an unknown protocol was requested.
|
|
//
|
|
// +stateify savable
|
|
type ErrUnknownProtocol struct{}
|
|
|
|
func (*ErrUnknownProtocol) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrUnknownProtocol) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrUnknownProtocol) String() string { return "unknown protocol" }
|
|
|
|
// ErrUnknownProtocolOption indicates an unknown protocol option was provided.
|
|
//
|
|
// +stateify savable
|
|
type ErrUnknownProtocolOption struct{}
|
|
|
|
func (*ErrUnknownProtocolOption) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrUnknownProtocolOption) IgnoreStats() bool {
|
|
return false
|
|
}
|
|
func (*ErrUnknownProtocolOption) String() string { return "unknown option for protocol" }
|
|
|
|
// ErrWouldBlock indicates the operation would block.
|
|
//
|
|
// +stateify savable
|
|
type ErrWouldBlock struct{}
|
|
|
|
func (*ErrWouldBlock) isError() {}
|
|
|
|
// IgnoreStats implements Error.
|
|
func (*ErrWouldBlock) IgnoreStats() bool {
|
|
return true
|
|
}
|
|
func (*ErrWouldBlock) String() string { return "operation would block" }
|
|
|
|
// LINT.ThenChange(../syserr/netstack.go)
|