netapi

type Accepter interface{ Server }

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
	// not fqdn must impl [IPAddress]
	IsFqdn() bool
	net.Addr
}

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

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

	context.Context

	DomainString string `metrics:"DOMAIN"`
	IPString     string `metrics:"IP"`
	Tag          string `metrics:"Tag"`
	Hash         string `metrics:"Hash"`

	// sniffy
	Protocol      string `metrics:"Protocol"`
	Process       string `metrics:"Process"`
	TLSServerName string `metrics:"TLS Servername"`
	HTTPHost      string `metrics:"HTTP Host"`

	// dns resolver
	Component string `metrics:"Component"`

	Resolver ContextResolver `metrics:"-"`

	UDPMigrateID uint64 `metrics:"UDP MigrateID"`

	ForceMode bypass.Mode `metrics:"-"`
	SniffMode bypass.Mode `metrics:"-"`
	Mode      bypass.Mode `metrics:"MODE"`
	SkipRoute bool        `metrics:"-"`
}

type ContextResolver struct {
	Resolver     Resolver
	ResolverSelf Resolver
	Mode         ResolverMode
	SkipResolve  bool `metrics:"-"`
	ForceFakeIP  bool `metrics:"-"`
}

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

type DNSServer interface {
	Server
	HandleUDP(context.Context, net.PacketConn) error
	HandleTCP(context.Context, net.Conn) error
	Do(context.Context, *DNSRawRequest) error
}

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

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

type EmptyDispatch struct{}

type ErrorResolver func(domain string) error

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

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

type IPAddress interface {
	Address
	IP() net.IP
	WithZone(zone string)
}

type Listener interface {
	PacketListener
	StreamListener
	Server
}

type LogConn struct {
	net.Conn
}

type LookupIPOption struct {
	Mode ResolverMode
}

type Packet struct {
	Src       net.Addr
	Dst       Address
	WriteBack WriteBack
	Payload   []byte
	MigrateID uint64
}

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

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

type PrefixBytesConn struct {
	net.Conn
	// contains filtered or unexported fields
}

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

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

type Resolver interface {
	LookupIP(ctx context.Context, domain string, opts ...func(*LookupIPOption)) ([]net.IP, error)
	Raw(ctx context.Context, req dnsmessage.Question) (dnsmessage.Message, error)
	io.Closer
}

type ResolverMode int

type Server interface {
	io.Closer
}

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

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

	Src     net.Conn
	Address Address
}

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

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

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