constant

type AdapterType int

type AuthenticatorListener interface {
	SetAuthenticator([]auth.AuthUser)
}

type Chain []string

type Conn interface {
	net.Conn
	Connection
}

type ConnContext interface {
	PlainContext
	Metadata() *Metadata
	Conn() net.Conn
}

type Connection interface {
	Chains() Chain
	AppendToChains(adapter ProxyAdapter)
	SetChains(chains []string)
	String() string
}

type DNSAddrPort struct {
	netip.AddrPort
}

type DNSMode int

type DNSUrl struct {
	Network  string
	AddrPort DNSAddrPort
}

type DelayHistory struct {
	Time     time.Time `json:"time"`
	Delay    uint16    `json:"delay"`
	AvgDelay uint16    `json:"meanDelay"`
}

type EBpf interface {
	Start() error
	Close()
	Lookup(srcAddrPort netip.AddrPort) (socks5.Addr, error)
}

type Inbound inbound

type InboundType string

type Listener interface {
	RawAddress() string
	Address() string
	Close() error
}

type LogAddr struct {
	M        Metadata
	Src      bool
	HostOnly bool
}

type LogRule struct {
	R Rule
}

type Matcher interface {
	Name() string
	Eval(metadata *Metadata) (string, error)
	Match(metadata *Metadata) (bool, error)
}

type Metadata struct {
	NetWork      NetWork    `json:"network"`
	Type         Type       `json:"type"`
	SrcIP        netip.Addr `json:"sourceIP"`
	DstIP        netip.Addr `json:"destinationIP"`
	SrcPort      Port       `json:"sourcePort"`
	DstPort      Port       `json:"destinationPort"`
	Host         string     `json:"host"`
	DNSMode      DNSMode    `json:"dnsMode"`
	Process      string     `json:"process"`
	ProcessPath  string     `json:"processPath"`
	UserAgent    string     `json:"userAgent"`
	SpecialProxy string     `json:"specialProxy"`

	OriginDst netip.AddrPort `json:"-"`
}

type MitmOption struct {
	ApiHost string

	TLSConfig  *tls.Config
	CertConfig *cert.Config

	Handler RewriteHandler
}

type MitmSession struct {
	Conn     net.Conn
	Request  *http.Request
	Response *http.Response
	// contains filtered or unexported fields
}

type NetWork int

type PacketConn interface {
	net.PacketConn
	Connection
}

type PacketConnContext interface {
	PlainContext
	Metadata() *Metadata
	PacketConn() net.PacketConn
}

type PlainContext interface {
	ID() uuid.UUID
}

type Port uint16

type Proxy interface {
	ProxyAdapter
	Alive() bool
	HasV6() bool
	DelayHistory() []DelayHistory
	LastDelay() uint16
	URLTest(ctx context.Context, url string) (uint16, uint16, error)
}

type ProxyAdapter interface {
	Name() string
	Type() AdapterType
	Addr() string
	SupportUDP() bool
	DisableDnsResolve() bool
	MarshalJSON() ([]byte, error)

	// StreamConn wraps a protocol around net.Conn with Metadata.
	//
	// Examples:
	//	conn, _ := net.DialContext(context.Background(), "tcp", "host:port")
	//	conn, _ = adapter.StreamConn(conn, metadata)
	//
	// It returns a C.Conn with protocol which start with
	// a new session (if any)
	StreamConn(c net.Conn, metadata *Metadata) (net.Conn, error)

	// StreamPacketConn wraps a UDP protocol around net.Conn with Metadata.
	StreamPacketConn(c net.Conn, metadata *Metadata) (net.Conn, error)

	// DialContext return a C.Conn with protocol which
	// contains multiplexing-related reuse logic (if any)
	DialContext(ctx context.Context, metadata *Metadata, opts ...dialer.Option) (Conn, error)

	// ListenPacketContext listen for a PacketConn
	ListenPacketContext(ctx context.Context, metadata *Metadata, opts ...dialer.Option) (PacketConn, error)

	// Unwrap extracts the proxy from a proxy-group. It returns nil when nothing to extract.
	Unwrap(metadata *Metadata) Proxy

	// Cleanup released resources.
	Cleanup()
}

type RawProxy struct {
	Name     string         `yaml:"name"`
	Type     string         `yaml:"type"`
	Server   string         `yaml:"server"`
	UUID     string         `yaml:"uuid,omitempty"`
	Password string         `yaml:"password,omitempty"`
	M        map[string]any `yaml:",inline"`
}

type Rewrite interface {
	URLRegx() *regexp.Regexp
	RuleType() RewriteType
	RuleRegx() []*regexp.Regexp
	RulePayload() []string
	ReplaceURLPayload([]string) string
	ReplaceSubPayload(string) (string, bool)
}

type RewriteHandler interface {
	HandleRequest(*MitmSession) (*http.Request, *http.Response) // session.Response maybe nil
	HandleResponse(*MitmSession) *http.Response
	HandleApiRequest(*MitmSession) bool
	HandleError(*MitmSession, error) // session maybe nil
}

type RewriteRule interface {
	SearchInRequest(func(Rewrite) bool) bool
	SearchInResponse(func(Rewrite) bool) bool
}

type RewriteType int

type Rule interface {
	RuleType() RuleType
	Match(metadata *Metadata) bool
	Adapter() string
	Payload() string
	ShouldResolveIP() bool
	RuleExtra() *RuleExtra
	SetRuleExtra(re *RuleExtra)
	ShouldFindProcess() bool
	SubRules() []Rule
	RuleGroups() RuleGroup
	AppendGroup(group string)
}

type RuleExtra struct {
	Network      NetWork
	SourceIPs    []*netip.Prefix
	ProcessNames []string
}

type RuleGeoSite interface {
	GetDomainMatcher() *router.DomainMatcher
}

type RuleGroup []string

type RuleType int

type TUNChangeCallback interface {
	Pause()
	Resume()
}

type TUNStack int

type TUNState int

type Tun struct {
	Enable              bool          `yaml:"enable" json:"enable"`
	Device              string        `yaml:"device" json:"device"`
	Stack               TUNStack      `yaml:"stack" json:"stack"`
	DNSHijack           []DNSUrl      `yaml:"dns-hijack" json:"dns-hijack"`
	AutoRoute           bool          `yaml:"auto-route" json:"auto-route"`
	AutoDetectInterface bool          `yaml:"auto-detect-interface" json:"auto-detect-interface"`
	TunAddressPrefix    *netip.Prefix `yaml:"-" json:"-"`
	RedirectToTun       []string      `yaml:"-" json:"-"`
	StopRouteListener   bool          `yaml:"-" json:"-"`
}

type Type int

type UDPPacket interface {
	// Data get the payload of UDP Packet
	Data() *[]byte

	// WriteBack writes the payload with source IP/Port equals addr
	// - variable source IP/Port is important to STUN
	// - if addr is not provided, WriteBack will write out UDP packet with SourceIP/Port equals to original Target,
	//   this is important when using Fake-IP.
	WriteBack(b []byte, addr net.Addr) (n int, err error)

	// Drop call after packet is used, could recycle buffer in this function.
	Drop()

	// LocalAddr returns the source IP/Port of packet
	LocalAddr() net.Addr
}