1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-11-11 15:03:19 -05:00
v2fly/proxy/freedom/freedom.go

195 lines
5.4 KiB
Go
Raw Normal View History

2015-09-11 08:12:09 -04:00
package freedom
2015-09-09 11:39:06 -04:00
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
2017-04-08 19:43:25 -04:00
2015-09-09 11:39:06 -04:00
import (
"context"
"time"
2016-12-09 07:17:34 -05:00
core "github.com/v2fly/v2ray-core/v5"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/dice"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/retry"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/common/signal"
"github.com/v2fly/v2ray-core/v5/common/task"
"github.com/v2fly/v2ray-core/v5/features/dns"
"github.com/v2fly/v2ray-core/v5/features/policy"
"github.com/v2fly/v2ray-core/v5/transport"
"github.com/v2fly/v2ray-core/v5/transport/internet"
2015-09-09 11:39:06 -04:00
)
2018-10-22 09:58:52 -04:00
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
h := new(Handler)
if err := core.RequireFeatures(ctx, func(pm policy.Manager, d dns.Client) error {
return h.Init(config.(*Config), pm, d)
}); err != nil {
return nil, err
}
return h, nil
}))
2021-09-04 16:30:38 -04:00
common.Must(common.RegisterConfig((*SimplifiedConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
simplifiedServer := config.(*SimplifiedConfig)
_ = simplifiedServer
fullConfig := &Config{}
return common.CreateObject(ctx, fullConfig)
}))
2018-10-22 09:58:52 -04:00
}
2017-11-15 12:28:39 -05:00
// Handler handles Freedom connections.
2016-12-22 07:33:28 -05:00
type Handler struct {
2018-10-11 16:34:31 -04:00
policyManager policy.Manager
dns dns.Client
2020-08-26 07:35:33 -04:00
config *Config
2016-05-22 16:30:21 -04:00
}
2018-10-22 09:58:52 -04:00
// Init initializes the Handler with necessary parameters.
func (h *Handler) Init(config *Config, pm policy.Manager, d dns.Client) error {
2020-08-26 07:35:33 -04:00
h.config = config
2018-10-22 09:58:52 -04:00
h.policyManager = pm
h.dns = d
2018-10-22 09:58:52 -04:00
return nil
2016-05-22 16:30:21 -04:00
}
2018-10-11 16:34:31 -04:00
func (h *Handler) policy() policy.Session {
p := h.policyManager.ForLevel(h.config.UserLevel)
if h.config.Timeout > 0 && h.config.UserLevel == 0 {
p.Timeouts.ConnectionIdle = time.Duration(h.config.Timeout) * time.Second
}
return p
}
func (h *Handler) resolveIP(ctx context.Context, domain string, localAddr net.Address) net.Address {
if c, ok := h.dns.(dns.ClientWithIPOption); ok {
c.SetFakeDNSOption(false) // Skip FakeDNS
} else {
newError("DNS client doesn't implement ClientWithIPOption")
}
2021-11-27 01:32:07 -05:00
lookupFunc := h.dns.LookupIP
if h.config.DomainStrategy == Config_USE_IP4 || (localAddr != nil && localAddr.Family().IsIPv4()) {
if lookupIPv4, ok := h.dns.(dns.IPv4Lookup); ok {
lookupFunc = lookupIPv4.LookupIPv4
}
} else if h.config.DomainStrategy == Config_USE_IP6 || (localAddr != nil && localAddr.Family().IsIPv6()) {
if lookupIPv6, ok := h.dns.(dns.IPv6Lookup); ok {
lookupFunc = lookupIPv6.LookupIPv6
}
}
ips, err := lookupFunc(domain)
2017-12-19 17:55:09 -05:00
if err != nil {
newError("failed to get IP address for domain ", domain).Base(err).WriteToLog(session.ExportIDToError(ctx))
2017-12-19 17:55:09 -05:00
}
2016-05-22 16:30:21 -04:00
if len(ips) == 0 {
2017-11-15 06:55:54 -05:00
return nil
2016-05-22 16:30:21 -04:00
}
2017-11-15 06:55:54 -05:00
return net.IPAddress(ips[dice.Roll(len(ips))])
2015-09-09 11:39:06 -04:00
}
2018-07-18 10:29:29 -04:00
func isValidAddress(addr *net.IPOrDomain) bool {
if addr == nil {
return false
}
a := addr.AsAddress()
return a != net.AnyIP
}
2017-11-15 12:28:39 -05:00
// Process implements proxy.Outbound.
2018-11-03 07:36:29 -04:00
func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer internet.Dialer) error {
outbound := session.OutboundFromContext(ctx)
if outbound == nil || !outbound.Target.IsValid() {
return newError("target not specified.")
}
destination := outbound.Target
if h.config.DestinationOverride != nil {
server := h.config.DestinationOverride.Server
2018-07-18 10:29:29 -04:00
if isValidAddress(server.Address) {
2018-07-18 10:21:40 -04:00
destination.Address = server.Address.AsAddress()
}
if server.Port != 0 {
destination.Port = net.Port(server.Port)
}
}
newError("opening connection to ", destination).WriteToLog(session.ExportIDToError(ctx))
2015-12-16 19:19:04 -05:00
2018-04-16 18:31:10 -04:00
input := link.Reader
output := link.Writer
2016-04-18 12:44:10 -04:00
2018-07-01 15:37:45 -04:00
var conn internet.Connection
err := retry.ExponentialBackoff(5, 100).On(func() error {
dialDest := destination
if h.config.useIP() && dialDest.Address.Family().IsDomain() {
ip := h.resolveIP(ctx, dialDest.Address.Domain(), dialer.Address())
2018-07-01 15:37:45 -04:00
if ip != nil {
dialDest = net.Destination{
Network: dialDest.Network,
Address: ip,
Port: dialDest.Port,
}
newError("dialing to ", dialDest).WriteToLog(session.ExportIDToError(ctx))
2017-11-15 06:55:54 -05:00
}
}
2018-07-01 15:37:45 -04:00
rawConn, err := dialer.Dial(ctx, dialDest)
2015-12-16 19:19:04 -05:00
if err != nil {
return err
}
conn = rawConn
return nil
})
2015-09-09 11:39:25 -04:00
if err != nil {
2017-04-08 19:43:25 -04:00
return newError("failed to open connection to ", destination).Base(err)
}
defer conn.Close()
plcy := h.policy()
2017-11-14 18:36:14 -05:00
ctx, cancel := context.WithCancel(ctx)
timer := signal.CancelAfterInactivity(ctx, cancel, plcy.Timeouts.ConnectionIdle)
2017-01-31 06:42:05 -05:00
2018-04-11 10:45:09 -04:00
requestDone := func() error {
defer timer.SetTimeout(plcy.Timeouts.DownlinkOnly)
2017-04-16 03:57:28 -04:00
var writer buf.Writer
if destination.Network == net.Network_TCP {
writer = buf.NewWriter(conn)
} else {
2018-07-31 07:43:27 -04:00
writer = &buf.SequentialWriter{Writer: conn}
2017-04-16 03:57:28 -04:00
}
2019-02-14 18:28:26 -05:00
2017-04-27 16:30:48 -04:00
if err := buf.Copy(input, writer, buf.UpdateActivity(timer)); err != nil {
2017-04-16 16:48:51 -04:00
return newError("failed to process request").Base(err)
2016-11-21 18:17:49 -05:00
}
2016-12-29 18:32:20 -05:00
return nil
2018-04-11 10:45:09 -04:00
}
2015-09-22 12:31:06 -04:00
2018-04-11 10:45:09 -04:00
responseDone := func() error {
defer timer.SetTimeout(plcy.Timeouts.UplinkOnly)
2016-12-29 18:32:20 -05:00
2018-12-11 04:17:50 -05:00
var reader buf.Reader
if destination.Network == net.Network_TCP {
reader = buf.NewReader(conn)
} else {
2019-02-07 13:14:37 -05:00
reader = buf.NewPacketReader(conn)
2018-12-11 04:17:50 -05:00
}
if err := buf.Copy(reader, output, buf.UpdateActivity(timer)); err != nil {
2017-04-16 16:48:51 -04:00
return newError("failed to process response").Base(err)
2016-12-29 18:32:20 -05:00
}
2016-12-29 18:32:20 -05:00
return nil
2018-04-11 10:45:09 -04:00
}
2016-12-29 18:32:20 -05:00
2018-12-06 05:35:02 -05:00
if err := task.Run(ctx, requestDone, task.OnSuccess(responseDone, task.Close(output))); err != nil {
2017-04-08 19:43:25 -04:00
return newError("connection ends").Base(err)
2016-11-21 18:17:49 -05:00
}
return nil
2015-09-09 11:39:06 -04:00
}