package vnet

Import Path
	github.com/pion/transport/v3/vnet (on go.dev)

Dependency Relation
	imports 15 packages, and imported by one package

Involved Source Files

	    chunk.go
	    chunk_queue.go
	    conn.go
	    conn_map.go
	    delay_filter.go
	    errors.go
	    loss_filter.go
	    nat.go
	    net.go
	    resolver.go
	    router.go
	    tbf.go
	    udpproxy.go
	    udpproxy_direct.go
	  d vnet.go
		Package vnet provides a virtual network layer for pion
Package-Level Type Names (total 16)

	/* sort by: alphabet | popularity */
	 type Chunk (interface)
		Chunk represents a packet passed around in the vnet

		Methods (total 7)
			( Chunk) Clone() Chunk
			( Chunk) DestinationAddr() net.Addr
			( Chunk) Network() string
				// returns "udp" or "tcp"

			( Chunk) SourceAddr() net.Addr
			( Chunk) String() string
			( Chunk) Tag() string
			( Chunk) UserData() []byte
		Implements (at least 3)
			 Chunk : expvar.Var
			 Chunk : fmt.Stringer
			 Chunk : net.Addr
		As Outputs Of (at least one exported)
			func Chunk.Clone() Chunk

	 type ChunkFilter (func)
		ChunkFilter is a handler users can add to filter chunks.
		If the filter returns false, the packet will be dropped.

		As Inputs Of (at least one exported)
			func (*Router).AddChunkFilter(filter ChunkFilter)

	 type DelayFilter (struct)
		DelayFilter delays outgoing packets by the given delay. Run must be called
		before any packets will be forwarded.

		Fields (only one)
			NIC NIC
		Methods (only one)
			(*DelayFilter) Run(ctx context.Context)
				Run starts forwarding of packets. Packets will be forwarded if they spent
				>delay time in the internal queue. Must be called before any packet will be
				forwarded.

		Implements (at least one exported)
			*DelayFilter : NIC
		As Outputs Of (at least one exported)
			func NewDelayFilter(nic NIC, delay time.Duration) (*DelayFilter, error)

	 type EndpointDependencyType uint8 (basic type)
		EndpointDependencyType defines a type of behavioral dependendency on the
		remote endpoint's IP address or port number. This is used for the two
		kinds of behaviors:
		  - Port mapping behavior
		  - Filtering behavior
		
		See: https://tools.ietf.org/html/rfc4787

		As Types Of (total 3)
			const EndpointAddrDependent
			const EndpointAddrPortDependent
			const EndpointIndependent

	 type LossFilter (struct)
		LossFilter is a wrapper around NICs, that drops some of the packets passed to
		onInboundChunk

		Fields (only one)
			NIC NIC
		Implements (at least one exported)
			*LossFilter : NIC
		As Outputs Of (at least one exported)
			func NewLossFilter(nic NIC, chance int) (*LossFilter, error)

	 type NATMode uint8 (basic type)
		NATMode defines basic behavior of the NAT

		As Types Of (total 2)
			const NATModeNAT1To1
			const NATModeNormal

	 type NATType (struct)
		NATType has a set of parameters that define the behavior of NAT.

		Fields (total 6)
			FilteringBehavior EndpointDependencyType
			Hairpinning bool
				// Not implemented yet

			MappingBehavior EndpointDependencyType
			MappingLifeTime time.Duration
			Mode NATMode
			PortPreservation bool
				// Not implemented yet


	 type Net (struct)
		Net represents a local network stack equivalent to a set of layers from NIC
		up to the transport (UDP / TCP) layer.

		Methods (total 13)
			(*Net) CreateDialer(d *net.Dialer) transport.Dialer
				CreateDialer creates an instance of vnet.Dialer

			(*Net) Dial(network string, address string) (net.Conn, error)
				Dial connects to the address on the named network.

			(*Net) DialTCP(string, *net.TCPAddr, *net.TCPAddr) (transport.TCPConn, error)
				DialTCP acts like Dial for TCP networks.

			(*Net) DialUDP(network string, locAddr, remAddr *net.UDPAddr) (transport.UDPConn, error)
				DialUDP acts like Dial for UDP networks.

			(*Net) InterfaceByIndex(index int) (*transport.Interface, error)
				InterfaceByIndex returns the interface specified by index.
				
				On Solaris, it returns one of the logical network interfaces
				sharing the logical data link; for more precision use
				InterfaceByName.

			(*Net) InterfaceByName(ifName string) (*transport.Interface, error)
				InterfaceByName returns the interface specified by name.

			(*Net) Interfaces() ([]*transport.Interface, error)
				Interfaces returns a list of the system's network interfaces.

			(*Net) ListenPacket(network string, address string) (net.PacketConn, error)
				ListenPacket announces on the local network address.

			(*Net) ListenTCP(string, *net.TCPAddr) (transport.TCPListener, error)
				ListenTCP acts like Listen for TCP networks.

			(*Net) ListenUDP(network string, locAddr *net.UDPAddr) (transport.UDPConn, error)
				ListenUDP acts like ListenPacket for UDP networks.

			(*Net) ResolveIPAddr(_, address string) (*net.IPAddr, error)
				ResolveIPAddr returns an address of IP end point.

			(*Net) ResolveTCPAddr(network, address string) (*net.TCPAddr, error)
				ResolveTCPAddr returns an address of TCP end point.

			(*Net) ResolveUDPAddr(network, address string) (*net.UDPAddr, error)
				ResolveUDPAddr returns an address of UDP end point.

		Implements (at least 6)
			*Net : NIC
			*Net : github.com/pion/transport/v3.Dialer
			*Net : github.com/pion/transport/v3.Net
			*Net : github.com/pion/transport/v2.Dialer
			*Net : github.com/nats-io/nats.go.CustomDialer
			*Net : golang.org/x/net/proxy.Dialer
		As Outputs Of (at least one exported)
			func NewNet(config *NetConfig) (*Net, error)
		As Inputs Of (at least one exported)
			func (*UDPProxy).Proxy(client *Net, server *net.UDPAddr) error

	 type NetConfig (struct)
		NetConfig is a bag of configuration parameters passed to NewNet().

		Fields (total 2)
			StaticIP string
				StaticIP is deprecated. Use StaticIPs.

			StaticIPs []string
				StaticIPs is an array of static IP addresses to be assigned for this Net.
				If no static IP address is given, the router will automatically assign
				an IP address.

		As Inputs Of (at least one exported)
			func NewNet(config *NetConfig) (*Net, error)

	 type NIC (interface)
		NIC is a network interface controller that interfaces Router

		Implemented By (at least 5)
			*DelayFilter
			*LossFilter
			*Net
			*Router
			*TokenBucketFilter
		As Inputs Of (at least 4)
			func NewDelayFilter(nic NIC, delay time.Duration) (*DelayFilter, error)
			func NewLossFilter(nic NIC, chance int) (*LossFilter, error)
			func NewTokenBucketFilter(n NIC, opts ...TBFOption) (*TokenBucketFilter, error)
			func (*Router).AddNet(nic NIC) error

	 type Router (struct)
		Router ...

		Methods (total 7)
			(*Router) AddChildRouter(router *Router) error
				AddChildRouter is like AddRouter, but does not add the child routers NIC to
				the parent. This has to be done manually by calling AddNet, which allows to
				use a wrapper around the subrouters NIC.
				AddNet MUST be called before AddChildRouter.

			(*Router) AddChunkFilter(filter ChunkFilter)
				AddChunkFilter adds a filter for chunks traversing this router.
				You may add more than one filter. The filters are called in the order of this method call.
				If a chunk is dropped by a filter, subsequent filter will not receive the chunk.

			(*Router) AddHost(hostName string, ipAddr string) error
				AddHost adds a mapping of hostname and an IP address to the local resolver.

			(*Router) AddNet(nic NIC) error
				AddNet ...

			(*Router) AddRouter(router *Router) error
				AddRouter adds a child Router.

			(*Router) Start() error
				Start ...

			(*Router) Stop() error
				Stop ...

		Implements (at least one exported)
			*Router : NIC
		As Outputs Of (at least one exported)
			func NewRouter(config *RouterConfig) (*Router, error)
		As Inputs Of (at least 3)
			func NewProxy(router *Router) (*UDPProxy, error)
			func (*Router).AddChildRouter(router *Router) error
			func (*Router).AddRouter(router *Router) error

	 type RouterConfig (struct)
		RouterConfig ...

		Fields (total 9)
			CIDR string
				CIDR notation, like "192.0.2.0/24"

			LoggerFactory logging.LoggerFactory
				Logger factory

			MaxJitter time.Duration
				Max Jitter

			MinDelay time.Duration
				Minimum Delay

			NATType *NATType
				Effective only when this router has a parent router

			Name string
				Name of router. If not specified, a unique name will be assigned.

			QueueSize int
				Internal queue size

			StaticIP string
				StaticIP is deprecated. Use StaticIPs.

			StaticIPs []string
				StaticIPs is an array of static IP addresses to be assigned for this router.
				If no static IP address is given, the router will automatically assign
				an IP address.
				This will be ignored if this router is the root.

		As Inputs Of (at least one exported)
			func NewRouter(config *RouterConfig) (*Router, error)

	 type TBFOption (func)
		TBFOption is the option type to configure a TokenBucketFilter

		As Outputs Of (at least 4)
			func TBFMaxBurst(size int) TBFOption
			func TBFQueueSizeInBytes(bytes int) TBFOption
			func TBFRate(rate int) TBFOption
			func (*TokenBucketFilter).Set(opts ...TBFOption) (previous TBFOption)
		As Inputs Of (at least 2)
			func NewTokenBucketFilter(n NIC, opts ...TBFOption) (*TokenBucketFilter, error)
			func (*TokenBucketFilter).Set(opts ...TBFOption) (previous TBFOption)

	 type TokenBucketFilter (struct)
		TokenBucketFilter implements a token bucket rate limit algorithm.

		Fields (only one)
			NIC NIC
		Methods (total 2)
			(*TokenBucketFilter) Close() error
				Close closes and stops the token bucket filter queue

			(*TokenBucketFilter) Set(opts ...TBFOption) (previous TBFOption)
				Set updates a setting on the token bucket filter

		Implements (at least 3)
			*TokenBucketFilter : NIC
			*TokenBucketFilter : github.com/prometheus/common/expfmt.Closer
			*TokenBucketFilter : io.Closer
		As Outputs Of (at least one exported)
			func NewTokenBucketFilter(n NIC, opts ...TBFOption) (*TokenBucketFilter, error)

	 type UDPConn (struct)
		UDPConn is the implementation of the Conn and PacketConn interfaces for UDP network connections.
		compatible with net.PacketConn and net.Conn

		Methods (total 16)
			(*UDPConn) Close() error
				Close closes the connection.
				Any blocked ReadFrom or WriteTo operations will be unblocked and return errors.

			(*UDPConn) LocalAddr() net.Addr
				LocalAddr returns the local network address.

			(*UDPConn) Read(b []byte) (int, error)
				Read reads data from the connection.
				Read can be made to time out and return an Error with Timeout() == true
				after a fixed time limit; see SetDeadline and SetReadDeadline.

			(*UDPConn) ReadFrom(p []byte) (n int, addr net.Addr, err error)
				ReadFrom reads a packet from the connection,
				copying the payload into p. It returns the number of
				bytes copied into p and the return address that
				was on the packet.
				It returns the number of bytes read (0 <= n <= len(p))
				and any error encountered. Callers should always process
				the n > 0 bytes returned before considering the error err.
				ReadFrom can be made to time out and return
				an Error with Timeout() == true after a fixed time limit;
				see SetDeadline and SetReadDeadline.

			(*UDPConn) ReadFromUDP(b []byte) (int, *net.UDPAddr, error)
				ReadFromUDP acts like ReadFrom but returns a UDPAddr.

			(*UDPConn) ReadMsgUDP([]byte, []byte) (n, oobn, flags int, addr *net.UDPAddr, err error)
				ReadMsgUDP reads a message from c, copying the payload into b and
				the associated out-of-band data into oob. It returns the number of
				bytes copied into b, the number of bytes copied into oob, the flags
				that were set on the message and the source address of the message.
				
				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*UDPConn) RemoteAddr() net.Addr
				RemoteAddr returns the remote network address.

			(*UDPConn) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines associated
				with the connection. It is equivalent to calling both
				SetReadDeadline and SetWriteDeadline.
				
				A deadline is an absolute time after which I/O operations
				fail with a timeout (see type Error) instead of
				blocking. The deadline applies to all future and pending
				I/O, not just the immediately following call to ReadFrom or
				WriteTo. After a deadline has been exceeded, the connection
				can be refreshed by setting a deadline in the future.
				
				An idle timeout can be implemented by repeatedly extending
				the deadline after successful ReadFrom or WriteTo calls.
				
				A zero value for t means I/O operations will not time out.

			(*UDPConn) SetReadBuffer(int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*UDPConn) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the deadline for future ReadFrom calls
				and any currently-blocked ReadFrom call.
				A zero value for t means ReadFrom will not time out.

			(*UDPConn) SetWriteBuffer(int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*UDPConn) SetWriteDeadline(time.Time) error
				SetWriteDeadline sets the deadline for future WriteTo calls
				and any currently-blocked WriteTo call.
				Even if write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means WriteTo will not time out.

			(*UDPConn) Write(b []byte) (int, error)
				Write writes data to the connection.
				Write can be made to time out and return an Error with Timeout() == true
				after a fixed time limit; see SetDeadline and SetWriteDeadline.

			(*UDPConn) WriteMsgUDP([]byte, []byte, *net.UDPAddr) (n, oobn int, err error)
				WriteMsgUDP writes a message to addr via c if c isn't connected, or
				to c's remote address if c is connected (in which case addr must be
				nil). The payload is copied from b and the associated out-of-band
				data is copied from oob. It returns the number of payload and
				out-of-band bytes written.
				
				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*UDPConn) WriteTo(p []byte, addr net.Addr) (n int, err error)
				WriteTo writes a packet with payload p to addr.
				WriteTo can be made to time out and return
				an Error with Timeout() == true after a fixed time limit;
				see SetDeadline and SetWriteDeadline.
				On packet-oriented connections, write timeouts are rare.

			(*UDPConn) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error)
				WriteToUDP acts like WriteTo but takes a UDPAddr.

		Implements (at least 18)
			*UDPConn : github.com/pion/transport/v3.UDPConn
			*UDPConn : github.com/pion/transport/v2.UDPConn
			*UDPConn : github.com/pion/datachannel.ReadDeadliner
			*UDPConn : github.com/pion/datachannel.WriteDeadliner
			*UDPConn : github.com/pion/stun.Connection
			*UDPConn : github.com/pion/stun/v3.Connection
			*UDPConn : github.com/miekg/dns.Writer
			*UDPConn : github.com/prometheus/common/expfmt.Closer
			*UDPConn : internal/bisect.Writer
			*UDPConn : io.Closer
			*UDPConn : io.ReadCloser
			*UDPConn : io.Reader
			*UDPConn : io.ReadWriteCloser
			*UDPConn : io.ReadWriter
			*UDPConn : io.WriteCloser
			*UDPConn : io.Writer
			*UDPConn : net.Conn
			*UDPConn : net.PacketConn

	 type UDPProxy (struct)
		UDPProxy is a proxy between real server(net.UDPConn) and vnet.UDPConn.
		
		High level design:
		
			                        ..............................................
			                        :         Virtual Network (vnet)             :
			                        :                                            :
			+-------+ *         1 +----+         +--------+                      :
			| :App  |------------>|:Net|--o<-----|:Router |          .............................
			+-------+             +----+         |        |          :        UDPProxy           :
			                        :            |        |       +----+     +---------+     +---------+     +--------+
			                        :            |        |--->o--|:Net|-->o-| vnet.   |-->o-|  net.   |--->-| :Real  |
			                        :            |        |       +----+     | UDPConn |     | UDPConn |     | Server |
			                        :            |        |          :       +---------+     +---------+     +--------+
			                        :            |        |          ............................:
			                        :            +--------+                       :
			                        ...............................................

		Methods (total 3)
			(*UDPProxy) Close() error
				Close the proxy, stop all workers.

			(*UDPProxy) Deliver(sourceAddr, destAddr net.Addr, b []byte) (nn int, err error)
				Deliver directly send packet to vnet or real-server.
				For example, we can use this API to simulate the REPLAY ATTACK.

			(*UDPProxy) Proxy(client *Net, server *net.UDPAddr) error
				Proxy starts a worker for server, ignore if already started.

		Implements (at least 2)
			*UDPProxy : github.com/prometheus/common/expfmt.Closer
			*UDPProxy : io.Closer
		As Outputs Of (at least one exported)
			func NewProxy(router *Router) (*UDPProxy, error)


Package-Level Functions (total 9)

	 func NewDelayFilter(nic NIC, delay time.Duration) (*DelayFilter, error)
		NewDelayFilter creates a new DelayFilter with the given nic and delay.

	 func NewLossFilter(nic NIC, chance int) (*LossFilter, error)
		NewLossFilter creates a new LossFilter that drops every packet with a
		probability of chance/100. Every packet that is not dropped is passed on to
		the given NIC.

	 func NewNet(config *NetConfig) (*Net, error)
		NewNet creates an instance of a virtual network.
		
		By design, it always have lo0 and eth0 interfaces.
		The lo0 has the address 127.0.0.1 assigned by default.
		IP address for eth0 will be assigned when this Net is added to a router.

	 func NewProxy(router *Router) (*UDPProxy, error)
		NewProxy create a proxy, the router for this proxy belongs/bind to. If need to proxy for
		please create a new proxy for each router. For all addresses we proxy, we will create a
		vnet.Net in this router and proxy all packets.

	 func NewRouter(config *RouterConfig) (*Router, error)
		NewRouter ...

	 func NewTokenBucketFilter(n NIC, opts ...TBFOption) (*TokenBucketFilter, error)
		NewTokenBucketFilter creates and starts a new TokenBucketFilter

	 func TBFMaxBurst(size int) TBFOption
		TBFMaxBurst sets the bucket size of the token bucket filter. This is the
		maximum size that can instantly leave the filter, if the bucket is full.

	 func TBFQueueSizeInBytes(bytes int) TBFOption
		TBFQueueSizeInBytes sets the max number of bytes waiting in the queue. Can
		only be set in constructor before using the TBF.

	 func TBFRate(rate int) TBFOption
		TBFRate sets the bit rate of a TokenBucketFilter


Package-Level Constants (total 8)

	const Bit = 1
		Bit is a single bit

	const EndpointAddrDependent EndpointDependencyType = 1
		EndpointAddrDependent means the behavior is dependent on the endpoint's address

	const EndpointAddrPortDependent EndpointDependencyType = 2
		EndpointAddrPortDependent means the behavior is dependent on the endpoint's address and port

	const EndpointIndependent EndpointDependencyType = 0
		EndpointIndependent means the behavior is independent of the endpoint's address or port

	const KBit = 1000
		KBit is a kilobit

	const MBit = 1000000
		MBit is a Megabit

	const NATModeNAT1To1 NATMode = 1
		NATModeNAT1To1 exhibits 1:1 DNAT where the external IP address is statically mapped to
		a specific local IP address with port number is preserved always between them.
		When this mode is selected, MappingBehavior, FilteringBehavior, PortPreservation and
		MappingLifeTime of NATType are ignored.

	const NATModeNormal NATMode = 0
		NATModeNormal means the NAT behaves as a standard NAPT (RFC 2663).

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.