forwarder

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

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

type DNSConfig struct {
	// Servers is a list of DNS servers to use, ex. udp://1.1.1.1:53.
	// Requirements:
	// - Known schemes: udp, tcp
	// - IP ONLY.
	// - Port in a valid range: 1 - 65535.
	Servers []*url.URL `json:"servers"`
	// Timeout is the timeout for DNS queries.
	Timeout time.Duration `json:"timeout"`
}

type HTTPProxy struct {
	TLSConfig *tls.Config
	Listener  net.Listener
	// contains filtered or unexported fields
}

type HTTPProxyConfig struct {
	HTTPServerConfig
	UpstreamProxy  *url.URL `json:"upstream_proxy_uri"`
	ProxyLocalhost bool     `json:"proxy_localhost"`
}

type HTTPServer struct {
	Listener net.Listener
	// contains filtered or unexported fields
}

type HTTPServerConfig struct {
	Protocol        Scheme        `json:"protocol"`
	Addr            string        `json:"addr"`
	CertFile        string        `json:"cert_file"`
	KeyFile         string        `json:"key_file"`
	ReadTimeout     time.Duration `json:"read_timeout"`
	LogHTTPRequests bool          `json:"log_http_requests"`

	PromNamespace string                `json:"prom_namespace"`
	PromRegistry  prometheus.Registerer `json:"prom_registry"`
	BasicAuth     *url.Userinfo         `json:"basic_auth"`
}

type HTTPTransportConfig struct {
	// DialTimeout is the maximum amount of time a dial will wait for
	// a 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 `json:"dial_timeout"`

	// KeepAlive specifies the interval between keep-alive
	// probes for an active network connection.
	// If zero, keep-alive probes are sent with a default value
	// (currently 15 seconds), if supported by the protocol and operating
	// system. Network protocols or operating systems that do
	// not support keep-alives ignore this field.
	// If negative, keep-alive probes are disabled.
	KeepAlive time.Duration `json:"keep_alive"`

	// TLSHandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration `json:"tls_handshake_timeout"`

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

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

	// 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 `json:"max_conns_per_host"`

	// 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 `json:"idle_conn_timeout"`

	// 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 `json:"response_header_timeout"`

	// 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 `json:"expect_continue_timeout"`

	TLSConfig
}

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

type Logger interface {
	Errorf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Debugf(format string, args ...interface{})
}

type LoggingPACResolver struct {
	Resolver PACResolver
	Logger   Logger
}

type PACResolver interface {
	FindProxyForURL(url *url.URL, hostname string) (string, error)
}

type Scheme string

type SelfSignedCert struct {
	Hosts        []string
	Organization []string
	ValidFrom    time.Time
	ValidFor     time.Duration
	IsCA         bool
	RsaBits      int
	EcdsaCurve   string
	Ed25519Key   bool
}

type TLSConfig struct {
	// 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 `json:"insecure_skip_verify"`
}