git add

Hunter0x7c7

2022-08-11 a82f9cb69f63aaeba40c024960deda7d75b9fece

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//go:build !confonly 
// +build !confonly 
 
package grpc 
 
import ( 
    "context" 
    gonet "net" 
    "sync" 
    "time" 
 
    "google.golang.org/grpc" 
    "google.golang.org/grpc/backoff" 
    "google.golang.org/grpc/connectivity" 
    "google.golang.org/grpc/credentials" 
 
    core "github.com/v2fly/v2ray-core/v5" 
    "github.com/v2fly/v2ray-core/v5/common" 
    "github.com/v2fly/v2ray-core/v5/common/net" 
    "github.com/v2fly/v2ray-core/v5/common/session" 
    "github.com/v2fly/v2ray-core/v5/transport/internet" 
    "github.com/v2fly/v2ray-core/v5/transport/internet/grpc/encoding" 
    "github.com/v2fly/v2ray-core/v5/transport/internet/tls" 
) 
 
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) { 
    newError("creating connection to ", dest).WriteToLog(session.ExportIDToError(ctx)) 
 
    conn, err := dialgRPC(ctx, dest, streamSettings) 
    if err != nil { 
        return nil, newError("failed to dial Grpc").Base(err) 
    } 
    return internet.Connection(conn), nil 
} 
 
func init() { 
    common.Must(internet.RegisterTransportDialer(protocolName, Dial)) 
} 
 
type dialerCanceller func() 
 
var ( 
    globalDialerMap    map[net.Destination]*grpc.ClientConn 
    globalDialerAccess sync.Mutex 
) 
 
func dialgRPC(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (net.Conn, error) { 
    grpcSettings := streamSettings.ProtocolSettings.(*Config) 
 
    config := tls.ConfigFromStreamSettings(streamSettings) 
    dialOption := grpc.WithInsecure() 
 
    if config != nil { 
        dialOption = grpc.WithTransportCredentials(credentials.NewTLS(config.GetTLSConfig())) 
    } 
 
    conn, canceller, err := getGrpcClient(ctx, dest, dialOption, streamSettings) 
    if err != nil { 
        return nil, newError("Cannot dial grpc").Base(err) 
    } 
    client := encoding.NewGunServiceClient(conn) 
    gunService, err := client.(encoding.GunServiceClientX).TunCustomName(ctx, grpcSettings.ServiceName) 
    if err != nil { 
        canceller() 
        return nil, newError("Cannot dial grpc").Base(err) 
    } 
    return encoding.NewGunConn(gunService, nil), nil 
} 
 
func getGrpcClient(ctx context.Context, dest net.Destination, dialOption grpc.DialOption, streamSettings *internet.MemoryStreamConfig) (*grpc.ClientConn, dialerCanceller, error) { 
    globalDialerAccess.Lock() 
    defer globalDialerAccess.Unlock() 
 
    if globalDialerMap == nil { 
        globalDialerMap = make(map[net.Destination]*grpc.ClientConn) 
    } 
 
    canceller := func() { 
        globalDialerAccess.Lock() 
        defer globalDialerAccess.Unlock() 
        delete(globalDialerMap, dest) 
    } 
 
    // TODO Should support chain proxy to the same destination 
    if client, found := globalDialerMap[dest]; found && client.GetState() != connectivity.Shutdown { 
        return client, canceller, nil 
    } 
 
    conn, err := grpc.Dial( 
        dest.Address.String()+":"+dest.Port.String(), 
        dialOption, 
        grpc.WithConnectParams(grpc.ConnectParams{ 
            Backoff: backoff.Config{ 
                BaseDelay:  500 * time.Millisecond, 
                Multiplier: 1.5, 
                Jitter:     0.2, 
                MaxDelay:   19 * time.Second, 
            }, 
            MinConnectTimeout: 5 * time.Second, 
        }), 
        grpc.WithContextDialer(func(ctxGrpc context.Context, s string) (gonet.Conn, error) { 
            rawHost, rawPort, err := net.SplitHostPort(s) 
            if err != nil { 
                return nil, err 
            } 
            if len(rawPort) == 0 { 
                rawPort = "443" 
            } 
            port, err := net.PortFromString(rawPort) 
            if err != nil { 
                return nil, err 
            } 
            address := net.ParseAddress(rawHost) 
            detachedContext := core.ToBackgroundDetachedContext(ctx) 
            return internet.DialSystem(detachedContext, net.TCPDestination(address, port), streamSettings.SocketSettings) 
        }), 
    ) 
    globalDialerMap[dest] = conn 
    return conn, canceller, err 
}