socket

package
v0.0.0-...-0fb4cc7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 20, 2024 License: Apache-2.0, MIT Imports: 18 Imported by: 26

Documentation

Overview

Package socket provides the interfaces that need to be provided by socket implementations and providers, as well as per family demultiplexing of socket creation.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddressAndFamily 

func AddressAndFamily(addr []byte) (tcpip.FullAddress, uint16, *syserr.Error)

AddressAndFamily reads an sockaddr struct from the given address and converts it to the FullAddress format. It supports AF_INET, AF_INET6, and AF_PACKET addresses.

AddressAndFamily returns an address and its family.

func BytesToIPAddress 

func BytesToIPAddress(addr []byte) tcpip.Address

BytesToIPAddress converts an IPv4 or IPv6 address from the user to the netstack representation taking any addresses into account.

func ConvertAddress 

func ConvertAddress(family int, addr tcpip.FullAddress) (linux.SockAddr, uint32)

ConvertAddress converts the given address to a native format.

func Htons 

func Htons(v uint16) uint16

Htons converts a 16-bit number from host byte order to network byte order. It assumes that the host is little endian.

func IsICMP 

func IsICMP(s Socket) bool

IsICMP returns true if the socket is an ICMP socket.

func IsRaw 

func IsRaw(s Socket) bool

IsRaw returns true if the socket is a raw socket.

func IsTCP 

func IsTCP(s Socket) bool

IsTCP returns true if the socket is a TCP socket.

func IsUDP 

func IsUDP(s Socket) bool

IsUDP returns true if the socket is a UDP socket.

func New 

func New(t *kernel.Task, family int, stype linux.SockType, protocol int) (*vfs.FileDescription, *syserr.Error)

New creates a new socket with the given family, type and protocol.

func Ntohs 

func Ntohs(v uint16) uint16

Ntohs converts a 16-bit number from network byte order to host byte order. It assumes that the host is little endian.

func Pair 

func Pair(t *kernel.Task, family int, stype linux.SockType, protocol int) (*vfs.FileDescription, *vfs.FileDescription, *syserr.Error)

Pair creates a new connected socket pair with the given family, type and protocol.

func RegisterProvider 

func RegisterProvider(family int, provider Provider)

RegisterProvider registers the provider of a given address family so that sockets of that type can be created via socket() and/or socketpair() syscalls.

This should only be called during the initialization of the address family.

func UnmarshalSockAddr 

func UnmarshalSockAddr(family int, data []byte) linux.SockAddr

UnmarshalSockAddr unmarshals memory representing a struct sockaddr to one of the ABI socket address types.

Precondition: data must be long enough to represent a socket address of the given family.

Types

type ControlMessages 

type ControlMessages struct {
	Unix transport.ControlMessages
	IP   IPControlMessages
}

ControlMessages represents the union of unix control messages and tcpip control messages.

func (*ControlMessages) Release 

func (c *ControlMessages) Release(ctx context.Context)

Release releases Unix domain socket credentials and rights.

type IPControlMessages 

type IPControlMessages struct {
	// HasTimestamp indicates whether Timestamp is valid/set.
	HasTimestamp bool

	// Timestamp is the time that the last packet used to create the read data
	// was received.
	Timestamp time.Time `state:".(int64)"`

	// HasInq indicates whether Inq is valid/set.
	HasInq bool

	// Inq is the number of bytes ready to be received.
	Inq int32

	// HasTOS indicates whether Tos is valid/set.
	HasTOS bool

	// TOS is the IPv4 type of service of the associated packet.
	TOS uint8

	// HasTTL indicates whether TTL is valid/set.
	HasTTL bool

	// TTL is the IPv4 Time To Live of the associated packet.
	TTL uint32

	// HasHopLimit indicates whether HopLimit is valid/set.
	HasHopLimit bool

	// HopLimit is the IPv6 Hop Limit of the associated packet.
	HopLimit uint32

	// HasTClass indicates whether TClass is valid/set.
	HasTClass bool

	// TClass is the IPv6 traffic class of the associated packet.
	TClass uint32

	// HasIPPacketInfo indicates whether PacketInfo is set.
	HasIPPacketInfo bool

	// PacketInfo holds interface and address data on an incoming packet.
	PacketInfo linux.ControlMessageIPPacketInfo

	// HasIPv6PacketInfo indicates whether IPv6PacketInfo is set.
	HasIPv6PacketInfo bool

	// PacketInfo holds interface and address data on an incoming packet.
	IPv6PacketInfo linux.ControlMessageIPv6PacketInfo

	// OriginalDestinationAddress holds the original destination address
	// and port of the incoming packet.
	OriginalDstAddress linux.SockAddr

	// SockErr is the dequeued socket error on recvmsg(MSG_ERRQUEUE).
	SockErr linux.SockErrCMsg
}

IPControlMessages contains socket control messages for IP sockets. This can contain Linux specific structures unlike tcpip.ControlMessages.

+stateify savable

func NewIPControlMessages 

func NewIPControlMessages(family int, cmgs tcpip.ReceivableControlMessages) IPControlMessages

NewIPControlMessages converts the tcpip.ReceivableControlMessages (which does not have Linux specific format) to Linux format.

type Provider 

type Provider interface {
	// Socket creates a new socket.
	//
	// If a nil Socket _and_ a nil error is returned, it means that the
	// protocol is not supported. A non-nil error should only be returned
	// if the protocol is supported, but an error occurs during creation.
	Socket(t *kernel.Task, stype linux.SockType, protocol int) (*vfs.FileDescription, *syserr.Error)

	// Pair creates a pair of connected sockets.
	//
	// See Socket for error information.
	Pair(t *kernel.Task, stype linux.SockType, protocol int) (*vfs.FileDescription, *vfs.FileDescription, *syserr.Error)
}

Provider is the interface implemented by providers of sockets for specific address families (e.g., AF_INET).

type SendReceiveTimeout 

type SendReceiveTimeout struct {
	// contains filtered or unexported fields
}

SendReceiveTimeout stores timeouts for send and receive calls.

It is meant to be embedded into Socket implementations to help satisfy the interface.

Care must be taken when copying SendReceiveTimeout as it contains atomic variables.

+stateify savable

func (*SendReceiveTimeout) RecvTimeout 

func (to *SendReceiveTimeout) RecvTimeout() int64

RecvTimeout implements Socket.RecvTimeout.

func (*SendReceiveTimeout) SendTimeout 

func (to *SendReceiveTimeout) SendTimeout() int64

SendTimeout implements Socket.SendTimeout.

func (*SendReceiveTimeout) SetRecvTimeout 

func (to *SendReceiveTimeout) SetRecvTimeout(nanoseconds int64)

SetRecvTimeout implements Socket.SetRecvTimeout.

func (*SendReceiveTimeout) SetSendTimeout 

func (to *SendReceiveTimeout) SetSendTimeout(nanoseconds int64)

SetSendTimeout implements Socket.SetSendTimeout.

type Socket 

type Socket interface {
	vfs.FileDescriptionImpl

	// Connect implements the connect(2) linux unix.
	Connect(t *kernel.Task, sockaddr []byte, blocking bool) *syserr.Error

	// Accept implements the accept4(2) linux unix.
	// Returns fd, real peer address length and error. Real peer address
	// length is only set if len(peer) > 0.
	Accept(t *kernel.Task, peerRequested bool, flags int, blocking bool) (int32, linux.SockAddr, uint32, *syserr.Error)

	// Bind implements the bind(2) linux unix.
	Bind(t *kernel.Task, sockaddr []byte) *syserr.Error

	// Listen implements the listen(2) linux unix.
	Listen(t *kernel.Task, backlog int) *syserr.Error

	// Shutdown implements the shutdown(2) linux unix.
	Shutdown(t *kernel.Task, how int) *syserr.Error

	// GetSockOpt implements the getsockopt(2) linux unix.
	GetSockOpt(t *kernel.Task, level int, name int, outPtr hostarch.Addr, outLen int) (marshal.Marshallable, *syserr.Error)

	// SetSockOpt implements the setsockopt(2) linux unix.
	SetSockOpt(t *kernel.Task, level int, name int, opt []byte) *syserr.Error

	// GetSockName implements the getsockname(2) linux unix.
	//
	// addrLen is the address length to be returned to the application, not
	// necessarily the actual length of the address.
	GetSockName(t *kernel.Task) (addr linux.SockAddr, addrLen uint32, err *syserr.Error)

	// GetPeerName implements the getpeername(2) linux unix.
	//
	// addrLen is the address length to be returned to the application, not
	// necessarily the actual length of the address.
	GetPeerName(t *kernel.Task) (addr linux.SockAddr, addrLen uint32, err *syserr.Error)

	// RecvMsg implements the recvmsg(2) linux unix.
	//
	// senderAddrLen is the address length to be returned to the application,
	// not necessarily the actual length of the address.
	//
	// flags control how RecvMsg should be completed. msgFlags indicate how
	// the RecvMsg call was completed. Note that control message truncation
	// may still be required even if the MSG_CTRUNC bit is not set in
	// msgFlags. In that case, the caller should set MSG_CTRUNC appropriately.
	//
	// If err != nil, the recv was not successful.
	RecvMsg(t *kernel.Task, dst usermem.IOSequence, flags int, haveDeadline bool, deadline ktime.Time, senderRequested bool, controlDataLen uint64) (n int, msgFlags int, senderAddr linux.SockAddr, senderAddrLen uint32, controlMessages ControlMessages, err *syserr.Error)

	// SendMsg implements the sendmsg(2) linux unix. SendMsg does not take
	// ownership of the ControlMessage on error.
	//
	// If n > 0, err will either be nil or an error from t.Block.
	SendMsg(t *kernel.Task, src usermem.IOSequence, to []byte, flags int, haveDeadline bool, deadline ktime.Time, controlMessages ControlMessages) (n int, err *syserr.Error)

	// SetRecvTimeout sets the timeout (in ns) for recv operations. Zero means
	// no timeout, and negative means DONTWAIT.
	SetRecvTimeout(nanoseconds int64)

	// RecvTimeout gets the current timeout (in ns) for recv operations. Zero
	// means no timeout, and negative means DONTWAIT.
	RecvTimeout() int64

	// SetSendTimeout sets the timeout (in ns) for send operations. Zero means
	// no timeout, and negative means DONTWAIT.
	SetSendTimeout(nanoseconds int64)

	// SendTimeout gets the current timeout (in ns) for send operations. Zero
	// means no timeout, and negative means DONTWAIT.
	SendTimeout() int64

	// State returns the current state of the socket, as represented by Linux in
	// procfs. The returned state value is protocol-specific.
	State() uint32

	// Type returns the family, socket type and protocol of the socket.
	Type() (family int, skType linux.SockType, protocol int)
}

Socket is an interface containing socket syscalls used by the syscall layer to redirect them to the appropriate implementation.

Source Files

View all Source files

Directories

Path Synopsis
Package control provides internal representations of socket control messages.
 Package control provides internal representations of socket control messages.
Package hostinet implements AF_INET and AF_INET6 sockets using the host's network stack.
 Package hostinet implements AF_INET and AF_INET6 sockets using the host's network stack.
Package netfilter helps the sentry interact with netstack's netfilter capabilities.
 Package netfilter helps the sentry interact with netstack's netfilter capabilities.
Package netlink provides core functionality for netlink sockets.
 Package netlink provides core functionality for netlink sockets.
nlmsg
Package nlmsg provides helpers to parse and construct netlink messages.
 Package nlmsg provides helpers to parse and construct netlink messages.
port
Package port provides port ID allocation for netlink sockets.
 Package port provides port ID allocation for netlink sockets.
route
Package route provides a NETLINK_ROUTE socket protocol.
 Package route provides a NETLINK_ROUTE socket protocol.
uevent
Package uevent provides a NETLINK_KOBJECT_UEVENT socket protocol.
 Package uevent provides a NETLINK_KOBJECT_UEVENT socket protocol.
Package netstack provides an implementation of the socket.Socket interface that is backed by a tcpip.Endpoint.
 Package netstack provides an implementation of the socket.Socket interface that is backed by a tcpip.Endpoint.
Package plugin provides a set of interfaces to interact with third-party netstack.
 Package plugin provides a set of interfaces to interact with third-party netstack.
cgo
Package cgo provides interfaces definition to interact with third-party network stack.
 Package cgo provides interfaces definition to interact with third-party network stack.
stack
Package stack provides an implementation of plugin.PluginStack interface and an implementation of socket.Socket interface.
 Package stack provides an implementation of plugin.PluginStack interface and an implementation of socket.Socket interface.
Package unix provides an implementation of the socket.Socket interface for the AF_UNIX protocol family.
 Package unix provides an implementation of the socket.Socket interface for the AF_UNIX protocol family.
transport
Package transport contains the implementation of Unix endpoints.
 Package transport contains the implementation of Unix endpoints.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.