Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 dial.go // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "net" ) // A ContextDialer dials using a context. type ContextDialer interface { DialContext(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 Dial(ctx context.Context, network, address string) (net.Conn, error) { d := FromEnvironment() if xd, ok := d.(ContextDialer); ok { return xd.DialContext(ctx, network, address) } return dialContext(ctx, d, network, address) } // 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. func dialContext(ctx context.Context, d Dialer, network, address string) (net.Conn, error) { var ( conn net.Conn done = make(chan struct{}, 1) err error ) go func() { conn, err = d.Dial(network, address) close(done) if conn != nil && ctx.Err() != nil { conn.Close() } }() select { case <-ctx.Done(): err = ctx.Err() case <-done: } return conn, err }	1.63 KB	2025-05-25 12:27
📄 dial_test.go // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "fmt" "os" "testing" "time" "golang.org/x/net/internal/sockstest" "golang.org/x/net/nettest" ) func TestDial(t testing.T) { ResetProxyEnv() t.Run("DirectWithCancel", func(t testing.T) { defer ResetProxyEnv() l, err := nettest.NewLocalListener("tcp") if err != nil { t.Fatal(err) } defer l.Close() ctx, cancel := context.WithCancel(context.Background()) defer cancel() c, err := Dial(ctx, l.Addr().Network(), l.Addr().String()) if err != nil { t.Fatal(err) } c.Close() }) t.Run("DirectWithTimeout", func(t testing.T) { defer ResetProxyEnv() l, err := nettest.NewLocalListener("tcp") if err != nil { t.Fatal(err) } defer l.Close() ctx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel() c, err := Dial(ctx, l.Addr().Network(), l.Addr().String()) if err != nil { t.Fatal(err) } c.Close() }) t.Run("DirectWithTimeoutExceeded", func(t testing.T) { defer ResetProxyEnv() l, err := nettest.NewLocalListener("tcp") if err != nil { t.Fatal(err) } defer l.Close() ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond) time.Sleep(time.Millisecond) defer cancel() c, err := Dial(ctx, l.Addr().Network(), l.Addr().String()) if err == nil { defer c.Close() t.Fatal("failed to timeout") } }) t.Run("SOCKS5", func(t testing.T) { defer ResetProxyEnv() s, err := sockstest.NewServer(sockstest.NoAuthRequired, sockstest.NoProxyRequired) if err != nil { t.Fatal(err) } defer s.Close() if err = os.Setenv("ALL_PROXY", fmt.Sprintf("socks5://%s", s.Addr().String())); err != nil { t.Fatal(err) } c, err := Dial(context.Background(), s.TargetAddr().Network(), s.TargetAddr().String()) if err != nil { t.Fatal(err) } c.Close() }) t.Run("SOCKS5WithTimeout", func(t testing.T) { defer ResetProxyEnv() s, err := sockstest.NewServer(sockstest.NoAuthRequired, sockstest.NoProxyRequired) if err != nil { t.Fatal(err) } defer s.Close() if err = os.Setenv("ALL_PROXY", fmt.Sprintf("socks5://%s", s.Addr().String())); err != nil { t.Fatal(err) } ctx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel() c, err := Dial(ctx, s.TargetAddr().Network(), s.TargetAddr().String()) if err != nil { t.Fatal(err) } c.Close() }) t.Run("SOCKS5WithTimeoutExceeded", func(t *testing.T) { defer ResetProxyEnv() s, err := sockstest.NewServer(sockstest.NoAuthRequired, sockstest.NoProxyRequired) if err != nil { t.Fatal(err) } defer s.Close() if err = os.Setenv("ALL_PROXY", fmt.Sprintf("socks5://%s", s.Addr().String())); err != nil { t.Fatal(err) } ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond) time.Sleep(time.Millisecond) defer cancel() c, err := Dial(ctx, s.TargetAddr().Network(), s.TargetAddr().String()) if err == nil { defer c.Close() t.Fatal("failed to timeout") } }) }	3.08 KB	2025-05-25 12:27
📄 direct.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "net" ) type direct struct{} // Direct implements Dialer by making network connections directly using net.Dial or net.DialContext. var Direct = direct{} var ( _ Dialer = Direct _ ContextDialer = Direct ) // Dial directly invokes net.Dial with the supplied parameters. func (direct) Dial(network, addr string) (net.Conn, error) { return net.Dial(network, addr) } // DialContext instantiates a net.Dialer and invokes its DialContext receiver with the supplied parameters. func (direct) DialContext(ctx context.Context, network, addr string) (net.Conn, error) { var d net.Dialer return d.DialContext(ctx, network, addr) }	832 B	2025-05-25 12:27
📄 per_host.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "net" "strings" ) // A PerHost directs connections to a default Dialer unless the host name // requested matches one of a number of exceptions. type PerHost struct { def, bypass Dialer bypassNetworks []net.IPNet bypassIPs []net.IP bypassZones []string bypassHosts []string } // 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 NewPerHost(defaultDialer, bypass Dialer) PerHost { return &PerHost{ def: defaultDialer, bypass: bypass, } } // Dial connects to the address addr on the given network through either // defaultDialer or bypass. func (p PerHost) Dial(network, addr string) (c net.Conn, err error) { host, _, err := net.SplitHostPort(addr) if err != nil { return nil, err } return p.dialerForRequest(host).Dial(network, addr) } // DialContext connects to the address addr on the given network through either // defaultDialer or bypass. func (p PerHost) DialContext(ctx context.Context, network, addr string) (c net.Conn, err error) { host, _, err := net.SplitHostPort(addr) if err != nil { return nil, err } d := p.dialerForRequest(host) if x, ok := d.(ContextDialer); ok { return x.DialContext(ctx, network, addr) } return dialContext(ctx, d, network, addr) } func (p PerHost) dialerForRequest(host string) Dialer { if ip := net.ParseIP(host); ip != nil { for _, net := range p.bypassNetworks { if net.Contains(ip) { return p.bypass } } for _, bypassIP := range p.bypassIPs { if bypassIP.Equal(ip) { return p.bypass } } return p.def } for _, zone := range p.bypassZones { if strings.HasSuffix(host, zone) { return p.bypass } if host == zone[1:] { // For a zone ".example.com", we match "example.com" // too. return p.bypass } } for _, bypassHost := range p.bypassHosts { if bypassHost == host { return p.bypass } } return p.def } // 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. func (p PerHost) AddFromString(s string) { hosts := strings.Split(s, ",") for _, host := range hosts { host = strings.TrimSpace(host) if len(host) == 0 { continue } if strings.Contains(host, "/") { // We assume that it's a CIDR address like 127.0.0.0/8 if _, net, err := net.ParseCIDR(host); err == nil { p.AddNetwork(net) } continue } if ip := net.ParseIP(host); ip != nil { p.AddIP(ip) continue } if strings.HasPrefix(host, ".") { p.AddZone(host[1:]) continue } p.AddHost(host) } } // 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. func (p PerHost) AddIP(ip net.IP) { p.bypassIPs = append(p.bypassIPs, ip) } // 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. func (p PerHost) AddNetwork(net net.IPNet) { p.bypassNetworks = append(p.bypassNetworks, net) } // AddZone specifies a DNS suffix that will use the bypass proxy. A zone of // "example.com" matches "example.com" and all of its subdomains. func (p PerHost) AddZone(zone string) { zone = strings.TrimSuffix(zone, ".") if !strings.HasPrefix(zone, ".") { zone = "." + zone } p.bypassZones = append(p.bypassZones, zone) } // AddHost specifies a host name that will use the bypass proxy. func (p *PerHost) AddHost(host string) { host = strings.TrimSuffix(host, ".") p.bypassHosts = append(p.bypassHosts, host) }	4.02 KB	2025-05-25 12:27
📄 per_host_test.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "errors" "net" "reflect" "testing" ) type recordingProxy struct { addrs []string } func (r recordingProxy) Dial(network, addr string) (net.Conn, error) { r.addrs = append(r.addrs, addr) return nil, errors.New("recordingProxy") } func TestPerHost(t testing.T) { expectedDef := []string{ "example.com:123", "1.2.3.4:123", "[1001::]:123", } expectedBypass := []string{ "localhost:123", "zone:123", "foo.zone:123", "127.0.0.1:123", "10.1.2.3:123", "[1000::]:123", } t.Run("Dial", func(t testing.T) { var def, bypass recordingProxy perHost := NewPerHost(&def, &bypass) perHost.AddFromString("localhost,.zone,127.0.0.1,10.0.0.1/8,1000::/16") for _, addr := range expectedDef { perHost.Dial("tcp", addr) } for _, addr := range expectedBypass { perHost.Dial("tcp", addr) } if !reflect.DeepEqual(expectedDef, def.addrs) { t.Errorf("Hosts which went to the default proxy didn't match. Got %v, want %v", def.addrs, expectedDef) } if !reflect.DeepEqual(expectedBypass, bypass.addrs) { t.Errorf("Hosts which went to the bypass proxy didn't match. Got %v, want %v", bypass.addrs, expectedBypass) } }) t.Run("DialContext", func(t testing.T) { var def, bypass recordingProxy perHost := NewPerHost(&def, &bypass) perHost.AddFromString("localhost,.zone,127.0.0.1,10.0.0.1/8,1000::/16") for _, addr := range expectedDef { perHost.DialContext(context.Background(), "tcp", addr) } for _, addr := range expectedBypass { perHost.DialContext(context.Background(), "tcp", addr) } if !reflect.DeepEqual(expectedDef, def.addrs) { t.Errorf("Hosts which went to the default proxy didn't match. Got %v, want %v", def.addrs, expectedDef) } if !reflect.DeepEqual(expectedBypass, bypass.addrs) { t.Errorf("Hosts which went to the bypass proxy didn't match. Got %v, want %v", bypass.addrs, expectedBypass) } }) }	2.04 KB	2025-05-25 12:27
📄 proxy.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package proxy provides support for a variety of protocols to proxy network // data. package proxy // import "golang.org/x/net/proxy" import ( "errors" "net" "net/url" "os" "sync" ) // A Dialer is a means to establish a connection. // Custom dialers should also implement ContextDialer. type Dialer interface { // Dial connects to the given address via the proxy. Dial(network, addr string) (c net.Conn, err error) } // Auth contains authentication parameters that specific Dialers may require. type Auth struct { User, Password string } // FromEnvironment returns the dialer specified by the proxy-related // variables in the environment and makes underlying connections // directly. func FromEnvironment() Dialer { return FromEnvironmentUsing(Direct) } // 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 FromEnvironmentUsing(forward Dialer) Dialer { allProxy := allProxyEnv.Get() if len(allProxy) == 0 { return forward } proxyURL, err := url.Parse(allProxy) if err != nil { return forward } proxy, err := FromURL(proxyURL, forward) if err != nil { return forward } noProxy := noProxyEnv.Get() if len(noProxy) == 0 { return proxy } perHost := NewPerHost(proxy, forward) perHost.AddFromString(noProxy) return perHost } // proxySchemes is a map from URL schemes to a function that creates a Dialer // from a URL with such a scheme. var proxySchemes map[string]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 RegisterDialerType(scheme string, f func(url.URL, Dialer) (Dialer, error)) { if proxySchemes == nil { proxySchemes = make(map[string]func(url.URL, Dialer) (Dialer, error)) } proxySchemes[scheme] = f } // FromURL returns a Dialer given a URL specification and an underlying // Dialer for it to make network requests. func FromURL(u url.URL, forward Dialer) (Dialer, error) { var auth Auth if u.User != nil { auth = new(Auth) auth.User = u.User.Username() if p, ok := u.User.Password(); ok { auth.Password = p } } switch u.Scheme { case "socks5", "socks5h": addr := u.Hostname() port := u.Port() if port == "" { port = "1080" } return SOCKS5("tcp", net.JoinHostPort(addr, port), auth, forward) } // If the scheme doesn't match any of the built-in schemes, see if it // was registered by another package. if proxySchemes != nil { if f, ok := proxySchemes[u.Scheme]; ok { return f(u, forward) } } return nil, errors.New("proxy: unknown scheme: " + u.Scheme) } var ( allProxyEnv = &envOnce{ names: []string{"ALL_PROXY", "all_proxy"}, } noProxyEnv = &envOnce{ names: []string{"NO_PROXY", "no_proxy"}, } ) // 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) type envOnce struct { names []string once sync.Once val string } func (e envOnce) Get() string { e.once.Do(e.init) return e.val } func (e envOnce) init() { for _, n := range e.names { e.val = os.Getenv(n) if e.val != "" { return } } } // reset is used by tests func (e *envOnce) reset() { e.once = sync.Once{} e.val = "" }	3.59 KB	2025-05-25 12:27
📄 proxy_test.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "bytes" "context" "errors" "fmt" "net" "net/url" "os" "strings" "testing" "golang.org/x/net/internal/socks" "golang.org/x/net/internal/sockstest" ) type proxyFromEnvTest struct { allProxyEnv string noProxyEnv string wantTypeOf Dialer } func (t proxyFromEnvTest) String() string { var buf bytes.Buffer space := func() { if buf.Len() > 0 { buf.WriteByte(' ') } } if t.allProxyEnv != "" { fmt.Fprintf(&buf, "all_proxy=%q", t.allProxyEnv) } if t.noProxyEnv != "" { space() fmt.Fprintf(&buf, "no_proxy=%q", t.noProxyEnv) } return strings.TrimSpace(buf.String()) } func TestFromEnvironment(t testing.T) { ResetProxyEnv() type dummyDialer struct { direct } RegisterDialerType("irc", func(_ url.URL, _ Dialer) (Dialer, error) { return dummyDialer{}, nil }) proxyFromEnvTests := []proxyFromEnvTest{ {allProxyEnv: "127.0.0.1:8080", noProxyEnv: "localhost, 127.0.0.1", wantTypeOf: direct{}}, {allProxyEnv: "ftp://example.com:8000", noProxyEnv: "localhost, 127.0.0.1", wantTypeOf: direct{}}, {allProxyEnv: "socks5://example.com:8080", noProxyEnv: "localhost, 127.0.0.1", wantTypeOf: &PerHost{}}, {allProxyEnv: "socks5h://example.com", wantTypeOf: &socks.Dialer{}}, {allProxyEnv: "irc://example.com:8000", wantTypeOf: dummyDialer{}}, {noProxyEnv: "localhost, 127.0.0.1", wantTypeOf: direct{}}, {wantTypeOf: direct{}}, } for _, tt := range proxyFromEnvTests { os.Setenv("ALL_PROXY", tt.allProxyEnv) os.Setenv("NO_PROXY", tt.noProxyEnv) ResetCachedEnvironment() d := FromEnvironment() if got, want := fmt.Sprintf("%T", d), fmt.Sprintf("%T", tt.wantTypeOf); got != want { t.Errorf("%v: got type = %T, want %T", tt, d, tt.wantTypeOf) } } } func TestFromURL(t testing.T) { ss, err := sockstest.NewServer(sockstest.NoAuthRequired, sockstest.NoProxyRequired) if err != nil { t.Fatal(err) } defer ss.Close() url, err := url.Parse("socks5://user:password@" + ss.Addr().String()) if err != nil { t.Fatal(err) } proxy, err := FromURL(url, nil) if err != nil { t.Fatal(err) } c, err := proxy.Dial("tcp", "fqdn.doesnotexist:5963") if err != nil { t.Fatal(err) } c.Close() } func TestSOCKS5(t testing.T) { ss, err := sockstest.NewServer(sockstest.NoAuthRequired, sockstest.NoProxyRequired) if err != nil { t.Fatal(err) } defer ss.Close() proxy, err := SOCKS5("tcp", ss.Addr().String(), nil, nil) if err != nil { t.Fatal(err) } c, err := proxy.Dial("tcp", ss.TargetAddr().String()) if err != nil { t.Fatal(err) } c.Close() } type funcFailDialer func(context.Context) error func (f funcFailDialer) Dial(net, addr string) (net.Conn, error) { panic("shouldn't see a call to Dial") } func (f funcFailDialer) DialContext(ctx context.Context, net, addr string) (net.Conn, error) { return nil, f(ctx) } // Check that FromEnvironmentUsing uses our dialer. func TestFromEnvironmentUsing(t testing.T) { ResetProxyEnv() errFoo := errors.New("some error to check our dialer was used)") type key string ctx := context.WithValue(context.Background(), key("foo"), "bar") dialer := FromEnvironmentUsing(funcFailDialer(func(ctx context.Context) error { if got := ctx.Value(key("foo")); got != "bar" { t.Errorf("Resolver context = %T %v, want %q", got, got, "bar") } return errFoo })) _, err := dialer.(ContextDialer).DialContext(ctx, "tcp", "foo.tld:123") if err == nil { t.Fatalf("unexpected success") } if !strings.Contains(err.Error(), errFoo.Error()) { t.Errorf("got unexpected error %q; want substr %q", err, errFoo) } } func ResetProxyEnv() { for _, env := range []envOnce{allProxyEnv, noProxyEnv} { for _, v := range env.names { os.Setenv(v, "") } } ResetCachedEnvironment() } func ResetCachedEnvironment() { allProxyEnv.reset() noProxyEnv.reset() }	3.88 KB	2025-05-25 12:27
📄 socks5.go // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package proxy import ( "context" "net" "golang.org/x/net/internal/socks" ) // SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given // address with an optional username and password. // See RFC 1928 and RFC 1929. func SOCKS5(network, address string, auth *Auth, forward Dialer) (Dialer, error) { d := socks.NewDialer(network, address) if forward != nil { if f, ok := forward.(ContextDialer); ok { d.ProxyDial = func(ctx context.Context, network string, address string) (net.Conn, error) { return f.DialContext(ctx, network, address) } } else { d.ProxyDial = func(ctx context.Context, network string, address string) (net.Conn, error) { return dialContext(ctx, forward, network, address) } } } if auth != nil { up := socks.UsernamePassword{ Username: auth.User, Password: auth.Password, } d.AuthMethods = []socks.AuthMethod{ socks.AuthMethodNotRequired, socks.AuthMethodUsernamePassword, } d.Authenticate = up.Authenticate } return d, nil }	1.15 KB	2025-05-25 12:27

Terminal