proxy.go

Documentation: golang.org/x/net/proxy

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package proxy provides support for a variety of protocols to proxy network
     6  // data.
     7  package proxy // import "golang.org/x/net/proxy"
     8  
     9  import (
    10  	"errors"
    11  	"net"
    12  	"net/url"
    13  	"os"
    14  	"sync"
    15  )
    16  
    17  // A Dialer is a means to establish a connection.
    18  // Custom dialers should also implement ContextDialer.
    19  type Dialer interface {
    20  	// Dial connects to the given address via the proxy.
    21  	Dial(network, addr string) (c net.Conn, err error)
    22  }
    23  
    24  // Auth contains authentication parameters that specific Dialers may require.
    25  type Auth struct {
    26  	User, Password string
    27  }
    28  
    29  // FromEnvironment returns the dialer specified by the proxy-related
    30  // variables in the environment and makes underlying connections
    31  // directly.
    32  func FromEnvironment() Dialer {
    33  	return FromEnvironmentUsing(Direct)
    34  }
    35  
    36  // FromEnvironmentUsing returns the dialer specify by the proxy-related
    37  // variables in the environment and makes underlying connections
    38  // using the provided forwarding Dialer (for instance, a *net.Dialer
    39  // with desired configuration).
    40  func FromEnvironmentUsing(forward Dialer) Dialer {
    41  	allProxy := allProxyEnv.Get()
    42  	if len(allProxy) == 0 {
    43  		return forward
    44  	}
    45  
    46  	proxyURL, err := url.Parse(allProxy)
    47  	if err != nil {
    48  		return forward
    49  	}
    50  	proxy, err := FromURL(proxyURL, forward)
    51  	if err != nil {
    52  		return forward
    53  	}
    54  
    55  	noProxy := noProxyEnv.Get()
    56  	if len(noProxy) == 0 {
    57  		return proxy
    58  	}
    59  
    60  	perHost := NewPerHost(proxy, forward)
    61  	perHost.AddFromString(noProxy)
    62  	return perHost
    63  }
    64  
    65  // proxySchemes is a map from URL schemes to a function that creates a Dialer
    66  // from a URL with such a scheme.
    67  var proxySchemes map[string]func(*url.URL, Dialer) (Dialer, error)
    68  
    69  // RegisterDialerType takes a URL scheme and a function to generate Dialers from
    70  // a URL with that scheme and a forwarding Dialer. Registered schemes are used
    71  // by FromURL.
    72  func RegisterDialerType(scheme string, f func(*url.URL, Dialer) (Dialer, error)) {
    73  	if proxySchemes == nil {
    74  		proxySchemes = make(map[string]func(*url.URL, Dialer) (Dialer, error))
    75  	}
    76  	proxySchemes[scheme] = f
    77  }
    78  
    79  // FromURL returns a Dialer given a URL specification and an underlying
    80  // Dialer for it to make network requests.
    81  func FromURL(u *url.URL, forward Dialer) (Dialer, error) {
    82  	var auth *Auth
    83  	if u.User != nil {
    84  		auth = new(Auth)
    85  		auth.User = u.User.Username()
    86  		if p, ok := u.User.Password(); ok {
    87  			auth.Password = p
    88  		}
    89  	}
    90  
    91  	switch u.Scheme {
    92  	case "socks5", "socks5h":
    93  		addr := u.Hostname()
    94  		port := u.Port()
    95  		if port == "" {
    96  			port = "1080"
    97  		}
    98  		return SOCKS5("tcp", net.JoinHostPort(addr, port), auth, forward)
    99  	}
   100  
   101  	// If the scheme doesn't match any of the built-in schemes, see if it
   102  	// was registered by another package.
   103  	if proxySchemes != nil {
   104  		if f, ok := proxySchemes[u.Scheme]; ok {
   105  			return f(u, forward)
   106  		}
   107  	}
   108  
   109  	return nil, errors.New("proxy: unknown scheme: " + u.Scheme)
   110  }
   111  
   112  var (
   113  	allProxyEnv = &envOnce{
   114  		names: []string{"ALL_PROXY", "all_proxy"},
   115  	}
   116  	noProxyEnv = &envOnce{
   117  		names: []string{"NO_PROXY", "no_proxy"},
   118  	}
   119  )
   120  
   121  // envOnce looks up an environment variable (optionally by multiple
   122  // names) once. It mitigates expensive lookups on some platforms
   123  // (e.g. Windows).
   124  // (Borrowed from net/http/transport.go)
   125  type envOnce struct {
   126  	names []string
   127  	once  sync.Once
   128  	val   string
   129  }
   130  
   131  func (e *envOnce) Get() string {
   132  	e.once.Do(e.init)
   133  	return e.val
   134  }
   135  
   136  func (e *envOnce) init() {
   137  	for _, n := range e.names {
   138  		e.val = os.Getenv(n)
   139  		if e.val != "" {
   140  			return
   141  		}
   142  	}
   143  }
   144  
   145  // reset is used by tests
   146  func (e *envOnce) reset() {
   147  	e.once = sync.Once{}
   148  	e.val = ""
   149  }
   150
View as plain text