forwarder

type APIEndpoint struct {
	Path    string
	Handler http.Handler
}

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

type ConnectFunc = martian.ConnectFunc

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

type DialConfig struct {
	// DialTimeout is the maximum amount of time a dial will wait for
	// connect to complete.
	//
	// With or without a timeout, the operating system may impose
	// its own earlier timeout. For instance, TCP timeouts are
	// often around 3 minutes.
	DialTimeout time.Duration

	// KeepAlive enables TCP keep-alive probes for an active network connection.
	// The keep-alive probes are sent with OS specific intervals.
	KeepAlive bool

	PromConfig
}

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

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

type HTTPProxyConfig struct {
	HTTPServerConfig
	Name                   string
	MITM                   *MITMConfig
	MITMDomains            Matcher
	ProxyLocalhost         ProxyLocalhostMode
	UpstreamProxy          *url.URL
	UpstreamProxyFunc      ProxyFunc
	DenyDomains            Matcher
	DirectDomains          Matcher
	RequestIDHeader        string
	RequestModifiers       []RequestModifier
	ResponseModifiers      []ResponseModifier
	ConnectRequestModifier func(*http.Request) error
	ConnectFunc            ConnectFunc
	ConnectTimeout         time.Duration
	ReadLimit              SizeSuffix
	WriteLimit             SizeSuffix

	// TestingHTTPHandler uses Martian's [http.Handler] implementation
	// over [http.Server] instead of the default TCP server.
	TestingHTTPHandler bool
}

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

type HTTPServerConfig struct {
	Protocol Scheme
	Addr     string
	TLSServerConfig
	IdleTimeout       time.Duration
	ReadTimeout       time.Duration
	ReadHeaderTimeout time.Duration
	WriteTimeout      time.Duration
	LogHTTPMode       httplog.Mode
	BasicAuth         *url.Userinfo
	PromConfig
}

type HTTPTransportConfig struct {
	DialConfig

	TLSClientConfig

	// MaxIdleConns controls the maximum number of idle (keep-alive)
	// connections across all hosts. Zero means no limit.
	MaxIdleConns int

	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
	// (keep-alive) connections to keep per-host. If zero,
	// DefaultMaxIdleConnsPerHost is used.
	MaxIdleConnsPerHost int

	// MaxConnsPerHost optionally limits the total number of
	// connections per host, including connections in the dialing,
	// active, and idle states. On limit violation, dials will block.
	//
	// Zero means no limit.
	MaxConnsPerHost int

	// IdleConnTimeout is the maximum amount of time an idle
	// (keep-alive) connection will remain idle before closing
	// itself.
	// Zero means no limit.
	IdleConnTimeout time.Duration

	// ResponseHeaderTimeout, if non-zero, specifies the amount of
	// time to wait for a server's response headers after fully
	// writing the request (including its body, if any). This
	// time does not include the time to read the response body.
	ResponseHeaderTimeout time.Duration

	// ExpectContinueTimeout, if non-zero, specifies the amount of
	// time to wait for a server's first response headers after fully
	// writing the request headers if the request has an
	// "Expect: 100-continue" header. Zero means no timeout and
	// causes the body to be sent immediately, without
	// waiting for the server to approve.
	// This time does not include the time to send the request header.
	ExpectContinueTimeout time.Duration
}

type HostPortUser struct {
	Host string
	Port string
	*url.Userinfo
}

type Listener struct {
	Address             string
	Log                 log.Logger
	TLSConfig           *tls.Config
	TLSHandshakeTimeout time.Duration
	ReadLimit           int64
	WriteLimit          int64
	PromConfig
	// contains filtered or unexported fields
}

type LoggingPACResolver struct {
	Resolver PACResolver
	Logger   log.Logger
}

type MITMConfig struct {
	CACertFile string
	CAKeyFile  string

	Organization string
	Validity     time.Duration
}

type MatchFunc func(string) bool

type Matcher interface {
	Match(string) bool
}

type PACResolver interface {
	// FindProxyForURL calls FindProxyForURL or FindProxyForURLEx function in the PAC script.
	// The hostname is optional, if empty it will be extracted from URL.
	FindProxyForURL(url *url.URL, hostname string) (string, error)
}

type PromConfig struct {
	PromNamespace string
	PromRegistry  prometheus.Registerer
}

type ProxyFunc func(*http.Request) (*url.URL, error)

type ProxyLocalhostMode string

type RequestModifier = martian.RequestModifier

type RequestModifierFunc = martian.RequestModifierFunc

type RequestResponseModifier = martian.RequestResponseModifier

type ResponseModifier = martian.ResponseModifier

type ResponseModifierFunc = martian.ResponseModifierFunc

type Scheme string

type SizeSuffix int64

type SizeSuffixList []SizeSuffix

type TLSClientConfig struct {
	// HandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	HandshakeTimeout time.Duration

	// InsecureSkipVerify controls whether a client verifies the server's
	// certificate chain and host name. If InsecureSkipVerify is true, crypto/tls
	// accepts any certificate presented by the server and any host name in that
	// certificate. In this mode, TLS is susceptible to machine-in-the-middle
	// attacks unless custom verification is used. This should be used only for
	// testing or in combination with VerifyConnection or VerifyPeerCertificate.
	InsecureSkipVerify bool

	// CACertFiles is a list of paths to CA certificate files.
	// If this is set, the system root CA pool will be supplemented with certificates from these files.
	CACertFiles []string
}

type TLSServerConfig struct {
	// HandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	HandshakeTimeout time.Duration

	// CertFile is the path to the TLS certificate.
	CertFile string

	// KeyFile is the path to the TLS private key of the certificate.
	KeyFile string
}

type TrackedConn struct {
	net.Conn

	// TrackTraffic enables counting of bytes read and written by the connection.
	// Use Rx and Tx to get the number of bytes read and written.
	TrackTraffic bool

	// OnClose is called after the underlying connection is closed and before the Close method returns.
	// OnClose is called at most once.
	OnClose func()
	// contains filtered or unexported fields
}