netapi

type Accepter interface{ Server }

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

type Address interface {
	// Hostname return hostname of address, eg: www.example.com, 127.0.0.1, ff::ff
	Hostname() string
	// Port return port of address
	Port() uint16
	// IsFqdn return true if address is FQDN
	// fqdn must impl [DomainAddress]
	// otherwise must impl [IPAddress]
	IsFqdn() bool
	// Comparable return hash of address, compute by [ComputeAddressHash]
	Comparable() uint64
	net.Addr
}

type AddressNetwork byte

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

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

type Context struct {
	Source      net.Addr `metrics:"Source"`
	Destination net.Addr `metrics:"Destination"`

	context.Context

	Hash     string `metrics:"Hash"`
	NodeName string `metrics:"NodeName"`

	ModeReason string `metrics:"MODE Reason"`

	Resolver ContextResolver `metrics:"-"`

	ForceMode bypass.Mode `metrics:"-"`
	SniffMode bypass.Mode `metrics:"-"`
	Mode      bypass.Mode `metrics:"MODE"`

	SystemDialer bool `metrics:"-"`
	// contains filtered or unexported fields
}

type ContextResolver struct {
	Resolver Resolver

	Mode        ResolverMode
	SkipResolve bool `metrics:"-"`
	// contains filtered or unexported fields
}

type DNSRawRequest struct {
	WriteBack   func([]byte) error
	Question    *Packet
	Stream      bool
	ForceFakeIP bool
}

type DNSServer interface {
	Server
	DoStream(context.Context, *DNSStreamRequest) error
	Do(context.Context, *DNSRawRequest) error
}

type DNSStreamRequest struct {
	Conn        net.Conn
	ForceFakeIP bool
}

type DialError struct {

	// Addr is the network address for which this error occurred.
	// For local operations, like Listen or SetDeadline, Addr is
	// the address of the local endpoint being manipulated.
	// For operations involving a remote network connection, like
	// Dial, Read, or Write, Addr is the remote address of that
	// connection.
	Addr net.Addr

	// Err is the error that occurred during the operation.
	// The Error method panics if the error is nil.
	Err error
	// Op is the operation which caused the error, such as
	// "read" or "write".
	Op string

	// Net is the network type on which this error occurred,
	// such as "tcp" or "udp6".
	Net string

	Sniff string
}

type DomainAddr struct {
	HostnameX      string `json:"hostname,omitempty"`
	AddressNetwork `json:"network,omitempty"`
	PortX          uint16 `json:"port,omitempty"`
}

type DomainAddress interface{ Address }

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

type EmptyDispatch struct{}

type ErrorResolver func(domain string) error

type ForceFakeIPKey struct{}

type Handler interface {
	HandleStream(*StreamMeta)
	HandlePacket(*Packet)
}

type IPAddr struct {
	AddrPortX      netip.AddrPort `json:"addr_port"`
	AddressNetwork `json:"network,omitempty"`
}

type IPAddress interface {
	Address
	AddrPort() netip.AddrPort
}

type IPs struct {
	AAAA []net.IP
	A    []net.IP
}

type Listener interface {
	PacketListener
	StreamListener
	Server
}

type LogConn struct {
	net.Conn
}

type LookupIPOption struct {
	Mode ResolverMode
}

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

type Packet struct {
	Src       net.Addr
	Dst       Address
	WriteBack WriteBack
	// Payload will set to nil when ref count is negative, get it by [Packet.GetPayload]
	// ! DON'T use Payload directly
	Payload     []byte
	MigrateID   uint64
	InboundName string
	// contains filtered or unexported fields
}

type PacketListener interface {
	Server
	Packet(context.Context) (net.PacketConn, error)
}

type PacketProxy interface {
	PacketConn(context.Context, Address) (net.PacketConn, error)
}

type PacketSniffer interface {
	Packet(*Context, []byte)
}

type Process struct {
	Path string
	Pid  uint
	Uid  uint
}

type ProcessDumper interface {
	ProcessName(network string, src, dst Address) (Process, error)
}

type Proxy interface {
	StreamProxy
	PacketProxy
	Dispatch(context.Context, Address) (Address, error)
	io.Closer
}

type Resolver interface {
	// LookupIP returns a list of ip addresses
	LookupIP(ctx context.Context, domain string, opts ...func(*LookupIPOption)) (*IPs, error)
	// Raw returns a dns message
	//
	// ! The returned message may be cached, so it should not be modified
	// ! Please clone the message if you need to modify it
	Raw(ctx context.Context, req dnsmessage.Question) (dnsmessage.Message, error)
	io.Closer
}

type ResolverMode int

type Server interface {
	io.Closer
}

type SkipRouteKey struct{}

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

type StreamListener interface {
	Server
	Stream(context.Context) (net.Listener, error)
}

type StreamMeta struct {
	Source      net.Addr
	Destination net.Addr
	Inbound     net.Addr
	InboundName string

	Src     net.Conn
	Address Address
}

type StreamProxy interface {
	Conn(context.Context, Address) (net.Conn, error)
}

type WriteBack interface {
	WriteBack(b []byte, addr net.Addr) (int, error)
}

type WriteBackFunc func(b []byte, addr net.Addr) (int, error)