github.com/metacubex/gvisor@v0.0.0-20240320004321-933faba989ec/pkg/tcpip/tcpip_state_autogen.go

// automatically generated by stateify.

package tcpip

import (
	"context"

	"github.com/metacubex/gvisor/pkg/state"
)

func (e *ErrAborted) StateTypeName() string {
	return "pkg/tcpip.ErrAborted"
}

func (e *ErrAborted) StateFields() []string {
	return []string{}
}

func (e *ErrAborted) beforeSave() {}

// +checklocksignore
func (e *ErrAborted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAborted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAddressFamilyNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrAddressFamilyNotSupported"
}

func (e *ErrAddressFamilyNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrAddressFamilyNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrAddressFamilyNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAddressFamilyNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAddressFamilyNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyBound) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyBound"
}

func (e *ErrAlreadyBound) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyBound) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyBound) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyBound) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyBound) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyConnected) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyConnected"
}

func (e *ErrAlreadyConnected) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyConnected) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyConnected) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyConnected) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyConnecting) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyConnecting"
}

func (e *ErrAlreadyConnecting) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyConnecting) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyConnecting) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyConnecting) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyConnecting) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadAddress) StateTypeName() string {
	return "pkg/tcpip.ErrBadAddress"
}

func (e *ErrBadAddress) StateFields() []string {
	return []string{}
}

func (e *ErrBadAddress) beforeSave() {}

// +checklocksignore
func (e *ErrBadAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadBuffer) StateTypeName() string {
	return "pkg/tcpip.ErrBadBuffer"
}

func (e *ErrBadBuffer) StateFields() []string {
	return []string{}
}

func (e *ErrBadBuffer) beforeSave() {}

// +checklocksignore
func (e *ErrBadBuffer) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadBuffer) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadBuffer) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadLocalAddress) StateTypeName() string {
	return "pkg/tcpip.ErrBadLocalAddress"
}

func (e *ErrBadLocalAddress) StateFields() []string {
	return []string{}
}

func (e *ErrBadLocalAddress) beforeSave() {}

// +checklocksignore
func (e *ErrBadLocalAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadLocalAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadLocalAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBroadcastDisabled) StateTypeName() string {
	return "pkg/tcpip.ErrBroadcastDisabled"
}

func (e *ErrBroadcastDisabled) StateFields() []string {
	return []string{}
}

func (e *ErrBroadcastDisabled) beforeSave() {}

// +checklocksignore
func (e *ErrBroadcastDisabled) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBroadcastDisabled) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBroadcastDisabled) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrClosedForReceive) StateTypeName() string {
	return "pkg/tcpip.ErrClosedForReceive"
}

func (e *ErrClosedForReceive) StateFields() []string {
	return []string{}
}

func (e *ErrClosedForReceive) beforeSave() {}

// +checklocksignore
func (e *ErrClosedForReceive) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrClosedForReceive) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrClosedForReceive) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrClosedForSend) StateTypeName() string {
	return "pkg/tcpip.ErrClosedForSend"
}

func (e *ErrClosedForSend) StateFields() []string {
	return []string{}
}

func (e *ErrClosedForSend) beforeSave() {}

// +checklocksignore
func (e *ErrClosedForSend) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrClosedForSend) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrClosedForSend) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectStarted) StateTypeName() string {
	return "pkg/tcpip.ErrConnectStarted"
}

func (e *ErrConnectStarted) StateFields() []string {
	return []string{}
}

func (e *ErrConnectStarted) beforeSave() {}

// +checklocksignore
func (e *ErrConnectStarted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectStarted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectStarted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionAborted) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionAborted"
}

func (e *ErrConnectionAborted) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionAborted) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionAborted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionAborted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionRefused) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionRefused"
}

func (e *ErrConnectionRefused) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionRefused) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionRefused) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionRefused) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionRefused) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionReset) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionReset"
}

func (e *ErrConnectionReset) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionReset) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionReset) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionReset) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionReset) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDestinationRequired) StateTypeName() string {
	return "pkg/tcpip.ErrDestinationRequired"
}

func (e *ErrDestinationRequired) StateFields() []string {
	return []string{}
}

func (e *ErrDestinationRequired) beforeSave() {}

// +checklocksignore
func (e *ErrDestinationRequired) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDestinationRequired) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDestinationRequired) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDuplicateAddress) StateTypeName() string {
	return "pkg/tcpip.ErrDuplicateAddress"
}

func (e *ErrDuplicateAddress) StateFields() []string {
	return []string{}
}

func (e *ErrDuplicateAddress) beforeSave() {}

// +checklocksignore
func (e *ErrDuplicateAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDuplicateAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDuplicateAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDuplicateNICID) StateTypeName() string {
	return "pkg/tcpip.ErrDuplicateNICID"
}

func (e *ErrDuplicateNICID) StateFields() []string {
	return []string{}
}

func (e *ErrDuplicateNICID) beforeSave() {}

// +checklocksignore
func (e *ErrDuplicateNICID) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDuplicateNICID) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDuplicateNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidEndpointState) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidEndpointState"
}

func (e *ErrInvalidEndpointState) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidEndpointState) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidEndpointState) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidEndpointState) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidEndpointState) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidOptionValue) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidOptionValue"
}

func (e *ErrInvalidOptionValue) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidOptionValue) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidOptionValue) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidOptionValue) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidOptionValue) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidPortRange) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidPortRange"
}

func (e *ErrInvalidPortRange) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidPortRange) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidPortRange) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidPortRange) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidPortRange) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMalformedHeader) StateTypeName() string {
	return "pkg/tcpip.ErrMalformedHeader"
}

func (e *ErrMalformedHeader) StateFields() []string {
	return []string{}
}

func (e *ErrMalformedHeader) beforeSave() {}

// +checklocksignore
func (e *ErrMalformedHeader) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMalformedHeader) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMalformedHeader) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMessageTooLong) StateTypeName() string {
	return "pkg/tcpip.ErrMessageTooLong"
}

func (e *ErrMessageTooLong) StateFields() []string {
	return []string{}
}

func (e *ErrMessageTooLong) beforeSave() {}

// +checklocksignore
func (e *ErrMessageTooLong) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMessageTooLong) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMessageTooLong) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNetworkUnreachable) StateTypeName() string {
	return "pkg/tcpip.ErrNetworkUnreachable"
}

func (e *ErrNetworkUnreachable) StateFields() []string {
	return []string{}
}

func (e *ErrNetworkUnreachable) beforeSave() {}

// +checklocksignore
func (e *ErrNetworkUnreachable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNetworkUnreachable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNetworkUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoBufferSpace) StateTypeName() string {
	return "pkg/tcpip.ErrNoBufferSpace"
}

func (e *ErrNoBufferSpace) StateFields() []string {
	return []string{}
}

func (e *ErrNoBufferSpace) beforeSave() {}

// +checklocksignore
func (e *ErrNoBufferSpace) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoBufferSpace) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoBufferSpace) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoPortAvailable) StateTypeName() string {
	return "pkg/tcpip.ErrNoPortAvailable"
}

func (e *ErrNoPortAvailable) StateFields() []string {
	return []string{}
}

func (e *ErrNoPortAvailable) beforeSave() {}

// +checklocksignore
func (e *ErrNoPortAvailable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoPortAvailable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoPortAvailable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrHostUnreachable) StateTypeName() string {
	return "pkg/tcpip.ErrHostUnreachable"
}

func (e *ErrHostUnreachable) StateFields() []string {
	return []string{}
}

func (e *ErrHostUnreachable) beforeSave() {}

// +checklocksignore
func (e *ErrHostUnreachable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrHostUnreachable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrHostUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrHostDown) StateTypeName() string {
	return "pkg/tcpip.ErrHostDown"
}

func (e *ErrHostDown) StateFields() []string {
	return []string{}
}

func (e *ErrHostDown) beforeSave() {}

// +checklocksignore
func (e *ErrHostDown) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrHostDown) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrHostDown) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoNet) StateTypeName() string {
	return "pkg/tcpip.ErrNoNet"
}

func (e *ErrNoNet) StateFields() []string {
	return []string{}
}

func (e *ErrNoNet) beforeSave() {}

// +checklocksignore
func (e *ErrNoNet) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoNet) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoNet) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoSuchFile) StateTypeName() string {
	return "pkg/tcpip.ErrNoSuchFile"
}

func (e *ErrNoSuchFile) StateFields() []string {
	return []string{}
}

func (e *ErrNoSuchFile) beforeSave() {}

// +checklocksignore
func (e *ErrNoSuchFile) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoSuchFile) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoSuchFile) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotConnected) StateTypeName() string {
	return "pkg/tcpip.ErrNotConnected"
}

func (e *ErrNotConnected) StateFields() []string {
	return []string{}
}

func (e *ErrNotConnected) beforeSave() {}

// +checklocksignore
func (e *ErrNotConnected) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotConnected) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotPermitted) StateTypeName() string {
	return "pkg/tcpip.ErrNotPermitted"
}

func (e *ErrNotPermitted) StateFields() []string {
	return []string{}
}

func (e *ErrNotPermitted) beforeSave() {}

// +checklocksignore
func (e *ErrNotPermitted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotPermitted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotPermitted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrNotSupported"
}

func (e *ErrNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrPortInUse) StateTypeName() string {
	return "pkg/tcpip.ErrPortInUse"
}

func (e *ErrPortInUse) StateFields() []string {
	return []string{}
}

func (e *ErrPortInUse) beforeSave() {}

// +checklocksignore
func (e *ErrPortInUse) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrPortInUse) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrPortInUse) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrQueueSizeNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrQueueSizeNotSupported"
}

func (e *ErrQueueSizeNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrQueueSizeNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrQueueSizeNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrQueueSizeNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrQueueSizeNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrTimeout) StateTypeName() string {
	return "pkg/tcpip.ErrTimeout"
}

func (e *ErrTimeout) StateFields() []string {
	return []string{}
}

func (e *ErrTimeout) beforeSave() {}

// +checklocksignore
func (e *ErrTimeout) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrTimeout) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrTimeout) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownDevice) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownDevice"
}

func (e *ErrUnknownDevice) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownDevice) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownDevice) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownDevice) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownDevice) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownNICID) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownNICID"
}

func (e *ErrUnknownNICID) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownNICID) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownNICID) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownNICID) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownProtocol) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownProtocol"
}

func (e *ErrUnknownProtocol) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownProtocol) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownProtocol) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownProtocol) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownProtocol) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownProtocolOption) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownProtocolOption"
}

func (e *ErrUnknownProtocolOption) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownProtocolOption) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownProtocolOption) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownProtocolOption) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownProtocolOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrWouldBlock) StateTypeName() string {
	return "pkg/tcpip.ErrWouldBlock"
}

func (e *ErrWouldBlock) StateFields() []string {
	return []string{}
}

func (e *ErrWouldBlock) beforeSave() {}

// +checklocksignore
func (e *ErrWouldBlock) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrWouldBlock) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrWouldBlock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMissingRequiredFields) StateTypeName() string {
	return "pkg/tcpip.ErrMissingRequiredFields"
}

func (e *ErrMissingRequiredFields) StateFields() []string {
	return []string{}
}

func (e *ErrMissingRequiredFields) beforeSave() {}

// +checklocksignore
func (e *ErrMissingRequiredFields) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMissingRequiredFields) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMissingRequiredFields) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMulticastInputCannotBeOutput) StateTypeName() string {
	return "pkg/tcpip.ErrMulticastInputCannotBeOutput"
}

func (e *ErrMulticastInputCannotBeOutput) StateFields() []string {
	return []string{}
}

func (e *ErrMulticastInputCannotBeOutput) beforeSave() {}

// +checklocksignore
func (e *ErrMulticastInputCannotBeOutput) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMulticastInputCannotBeOutput) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMulticastInputCannotBeOutput) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (l *sockErrorList) StateTypeName() string {
	return "pkg/tcpip.sockErrorList"
}

func (l *sockErrorList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (l *sockErrorList) beforeSave() {}

// +checklocksignore
func (l *sockErrorList) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.head)
	stateSinkObject.Save(1, &l.tail)
}

func (l *sockErrorList) afterLoad(context.Context) {}

// +checklocksignore
func (l *sockErrorList) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.head)
	stateSourceObject.Load(1, &l.tail)
}

func (e *sockErrorEntry) StateTypeName() string {
	return "pkg/tcpip.sockErrorEntry"
}

func (e *sockErrorEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (e *sockErrorEntry) beforeSave() {}

// +checklocksignore
func (e *sockErrorEntry) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
	stateSinkObject.Save(0, &e.next)
	stateSinkObject.Save(1, &e.prev)
}

func (e *sockErrorEntry) afterLoad(context.Context) {}

// +checklocksignore
func (e *sockErrorEntry) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &e.next)
	stateSourceObject.Load(1, &e.prev)
}

func (so *SocketOptions) StateTypeName() string {
	return "pkg/tcpip.SocketOptions"
}

func (so *SocketOptions) StateFields() []string {
	return []string{
		"handler",
		"broadcastEnabled",
		"passCredEnabled",
		"noChecksumEnabled",
		"reuseAddressEnabled",
		"reusePortEnabled",
		"keepAliveEnabled",
		"multicastLoopEnabled",
		"receiveTOSEnabled",
		"receiveTTLEnabled",
		"receiveHopLimitEnabled",
		"receiveTClassEnabled",
		"receivePacketInfoEnabled",
		"receiveIPv6PacketInfoEnabled",
		"hdrIncludedEnabled",
		"v6OnlyEnabled",
		"quickAckEnabled",
		"delayOptionEnabled",
		"corkOptionEnabled",
		"receiveOriginalDstAddress",
		"ipv4RecvErrEnabled",
		"ipv6RecvErrEnabled",
		"errQueue",
		"bindToDevice",
		"sendBufferSize",
		"receiveBufferSize",
		"linger",
		"rcvlowat",
	}
}

func (so *SocketOptions) beforeSave() {}

// +checklocksignore
func (so *SocketOptions) StateSave(stateSinkObject state.Sink) {
	so.beforeSave()
	stateSinkObject.Save(0, &so.handler)
	stateSinkObject.Save(1, &so.broadcastEnabled)
	stateSinkObject.Save(2, &so.passCredEnabled)
	stateSinkObject.Save(3, &so.noChecksumEnabled)
	stateSinkObject.Save(4, &so.reuseAddressEnabled)
	stateSinkObject.Save(5, &so.reusePortEnabled)
	stateSinkObject.Save(6, &so.keepAliveEnabled)
	stateSinkObject.Save(7, &so.multicastLoopEnabled)
	stateSinkObject.Save(8, &so.receiveTOSEnabled)
	stateSinkObject.Save(9, &so.receiveTTLEnabled)
	stateSinkObject.Save(10, &so.receiveHopLimitEnabled)
	stateSinkObject.Save(11, &so.receiveTClassEnabled)
	stateSinkObject.Save(12, &so.receivePacketInfoEnabled)
	stateSinkObject.Save(13, &so.receiveIPv6PacketInfoEnabled)
	stateSinkObject.Save(14, &so.hdrIncludedEnabled)
	stateSinkObject.Save(15, &so.v6OnlyEnabled)
	stateSinkObject.Save(16, &so.quickAckEnabled)
	stateSinkObject.Save(17, &so.delayOptionEnabled)
	stateSinkObject.Save(18, &so.corkOptionEnabled)
	stateSinkObject.Save(19, &so.receiveOriginalDstAddress)
	stateSinkObject.Save(20, &so.ipv4RecvErrEnabled)
	stateSinkObject.Save(21, &so.ipv6RecvErrEnabled)
	stateSinkObject.Save(22, &so.errQueue)
	stateSinkObject.Save(23, &so.bindToDevice)
	stateSinkObject.Save(24, &so.sendBufferSize)
	stateSinkObject.Save(25, &so.receiveBufferSize)
	stateSinkObject.Save(26, &so.linger)
	stateSinkObject.Save(27, &so.rcvlowat)
}

func (so *SocketOptions) afterLoad(context.Context) {}

// +checklocksignore
func (so *SocketOptions) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &so.handler)
	stateSourceObject.Load(1, &so.broadcastEnabled)
	stateSourceObject.Load(2, &so.passCredEnabled)
	stateSourceObject.Load(3, &so.noChecksumEnabled)
	stateSourceObject.Load(4, &so.reuseAddressEnabled)
	stateSourceObject.Load(5, &so.reusePortEnabled)
	stateSourceObject.Load(6, &so.keepAliveEnabled)
	stateSourceObject.Load(7, &so.multicastLoopEnabled)
	stateSourceObject.Load(8, &so.receiveTOSEnabled)
	stateSourceObject.Load(9, &so.receiveTTLEnabled)
	stateSourceObject.Load(10, &so.receiveHopLimitEnabled)
	stateSourceObject.Load(11, &so.receiveTClassEnabled)
	stateSourceObject.Load(12, &so.receivePacketInfoEnabled)
	stateSourceObject.Load(13, &so.receiveIPv6PacketInfoEnabled)
	stateSourceObject.Load(14, &so.hdrIncludedEnabled)
	stateSourceObject.Load(15, &so.v6OnlyEnabled)
	stateSourceObject.Load(16, &so.quickAckEnabled)
	stateSourceObject.Load(17, &so.delayOptionEnabled)
	stateSourceObject.Load(18, &so.corkOptionEnabled)
	stateSourceObject.Load(19, &so.receiveOriginalDstAddress)
	stateSourceObject.Load(20, &so.ipv4RecvErrEnabled)
	stateSourceObject.Load(21, &so.ipv6RecvErrEnabled)
	stateSourceObject.Load(22, &so.errQueue)
	stateSourceObject.Load(23, &so.bindToDevice)
	stateSourceObject.Load(24, &so.sendBufferSize)
	stateSourceObject.Load(25, &so.receiveBufferSize)
	stateSourceObject.Load(26, &so.linger)
	stateSourceObject.Load(27, &so.rcvlowat)
}

func (l *LocalSockError) StateTypeName() string {
	return "pkg/tcpip.LocalSockError"
}

func (l *LocalSockError) StateFields() []string {
	return []string{
		"info",
	}
}

func (l *LocalSockError) beforeSave() {}

// +checklocksignore
func (l *LocalSockError) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.info)
}

func (l *LocalSockError) afterLoad(context.Context) {}

// +checklocksignore
func (l *LocalSockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.info)
}

func (s *SockError) StateTypeName() string {
	return "pkg/tcpip.SockError"
}

func (s *SockError) StateFields() []string {
	return []string{
		"sockErrorEntry",
		"Err",
		"Cause",
		"Payload",
		"Dst",
		"Offender",
		"NetProto",
	}
}

func (s *SockError) beforeSave() {}

// +checklocksignore
func (s *SockError) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.sockErrorEntry)
	stateSinkObject.Save(1, &s.Err)
	stateSinkObject.Save(2, &s.Cause)
	stateSinkObject.Save(3, &s.Payload)
	stateSinkObject.Save(4, &s.Dst)
	stateSinkObject.Save(5, &s.Offender)
	stateSinkObject.Save(6, &s.NetProto)
}

func (s *SockError) afterLoad(context.Context) {}

// +checklocksignore
func (s *SockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.sockErrorEntry)
	stateSourceObject.Load(1, &s.Err)
	stateSourceObject.Load(2, &s.Cause)
	stateSourceObject.Load(3, &s.Payload)
	stateSourceObject.Load(4, &s.Dst)
	stateSourceObject.Load(5, &s.Offender)
	stateSourceObject.Load(6, &s.NetProto)
}

func (s *stdClock) StateTypeName() string {
	return "pkg/tcpip.stdClock"
}

func (s *stdClock) StateFields() []string {
	return []string{
		"monotonicOffset",
	}
}

// +checklocksignore
func (s *stdClock) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.monotonicOffset)
}

// +checklocksignore
func (s *stdClock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.monotonicOffset)
	stateSourceObject.AfterLoad(func() { s.afterLoad(ctx) })
}

func (mt *MonotonicTime) StateTypeName() string {
	return "pkg/tcpip.MonotonicTime"
}

func (mt *MonotonicTime) StateFields() []string {
	return []string{
		"nanoseconds",
	}
}

func (mt *MonotonicTime) beforeSave() {}

// +checklocksignore
func (mt *MonotonicTime) StateSave(stateSinkObject state.Sink) {
	mt.beforeSave()
	stateSinkObject.Save(0, &mt.nanoseconds)
}

func (mt *MonotonicTime) afterLoad(context.Context) {}

// +checklocksignore
func (mt *MonotonicTime) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &mt.nanoseconds)
}

func (a *Address) StateTypeName() string {
	return "pkg/tcpip.Address"
}

func (a *Address) StateFields() []string {
	return []string{
		"addr",
		"length",
	}
}

func (a *Address) beforeSave() {}

// +checklocksignore
func (a *Address) StateSave(stateSinkObject state.Sink) {
	a.beforeSave()
	stateSinkObject.Save(0, &a.addr)
	stateSinkObject.Save(1, &a.length)
}

func (a *Address) afterLoad(context.Context) {}

// +checklocksignore
func (a *Address) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &a.addr)
	stateSourceObject.Load(1, &a.length)
}

func (m *AddressMask) StateTypeName() string {
	return "pkg/tcpip.AddressMask"
}

func (m *AddressMask) StateFields() []string {
	return []string{
		"mask",
		"length",
	}
}

func (m *AddressMask) beforeSave() {}

// +checklocksignore
func (m *AddressMask) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.mask)
	stateSinkObject.Save(1, &m.length)
}

func (m *AddressMask) afterLoad(context.Context) {}

// +checklocksignore
func (m *AddressMask) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.mask)
	stateSourceObject.Load(1, &m.length)
}

func (f *FullAddress) StateTypeName() string {
	return "pkg/tcpip.FullAddress"
}

func (f *FullAddress) StateFields() []string {
	return []string{
		"NIC",
		"Addr",
		"Port",
		"LinkAddr",
	}
}

func (f *FullAddress) beforeSave() {}

// +checklocksignore
func (f *FullAddress) StateSave(stateSinkObject state.Sink) {
	f.beforeSave()
	stateSinkObject.Save(0, &f.NIC)
	stateSinkObject.Save(1, &f.Addr)
	stateSinkObject.Save(2, &f.Port)
	stateSinkObject.Save(3, &f.LinkAddr)
}

func (f *FullAddress) afterLoad(context.Context) {}

// +checklocksignore
func (f *FullAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.NIC)
	stateSourceObject.Load(1, &f.Addr)
	stateSourceObject.Load(2, &f.Port)
	stateSourceObject.Load(3, &f.LinkAddr)
}

func (s *SendableControlMessages) StateTypeName() string {
	return "pkg/tcpip.SendableControlMessages"
}

func (s *SendableControlMessages) StateFields() []string {
	return []string{
		"HasTTL",
		"TTL",
		"HasHopLimit",
		"HopLimit",
		"HasIPv6PacketInfo",
		"IPv6PacketInfo",
	}
}

func (s *SendableControlMessages) beforeSave() {}

// +checklocksignore
func (s *SendableControlMessages) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.HasTTL)
	stateSinkObject.Save(1, &s.TTL)
	stateSinkObject.Save(2, &s.HasHopLimit)
	stateSinkObject.Save(3, &s.HopLimit)
	stateSinkObject.Save(4, &s.HasIPv6PacketInfo)
	stateSinkObject.Save(5, &s.IPv6PacketInfo)
}

func (s *SendableControlMessages) afterLoad(context.Context) {}

// +checklocksignore
func (s *SendableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.HasTTL)
	stateSourceObject.Load(1, &s.TTL)
	stateSourceObject.Load(2, &s.HasHopLimit)
	stateSourceObject.Load(3, &s.HopLimit)
	stateSourceObject.Load(4, &s.HasIPv6PacketInfo)
	stateSourceObject.Load(5, &s.IPv6PacketInfo)
}

func (c *ReceivableControlMessages) StateTypeName() string {
	return "pkg/tcpip.ReceivableControlMessages"
}

func (c *ReceivableControlMessages) StateFields() []string {
	return []string{
		"Timestamp",
		"HasInq",
		"Inq",
		"HasTOS",
		"TOS",
		"HasTTL",
		"TTL",
		"HasHopLimit",
		"HopLimit",
		"HasTimestamp",
		"HasTClass",
		"TClass",
		"HasIPPacketInfo",
		"PacketInfo",
		"HasIPv6PacketInfo",
		"IPv6PacketInfo",
		"HasOriginalDstAddress",
		"OriginalDstAddress",
		"SockErr",
	}
}

func (c *ReceivableControlMessages) beforeSave() {}

// +checklocksignore
func (c *ReceivableControlMessages) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	var TimestampValue int64
	TimestampValue = c.saveTimestamp()
	stateSinkObject.SaveValue(0, TimestampValue)
	stateSinkObject.Save(1, &c.HasInq)
	stateSinkObject.Save(2, &c.Inq)
	stateSinkObject.Save(3, &c.HasTOS)
	stateSinkObject.Save(4, &c.TOS)
	stateSinkObject.Save(5, &c.HasTTL)
	stateSinkObject.Save(6, &c.TTL)
	stateSinkObject.Save(7, &c.HasHopLimit)
	stateSinkObject.Save(8, &c.HopLimit)
	stateSinkObject.Save(9, &c.HasTimestamp)
	stateSinkObject.Save(10, &c.HasTClass)
	stateSinkObject.Save(11, &c.TClass)
	stateSinkObject.Save(12, &c.HasIPPacketInfo)
	stateSinkObject.Save(13, &c.PacketInfo)
	stateSinkObject.Save(14, &c.HasIPv6PacketInfo)
	stateSinkObject.Save(15, &c.IPv6PacketInfo)
	stateSinkObject.Save(16, &c.HasOriginalDstAddress)
	stateSinkObject.Save(17, &c.OriginalDstAddress)
	stateSinkObject.Save(18, &c.SockErr)
}

func (c *ReceivableControlMessages) afterLoad(context.Context) {}

// +checklocksignore
func (c *ReceivableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(1, &c.HasInq)
	stateSourceObject.Load(2, &c.Inq)
	stateSourceObject.Load(3, &c.HasTOS)
	stateSourceObject.Load(4, &c.TOS)
	stateSourceObject.Load(5, &c.HasTTL)
	stateSourceObject.Load(6, &c.TTL)
	stateSourceObject.Load(7, &c.HasHopLimit)
	stateSourceObject.Load(8, &c.HopLimit)
	stateSourceObject.Load(9, &c.HasTimestamp)
	stateSourceObject.Load(10, &c.HasTClass)
	stateSourceObject.Load(11, &c.TClass)
	stateSourceObject.Load(12, &c.HasIPPacketInfo)
	stateSourceObject.Load(13, &c.PacketInfo)
	stateSourceObject.Load(14, &c.HasIPv6PacketInfo)
	stateSourceObject.Load(15, &c.IPv6PacketInfo)
	stateSourceObject.Load(16, &c.HasOriginalDstAddress)
	stateSourceObject.Load(17, &c.OriginalDstAddress)
	stateSourceObject.Load(18, &c.SockErr)
	stateSourceObject.LoadValue(0, new(int64), func(y any) { c.loadTimestamp(ctx, y.(int64)) })
}

func (l *LinkPacketInfo) StateTypeName() string {
	return "pkg/tcpip.LinkPacketInfo"
}

func (l *LinkPacketInfo) StateFields() []string {
	return []string{
		"Protocol",
		"PktType",
	}
}

func (l *LinkPacketInfo) beforeSave() {}

// +checklocksignore
func (l *LinkPacketInfo) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.Protocol)
	stateSinkObject.Save(1, &l.PktType)
}

func (l *LinkPacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (l *LinkPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.Protocol)
	stateSourceObject.Load(1, &l.PktType)
}

func (f *ICMPv6Filter) StateTypeName() string {
	return "pkg/tcpip.ICMPv6Filter"
}

func (f *ICMPv6Filter) StateFields() []string {
	return []string{
		"DenyType",
	}
}

func (f *ICMPv6Filter) beforeSave() {}

// +checklocksignore
func (f *ICMPv6Filter) StateSave(stateSinkObject state.Sink) {
	f.beforeSave()
	stateSinkObject.Save(0, &f.DenyType)
}

func (f *ICMPv6Filter) afterLoad(context.Context) {}

// +checklocksignore
func (f *ICMPv6Filter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.DenyType)
}

func (l *LingerOption) StateTypeName() string {
	return "pkg/tcpip.LingerOption"
}

func (l *LingerOption) StateFields() []string {
	return []string{
		"Enabled",
		"Timeout",
	}
}

func (l *LingerOption) beforeSave() {}

// +checklocksignore
func (l *LingerOption) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.Enabled)
	stateSinkObject.Save(1, &l.Timeout)
}

func (l *LingerOption) afterLoad(context.Context) {}

// +checklocksignore
func (l *LingerOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.Enabled)
	stateSourceObject.Load(1, &l.Timeout)
}

func (i *IPPacketInfo) StateTypeName() string {
	return "pkg/tcpip.IPPacketInfo"
}

func (i *IPPacketInfo) StateFields() []string {
	return []string{
		"NIC",
		"LocalAddr",
		"DestinationAddr",
	}
}

func (i *IPPacketInfo) beforeSave() {}

// +checklocksignore
func (i *IPPacketInfo) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.NIC)
	stateSinkObject.Save(1, &i.LocalAddr)
	stateSinkObject.Save(2, &i.DestinationAddr)
}

func (i *IPPacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.NIC)
	stateSourceObject.Load(1, &i.LocalAddr)
	stateSourceObject.Load(2, &i.DestinationAddr)
}

func (i *IPv6PacketInfo) StateTypeName() string {
	return "pkg/tcpip.IPv6PacketInfo"
}

func (i *IPv6PacketInfo) StateFields() []string {
	return []string{
		"Addr",
		"NIC",
	}
}

func (i *IPv6PacketInfo) beforeSave() {}

// +checklocksignore
func (i *IPv6PacketInfo) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.Addr)
	stateSinkObject.Save(1, &i.NIC)
}

func (i *IPv6PacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPv6PacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.Addr)
	stateSourceObject.Load(1, &i.NIC)
}

func (s *StatCounter) StateTypeName() string {
	return "pkg/tcpip.StatCounter"
}

func (s *StatCounter) StateFields() []string {
	return []string{
		"count",
	}
}

func (s *StatCounter) beforeSave() {}

// +checklocksignore
func (s *StatCounter) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.count)
}

func (s *StatCounter) afterLoad(context.Context) {}

// +checklocksignore
func (s *StatCounter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.count)
}

func (r *ReceiveErrors) StateTypeName() string {
	return "pkg/tcpip.ReceiveErrors"
}

func (r *ReceiveErrors) StateFields() []string {
	return []string{
		"ReceiveBufferOverflow",
		"MalformedPacketsReceived",
		"ClosedReceiver",
		"ChecksumErrors",
	}
}

func (r *ReceiveErrors) beforeSave() {}

// +checklocksignore
func (r *ReceiveErrors) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.ReceiveBufferOverflow)
	stateSinkObject.Save(1, &r.MalformedPacketsReceived)
	stateSinkObject.Save(2, &r.ClosedReceiver)
	stateSinkObject.Save(3, &r.ChecksumErrors)
}

func (r *ReceiveErrors) afterLoad(context.Context) {}

// +checklocksignore
func (r *ReceiveErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.ReceiveBufferOverflow)
	stateSourceObject.Load(1, &r.MalformedPacketsReceived)
	stateSourceObject.Load(2, &r.ClosedReceiver)
	stateSourceObject.Load(3, &r.ChecksumErrors)
}

func (s *SendErrors) StateTypeName() string {
	return "pkg/tcpip.SendErrors"
}

func (s *SendErrors) StateFields() []string {
	return []string{
		"SendToNetworkFailed",
		"NoRoute",
	}
}

func (s *SendErrors) beforeSave() {}

// +checklocksignore
func (s *SendErrors) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.SendToNetworkFailed)
	stateSinkObject.Save(1, &s.NoRoute)
}

func (s *SendErrors) afterLoad(context.Context) {}

// +checklocksignore
func (s *SendErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.SendToNetworkFailed)
	stateSourceObject.Load(1, &s.NoRoute)
}

func (r *ReadErrors) StateTypeName() string {
	return "pkg/tcpip.ReadErrors"
}

func (r *ReadErrors) StateFields() []string {
	return []string{
		"ReadClosed",
		"InvalidEndpointState",
		"NotConnected",
	}
}

func (r *ReadErrors) beforeSave() {}

// +checklocksignore
func (r *ReadErrors) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.ReadClosed)
	stateSinkObject.Save(1, &r.InvalidEndpointState)
	stateSinkObject.Save(2, &r.NotConnected)
}

func (r *ReadErrors) afterLoad(context.Context) {}

// +checklocksignore
func (r *ReadErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.ReadClosed)
	stateSourceObject.Load(1, &r.InvalidEndpointState)
	stateSourceObject.Load(2, &r.NotConnected)
}

func (w *WriteErrors) StateTypeName() string {
	return "pkg/tcpip.WriteErrors"
}

func (w *WriteErrors) StateFields() []string {
	return []string{
		"WriteClosed",
		"InvalidEndpointState",
		"InvalidArgs",
	}
}

func (w *WriteErrors) beforeSave() {}

// +checklocksignore
func (w *WriteErrors) StateSave(stateSinkObject state.Sink) {
	w.beforeSave()
	stateSinkObject.Save(0, &w.WriteClosed)
	stateSinkObject.Save(1, &w.InvalidEndpointState)
	stateSinkObject.Save(2, &w.InvalidArgs)
}

func (w *WriteErrors) afterLoad(context.Context) {}

// +checklocksignore
func (w *WriteErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &w.WriteClosed)
	stateSourceObject.Load(1, &w.InvalidEndpointState)
	stateSourceObject.Load(2, &w.InvalidArgs)
}

func (src *TransportEndpointStats) StateTypeName() string {
	return "pkg/tcpip.TransportEndpointStats"
}

func (src *TransportEndpointStats) StateFields() []string {
	return []string{
		"PacketsReceived",
		"PacketsSent",
		"ReceiveErrors",
		"ReadErrors",
		"SendErrors",
		"WriteErrors",
	}
}

func (src *TransportEndpointStats) beforeSave() {}

// +checklocksignore
func (src *TransportEndpointStats) StateSave(stateSinkObject state.Sink) {
	src.beforeSave()
	stateSinkObject.Save(0, &src.PacketsReceived)
	stateSinkObject.Save(1, &src.PacketsSent)
	stateSinkObject.Save(2, &src.ReceiveErrors)
	stateSinkObject.Save(3, &src.ReadErrors)
	stateSinkObject.Save(4, &src.SendErrors)
	stateSinkObject.Save(5, &src.WriteErrors)
}

func (src *TransportEndpointStats) afterLoad(context.Context) {}

// +checklocksignore
func (src *TransportEndpointStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &src.PacketsReceived)
	stateSourceObject.Load(1, &src.PacketsSent)
	stateSourceObject.Load(2, &src.ReceiveErrors)
	stateSourceObject.Load(3, &src.ReadErrors)
	stateSourceObject.Load(4, &src.SendErrors)
	stateSourceObject.Load(5, &src.WriteErrors)
}

func (a *AddressWithPrefix) StateTypeName() string {
	return "pkg/tcpip.AddressWithPrefix"
}

func (a *AddressWithPrefix) StateFields() []string {
	return []string{
		"Address",
		"PrefixLen",
	}
}

func (a *AddressWithPrefix) beforeSave() {}

// +checklocksignore
func (a *AddressWithPrefix) StateSave(stateSinkObject state.Sink) {
	a.beforeSave()
	stateSinkObject.Save(0, &a.Address)
	stateSinkObject.Save(1, &a.PrefixLen)
}

func (a *AddressWithPrefix) afterLoad(context.Context) {}

// +checklocksignore
func (a *AddressWithPrefix) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &a.Address)
	stateSourceObject.Load(1, &a.PrefixLen)
}

func init() {
	state.Register((*ErrAborted)(nil))
	state.Register((*ErrAddressFamilyNotSupported)(nil))
	state.Register((*ErrAlreadyBound)(nil))
	state.Register((*ErrAlreadyConnected)(nil))
	state.Register((*ErrAlreadyConnecting)(nil))
	state.Register((*ErrBadAddress)(nil))
	state.Register((*ErrBadBuffer)(nil))
	state.Register((*ErrBadLocalAddress)(nil))
	state.Register((*ErrBroadcastDisabled)(nil))
	state.Register((*ErrClosedForReceive)(nil))
	state.Register((*ErrClosedForSend)(nil))
	state.Register((*ErrConnectStarted)(nil))
	state.Register((*ErrConnectionAborted)(nil))
	state.Register((*ErrConnectionRefused)(nil))
	state.Register((*ErrConnectionReset)(nil))
	state.Register((*ErrDestinationRequired)(nil))
	state.Register((*ErrDuplicateAddress)(nil))
	state.Register((*ErrDuplicateNICID)(nil))
	state.Register((*ErrInvalidEndpointState)(nil))
	state.Register((*ErrInvalidOptionValue)(nil))
	state.Register((*ErrInvalidPortRange)(nil))
	state.Register((*ErrMalformedHeader)(nil))
	state.Register((*ErrMessageTooLong)(nil))
	state.Register((*ErrNetworkUnreachable)(nil))
	state.Register((*ErrNoBufferSpace)(nil))
	state.Register((*ErrNoPortAvailable)(nil))
	state.Register((*ErrHostUnreachable)(nil))
	state.Register((*ErrHostDown)(nil))
	state.Register((*ErrNoNet)(nil))
	state.Register((*ErrNoSuchFile)(nil))
	state.Register((*ErrNotConnected)(nil))
	state.Register((*ErrNotPermitted)(nil))
	state.Register((*ErrNotSupported)(nil))
	state.Register((*ErrPortInUse)(nil))
	state.Register((*ErrQueueSizeNotSupported)(nil))
	state.Register((*ErrTimeout)(nil))
	state.Register((*ErrUnknownDevice)(nil))
	state.Register((*ErrUnknownNICID)(nil))
	state.Register((*ErrUnknownProtocol)(nil))
	state.Register((*ErrUnknownProtocolOption)(nil))
	state.Register((*ErrWouldBlock)(nil))
	state.Register((*ErrMissingRequiredFields)(nil))
	state.Register((*ErrMulticastInputCannotBeOutput)(nil))
	state.Register((*sockErrorList)(nil))
	state.Register((*sockErrorEntry)(nil))
	state.Register((*SocketOptions)(nil))
	state.Register((*LocalSockError)(nil))
	state.Register((*SockError)(nil))
	state.Register((*stdClock)(nil))
	state.Register((*MonotonicTime)(nil))
	state.Register((*Address)(nil))
	state.Register((*AddressMask)(nil))
	state.Register((*FullAddress)(nil))
	state.Register((*SendableControlMessages)(nil))
	state.Register((*ReceivableControlMessages)(nil))
	state.Register((*LinkPacketInfo)(nil))
	state.Register((*ICMPv6Filter)(nil))
	state.Register((*LingerOption)(nil))
	state.Register((*IPPacketInfo)(nil))
	state.Register((*IPv6PacketInfo)(nil))
	state.Register((*StatCounter)(nil))
	state.Register((*ReceiveErrors)(nil))
	state.Register((*SendErrors)(nil))
	state.Register((*ReadErrors)(nil))
	state.Register((*WriteErrors)(nil))
	state.Register((*TransportEndpointStats)(nil))
	state.Register((*AddressWithPrefix)(nil))
}