package proxy

Import Path
	golang.org/x/net/proxy (on go.dev)

Dependency Relation
	imports 8 packages, and imported by one package

Involved Source Files

	    dial.go
	    direct.go
	    per_host.go
	  d proxy.go
		Package proxy provides support for a variety of protocols to proxy network
		data.

	    socks5.go
Package-Level Type Names (total 6, in which 4 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Auth (struct)
		Auth contains authentication parameters that specific Dialers may require.

		Fields (total 2, both are exported)
			Password string
			User string
		As Inputs Of (at least one exported)
			func SOCKS5(network, address string, auth *Auth, forward Dialer) (Dialer, error)

	 type ContextDialer (interface)
		A ContextDialer dials using a context.

		Methods (only one, which is exported)
			( ContextDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)
		Implemented By (at least 7, in which 4 are exported)
			*PerHost
			*golang.org/x/net/internal/socks.Dialer
			*crypto/tls.Dialer
			*net.Dialer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 direct
			*net.sysDialer
			*net/http.socksDialer

	 type Dialer (interface)
		A Dialer is a means to establish a connection.
		Custom dialers should also implement ContextDialer.

		Methods (only one, which is exported)
			( Dialer) Dial(network, addr string) (c net.Conn, err error)
				Dial connects to the given address via the proxy.

		Implemented By (at least 7, in which 4 are exported)
			*PerHost
			*golang.org/x/net/internal/socks.Dialer
			*crypto/tls.Dialer
			*net.Dialer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 direct
			*net.sysDialer
			*net/http.socksDialer
		As Outputs Of (at least 5, in which 4 are exported)
			func FromEnvironment() Dialer
			func FromEnvironmentUsing(forward Dialer) Dialer
			func FromURL(u *url.URL, forward Dialer) (Dialer, error)
			func SOCKS5(network, address string, auth *Auth, forward Dialer) (Dialer, error)
			/* at least one unexported ... *//* at least one unexported: */
			func (*PerHost).dialerForRequest(host string) Dialer
		As Inputs Of (at least 5, in which 4 are exported)
			func FromEnvironmentUsing(forward Dialer) Dialer
			func FromURL(u *url.URL, forward Dialer) (Dialer, error)
			func NewPerHost(defaultDialer, bypass Dialer) *PerHost
			func SOCKS5(network, address string, auth *Auth, forward Dialer) (Dialer, error)
			/* at least one unexported ... *//* at least one unexported: */
			func dialContext(ctx context.Context, d Dialer, network, address string) (net.Conn, error)

	 type PerHost (struct)
		A PerHost directs connections to a default Dialer unless the host name
		requested matches one of a number of exceptions.

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			bypass Dialer
			bypassHosts []string
			bypassIPs []net.IP
			bypassNetworks []*net.IPNet
			bypassZones []string
			def Dialer
		Methods (total 8, in which 7 are exported)
			(*PerHost) AddFromString(s string)
				AddFromString parses a string that contains comma-separated values
				specifying hosts that should use the bypass proxy. Each value is either an
				IP address, a CIDR range, a zone (*.example.com) or a host name
				(localhost). A best effort is made to parse the string and errors are
				ignored.

			(*PerHost) AddHost(host string)
				AddHost specifies a host name that will use the bypass proxy.

			(*PerHost) AddIP(ip net.IP)
				AddIP specifies an IP address that will use the bypass proxy. Note that
				this will only take effect if a literal IP address is dialed. A connection
				to a named host will never match an IP.

			(*PerHost) AddNetwork(net *net.IPNet)
				AddNetwork specifies an IP range that will use the bypass proxy. Note that
				this will only take effect if a literal IP address is dialed. A connection
				to a named host will never match.

			(*PerHost) AddZone(zone string)
				AddZone specifies a DNS suffix that will use the bypass proxy. A zone of
				"example.com" matches "example.com" and all of its subdomains.

			(*PerHost) Dial(network, addr string) (c net.Conn, err error)
				Dial connects to the address addr on the given network through either
				defaultDialer or bypass.

			(*PerHost) DialContext(ctx context.Context, network, addr string) (c net.Conn, err error)
				DialContext connects to the address addr on the given network through either
				defaultDialer or bypass.

			/* one unexported ... *//* one unexported: */
			(*PerHost) dialerForRequest(host string) Dialer
		Implements (at least 2, both are exported)
			*PerHost : ContextDialer
			*PerHost : Dialer
		As Outputs Of (at least one exported)
			func NewPerHost(defaultDialer, bypass Dialer) *PerHost

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type direct (struct)

		Methods (total 2, both are exported)
			( direct) Dial(network, addr string) (net.Conn, error)
				Dial directly invokes net.Dial with the supplied parameters.

			( direct) DialContext(ctx context.Context, network, addr string) (net.Conn, error)
				DialContext instantiates a net.Dialer and invokes its DialContext receiver with the supplied parameters.

		Implements (at least 2, both are exported)
			 direct : ContextDialer
			 direct : Dialer
		As Types Of (only one, which is exported)
			  var Direct

	 type envOnce (struct)
		envOnce looks up an environment variable (optionally by multiple
		names) once. It mitigates expensive lookups on some platforms
		(e.g. Windows).
		(Borrowed from net/http/transport.go)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			names []string
			once sync.Once
			val string
		Methods (total 3, in which 1 is exported)
			(*envOnce) Get() string
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*envOnce) init()
			(*envOnce) reset()
				reset is used by tests

		As Types Of (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			  var allProxyEnv *envOnce
			  var noProxyEnv *envOnce


Package-Level Functions (total 8, in which 7 are exported)

	 func Dial(ctx context.Context, network, address string) (net.Conn, error)
		Dial works like DialContext on net.Dialer but using a dialer returned by FromEnvironment.
		
		The passed ctx is only used for returning the Conn, not the lifetime of the Conn.
		
		Custom dialers (registered via RegisterDialerType) that do not implement ContextDialer
		can leak a goroutine for as long as it takes the underlying Dialer implementation to timeout.
		
		A Conn returned from a successful Dial after the context has been cancelled will be immediately closed.

	 func FromEnvironment() Dialer
		FromEnvironment returns the dialer specified by the proxy-related
		variables in the environment and makes underlying connections
		directly.

	 func FromEnvironmentUsing(forward Dialer) Dialer
		FromEnvironmentUsing returns the dialer specify by the proxy-related
		variables in the environment and makes underlying connections
		using the provided forwarding Dialer (for instance, a *net.Dialer
		with desired configuration).

	 func FromURL(u *url.URL, forward Dialer) (Dialer, error)
		FromURL returns a Dialer given a URL specification and an underlying
		Dialer for it to make network requests.

	 func NewPerHost(defaultDialer, bypass Dialer) *PerHost
		NewPerHost returns a PerHost Dialer that directs connections to either
		defaultDialer or bypass, depending on whether the connection matches one of
		the configured rules.

	 func RegisterDialerType(scheme string, f func(*url.URL, Dialer) (Dialer, error))
		RegisterDialerType takes a URL scheme and a function to generate Dialers from
		a URL with that scheme and a forwarding Dialer. Registered schemes are used
		by FromURL.

	 func SOCKS5(network, address string, auth *Auth, forward Dialer) (Dialer, error)
		SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given
		address with an optional username and password.
		See RFC 1928 and RFC 1929.

	/* one unexported ... *//* one unexported: */
	 func dialContext(ctx context.Context, d Dialer, network, address string) (net.Conn, error)
		WARNING: this can leak a goroutine for as long as the underlying Dialer implementation takes to timeout
		A Conn returned from a successful Dial after the context has been cancelled will be immediately closed.


Package-Level Variables (total 4, in which 1 is exported)

	  var Direct direct
		Direct implements Dialer by making network connections directly using net.Dial or net.DialContext.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	  var allProxyEnv *envOnce
	  var noProxyEnv *envOnce
	  var proxySchemes map[string]func(*url.URL, Dialer) (Dialer, error)
		proxySchemes is a map from URL schemes to a function that creates a Dialer
		from a URL with such a scheme.

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.