repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/conn.go | transport/internet/hysteria2/conn.go | package hysteria2
import (
"time"
"github.com/apernet/quic-go"
hyClient "github.com/v2fly/hysteria/core/v2/client"
"github.com/v2fly/hysteria/core/v2/international/protocol"
hyServer "github.com/v2fly/hysteria/core/v2/server"
"github.com/v2fly/v2ray-core/v5/common/net"
)
const (
CanNotUseUDPExtension = "Only hysteria2 proxy protocol can use udpExtension."
Hy2MustNeedTLS = "Hysteria2 based on QUIC that requires TLS."
)
type HyConn struct {
IsUDPExtension bool
IsServer bool
ClientUDPSession hyClient.HyUDPConn
ServerUDPSession *hyServer.UdpSessionEntry
stream quic.Stream
local net.Addr
remote net.Addr
}
func (c *HyConn) Read(b []byte) (int, error) {
if c.IsUDPExtension {
n, data, _, err := c.ReadPacket()
copy(b, data)
return n, err
}
return c.stream.Read(b)
}
func (c *HyConn) Write(b []byte) (int, error) {
if c.IsUDPExtension {
dest, _ := net.ParseDestination("udp:v2fly.org:6666")
return c.WritePacket(b, dest)
}
return c.stream.Write(b)
}
func (c *HyConn) WritePacket(b []byte, dest net.Destination) (int, error) {
if !c.IsUDPExtension {
return 0, newError(CanNotUseUDPExtension)
}
if c.IsServer {
msg := &protocol.UDPMessage{
SessionID: c.ServerUDPSession.ID,
PacketID: 0,
FragID: 0,
FragCount: 1,
Addr: dest.NetAddr(),
Data: b,
}
c.ServerUDPSession.SendCh <- msg
return len(b), nil
}
return len(b), c.ClientUDPSession.Send(b, dest.NetAddr())
}
func (c *HyConn) ReadPacket() (int, []byte, *net.Destination, error) {
if !c.IsUDPExtension {
return 0, nil, nil, newError(CanNotUseUDPExtension)
}
if c.IsServer {
msg, ok := <-c.ServerUDPSession.ReceiveCh
if !ok {
return 0, nil, nil, newError("UDP session receive channel closed")
}
dest, err := net.ParseDestination("udp:" + msg.Addr)
return len(msg.Data), msg.Data, &dest, err
}
data, address, err := c.ClientUDPSession.Receive()
if err != nil {
return 0, nil, nil, err
}
dest, err := net.ParseDestination("udp:" + address)
if err != nil {
return 0, nil, nil, err
}
return len(data), data, &dest, nil
}
func (c *HyConn) Close() error {
if c.IsUDPExtension {
if !c.IsServer && c.ClientUDPSession == nil || (c.IsServer && c.ServerUDPSession == nil) {
return newError(CanNotUseUDPExtension)
}
if c.IsServer {
c.ServerUDPSession.CloseWithErr(nil)
return nil
}
return c.ClientUDPSession.Close()
}
return c.stream.Close()
}
func (c *HyConn) LocalAddr() net.Addr {
return c.local
}
func (c *HyConn) RemoteAddr() net.Addr {
return c.remote
}
func (c *HyConn) SetDeadline(t time.Time) error {
if c.IsUDPExtension {
return nil
}
return c.stream.SetDeadline(t)
}
func (c *HyConn) SetReadDeadline(t time.Time) error {
if c.IsUDPExtension {
return nil
}
return c.stream.SetReadDeadline(t)
}
func (c *HyConn) SetWriteDeadline(t time.Time) error {
if c.IsUDPExtension {
return nil
}
return c.stream.SetWriteDeadline(t)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/config.pb.go | transport/internet/hysteria2/config.pb.go | package hysteria2
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Congestion struct {
state protoimpl.MessageState `protogen:"open.v1"`
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
UpMbps uint64 `protobuf:"varint,2,opt,name=up_mbps,json=upMbps,proto3" json:"up_mbps,omitempty"`
DownMbps uint64 `protobuf:"varint,3,opt,name=down_mbps,json=downMbps,proto3" json:"down_mbps,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Congestion) Reset() {
*x = Congestion{}
mi := &file_transport_internet_hysteria2_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Congestion) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Congestion) ProtoMessage() {}
func (x *Congestion) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_hysteria2_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Congestion.ProtoReflect.Descriptor instead.
func (*Congestion) Descriptor() ([]byte, []int) {
return file_transport_internet_hysteria2_config_proto_rawDescGZIP(), []int{0}
}
func (x *Congestion) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *Congestion) GetUpMbps() uint64 {
if x != nil {
return x.UpMbps
}
return 0
}
func (x *Congestion) GetDownMbps() uint64 {
if x != nil {
return x.DownMbps
}
return 0
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Password string `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
Congestion *Congestion `protobuf:"bytes,4,opt,name=congestion,proto3" json:"congestion,omitempty"`
IgnoreClientBandwidth bool `protobuf:"varint,5,opt,name=ignore_client_bandwidth,json=ignoreClientBandwidth,proto3" json:"ignore_client_bandwidth,omitempty"`
UseUdpExtension bool `protobuf:"varint,6,opt,name=use_udp_extension,json=useUdpExtension,proto3" json:"use_udp_extension,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_hysteria2_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_hysteria2_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_hysteria2_config_proto_rawDescGZIP(), []int{1}
}
func (x *Config) GetPassword() string {
if x != nil {
return x.Password
}
return ""
}
func (x *Config) GetCongestion() *Congestion {
if x != nil {
return x.Congestion
}
return nil
}
func (x *Config) GetIgnoreClientBandwidth() bool {
if x != nil {
return x.IgnoreClientBandwidth
}
return false
}
func (x *Config) GetUseUdpExtension() bool {
if x != nil {
return x.UseUdpExtension
}
return false
}
var File_transport_internet_hysteria2_config_proto protoreflect.FileDescriptor
const file_transport_internet_hysteria2_config_proto_rawDesc = "" +
"\n" +
")transport/internet/hysteria2/config.proto\x12'v2ray.core.transport.internet.hysteria2\x1a common/protoext/extensions.proto\"V\n" +
"\n" +
"Congestion\x12\x12\n" +
"\x04type\x18\x01 \x01(\tR\x04type\x12\x17\n" +
"\aup_mbps\x18\x02 \x01(\x04R\x06upMbps\x12\x1b\n" +
"\tdown_mbps\x18\x03 \x01(\x04R\bdownMbps\"\xf9\x01\n" +
"\x06Config\x12\x1a\n" +
"\bpassword\x18\x03 \x01(\tR\bpassword\x12S\n" +
"\n" +
"congestion\x18\x04 \x01(\v23.v2ray.core.transport.internet.hysteria2.CongestionR\n" +
"congestion\x126\n" +
"\x17ignore_client_bandwidth\x18\x05 \x01(\bR\x15ignoreClientBandwidth\x12*\n" +
"\x11use_udp_extension\x18\x06 \x01(\bR\x0fuseUdpExtension:\x1a\x82\xb5\x18\x16\n" +
"\ttransport\x12\thysteria2B\x96\x01\n" +
"+com.v2ray.core.transport.internet.hysteria2P\x01Z;github.com/v2fly/v2ray-core/v5/transport/internet/hysteria2\xaa\x02'V2Ray.Core.Transport.Internet.Hysteria2b\x06proto3"
var (
file_transport_internet_hysteria2_config_proto_rawDescOnce sync.Once
file_transport_internet_hysteria2_config_proto_rawDescData []byte
)
func file_transport_internet_hysteria2_config_proto_rawDescGZIP() []byte {
file_transport_internet_hysteria2_config_proto_rawDescOnce.Do(func() {
file_transport_internet_hysteria2_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_hysteria2_config_proto_rawDesc), len(file_transport_internet_hysteria2_config_proto_rawDesc)))
})
return file_transport_internet_hysteria2_config_proto_rawDescData
}
var file_transport_internet_hysteria2_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_hysteria2_config_proto_goTypes = []any{
(*Congestion)(nil), // 0: v2ray.core.transport.internet.hysteria2.Congestion
(*Config)(nil), // 1: v2ray.core.transport.internet.hysteria2.Config
}
var file_transport_internet_hysteria2_config_proto_depIdxs = []int32{
0, // 0: v2ray.core.transport.internet.hysteria2.Config.congestion:type_name -> v2ray.core.transport.internet.hysteria2.Congestion
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_hysteria2_config_proto_init() }
func file_transport_internet_hysteria2_config_proto_init() {
if File_transport_internet_hysteria2_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_hysteria2_config_proto_rawDesc), len(file_transport_internet_hysteria2_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_hysteria2_config_proto_goTypes,
DependencyIndexes: file_transport_internet_hysteria2_config_proto_depIdxs,
MessageInfos: file_transport_internet_hysteria2_config_proto_msgTypes,
}.Build()
File_transport_internet_hysteria2_config_proto = out.File
file_transport_internet_hysteria2_config_proto_goTypes = nil
file_transport_internet_hysteria2_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/hysteria2.go | transport/internet/hysteria2/hysteria2.go | package hysteria2
import (
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
const (
protocolName = "hysteria2"
)
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/crypt.go | transport/internet/kcp/crypt.go | package kcp
import (
"crypto/cipher"
"encoding/binary"
"hash/fnv"
"github.com/v2fly/v2ray-core/v5/common"
)
// SimpleAuthenticator is a legacy AEAD used for KCP encryption.
type SimpleAuthenticator struct{}
// NewSimpleAuthenticator creates a new SimpleAuthenticator
func NewSimpleAuthenticator() cipher.AEAD {
return &SimpleAuthenticator{}
}
// NonceSize implements cipher.AEAD.NonceSize().
func (*SimpleAuthenticator) NonceSize() int {
return 0
}
// Overhead implements cipher.AEAD.NonceSize().
func (*SimpleAuthenticator) Overhead() int {
return 6
}
// Seal implements cipher.AEAD.Seal().
func (a *SimpleAuthenticator) Seal(dst, nonce, plain, extra []byte) []byte {
dst = append(dst, 0, 0, 0, 0, 0, 0) // 4 bytes for hash, and then 2 bytes for length
binary.BigEndian.PutUint16(dst[4:], uint16(len(plain)))
dst = append(dst, plain...)
fnvHash := fnv.New32a()
common.Must2(fnvHash.Write(dst[4:]))
fnvHash.Sum(dst[:0])
dstLen := len(dst)
xtra := 4 - dstLen%4
if xtra != 4 {
dst = append(dst, make([]byte, xtra)...)
}
xorfwd(dst)
if xtra != 4 {
dst = dst[:dstLen]
}
return dst
}
// Open implements cipher.AEAD.Open().
func (a *SimpleAuthenticator) Open(dst, nonce, cipherText, extra []byte) ([]byte, error) {
dst = append(dst, cipherText...)
dstLen := len(dst)
xtra := 4 - dstLen%4
if xtra != 4 {
dst = append(dst, make([]byte, xtra)...)
}
xorbkd(dst)
if xtra != 4 {
dst = dst[:dstLen]
}
fnvHash := fnv.New32a()
common.Must2(fnvHash.Write(dst[4:]))
if binary.BigEndian.Uint32(dst[:4]) != fnvHash.Sum32() {
return nil, newError("invalid auth")
}
length := binary.BigEndian.Uint16(dst[4:6])
if len(dst)-6 != int(length) {
return nil, newError("invalid auth")
}
return dst[6:], nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/listener.go | transport/internet/kcp/listener.go | package kcp
import (
"context"
"crypto/cipher"
gotls "crypto/tls"
"sync"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
"github.com/v2fly/v2ray-core/v5/transport/internet/udp"
)
type ConnectionID struct {
Remote net.Address
Port net.Port
Conv uint16
}
// Listener defines a server listening for connections
type Listener struct {
sync.Mutex
sessions map[ConnectionID]*Connection
hub *udp.Hub
tlsConfig *gotls.Config
config *Config
reader PacketReader
header internet.PacketHeader
security cipher.AEAD
addConn internet.ConnHandler
}
func NewListener(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, addConn internet.ConnHandler) (*Listener, error) {
kcpSettings := streamSettings.ProtocolSettings.(*Config)
header, err := kcpSettings.GetPackerHeader()
if err != nil {
return nil, newError("failed to create packet header").Base(err).AtError()
}
security, err := kcpSettings.GetSecurity()
if err != nil {
return nil, newError("failed to create security").Base(err).AtError()
}
l := &Listener{
header: header,
security: security,
reader: &KCPPacketReader{
Header: header,
Security: security,
},
sessions: make(map[ConnectionID]*Connection),
config: kcpSettings,
addConn: addConn,
}
if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
l.tlsConfig = config.GetTLSConfig()
}
hub, err := udp.ListenUDP(ctx, address, port, streamSettings, udp.HubCapacity(1024))
if err != nil {
return nil, err
}
l.Lock()
l.hub = hub
l.Unlock()
newError("listening on ", address, ":", port).WriteToLog()
go l.handlePackets()
return l, nil
}
func (l *Listener) handlePackets() {
receive := l.hub.Receive()
for payload := range receive {
l.OnReceive(payload.Payload, payload.Source)
}
}
func (l *Listener) OnReceive(payload *buf.Buffer, src net.Destination) {
segments := l.reader.Read(payload.Bytes())
payload.Release()
if len(segments) == 0 {
newError("discarding invalid payload from ", src).WriteToLog()
return
}
conv := segments[0].Conversation()
cmd := segments[0].Command()
id := ConnectionID{
Remote: src.Address,
Port: src.Port,
Conv: conv,
}
l.Lock()
defer l.Unlock()
conn, found := l.sessions[id]
if !found {
if cmd == CommandTerminate {
return
}
writer := &Writer{
id: id,
hub: l.hub,
dest: src,
listener: l,
}
remoteAddr := &net.UDPAddr{
IP: src.Address.IP(),
Port: int(src.Port),
}
localAddr := l.hub.Addr()
conn = NewConnection(ConnMetadata{
LocalAddr: localAddr,
RemoteAddr: remoteAddr,
Conversation: conv,
}, &KCPPacketWriter{
Header: l.header,
Security: l.security,
Writer: writer,
}, writer, l.config)
var netConn internet.Connection = conn
if l.tlsConfig != nil {
netConn = tls.Server(conn, l.tlsConfig)
}
l.addConn(netConn)
l.sessions[id] = conn
}
conn.Input(segments)
}
func (l *Listener) Remove(id ConnectionID) {
l.Lock()
delete(l.sessions, id)
l.Unlock()
}
// Close stops listening on the UDP address. Already Accepted connections are not closed.
func (l *Listener) Close() error {
l.hub.Close()
l.Lock()
defer l.Unlock()
for _, conn := range l.sessions {
go conn.Terminate()
}
return nil
}
func (l *Listener) ActiveConnections() int {
l.Lock()
defer l.Unlock()
return len(l.sessions)
}
// Addr returns the listener's network address, The Addr returned is shared by all invocations of Addr, so do not modify it.
func (l *Listener) Addr() net.Addr {
return l.hub.Addr()
}
type Writer struct {
id ConnectionID
dest net.Destination
hub *udp.Hub
listener *Listener
}
func (w *Writer) Write(payload []byte) (int, error) {
return w.hub.WriteTo(payload, w.dest)
}
func (w *Writer) Close() error {
w.listener.Remove(w.id)
return nil
}
func ListenKCP(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, addConn internet.ConnHandler) (internet.Listener, error) {
return NewListener(ctx, address, port, streamSettings, addConn)
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, ListenKCP))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/dialer.go | transport/internet/kcp/dialer.go | package kcp
import (
"context"
"io"
"sync/atomic"
"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/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
var globalConv = uint32(dice.RollUint16())
func fetchInput(_ context.Context, input io.Reader, reader PacketReader, conn *Connection) {
cache := make(chan *buf.Buffer, 1024)
go func() {
for {
payload := buf.New()
if _, err := payload.ReadFrom(input); err != nil {
payload.Release()
close(cache)
return
}
select {
case cache <- payload:
default:
payload.Release()
}
}
}()
for payload := range cache {
segments := reader.Read(payload.Bytes())
payload.Release()
if len(segments) > 0 {
conn.Input(segments)
}
}
}
// DialKCP dials a new KCP connections to the specific destination.
func DialKCP(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
dest.Network = net.Network_UDP
newError("dialing mKCP to ", dest).WriteToLog()
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.Dialer()
rawConn, err := dialer.Dial(ctx, nil, dest, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to dial to dest: ", err).AtWarning().Base(err)
}
kcpSettings := streamSettings.ProtocolSettings.(*Config)
header, err := kcpSettings.GetPackerHeader()
if err != nil {
return nil, newError("failed to create packet header").Base(err)
}
security, err := kcpSettings.GetSecurity()
if err != nil {
return nil, newError("failed to create security").Base(err)
}
reader := &KCPPacketReader{
Header: header,
Security: security,
}
writer := &KCPPacketWriter{
Header: header,
Security: security,
Writer: rawConn,
}
conv := uint16(atomic.AddUint32(&globalConv, 1))
session := NewConnection(ConnMetadata{
LocalAddr: rawConn.LocalAddr(),
RemoteAddr: rawConn.RemoteAddr(),
Conversation: conv,
}, writer, rawConn, kcpSettings)
go fetchInput(ctx, rawConn, reader, session)
var iConn internet.Connection = session
if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
iConn = tls.Client(iConn, config.GetTLSConfig(tls.WithDestination(dest)))
}
return iConn, nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, DialKCP))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/errors.generated.go | transport/internet/kcp/errors.generated.go | package kcp
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/receiving.go | transport/internet/kcp/receiving.go | package kcp
import (
"sync"
"github.com/v2fly/v2ray-core/v5/common/buf"
)
type ReceivingWindow struct {
cache map[uint32]*DataSegment
}
func NewReceivingWindow() *ReceivingWindow {
return &ReceivingWindow{
cache: make(map[uint32]*DataSegment),
}
}
func (w *ReceivingWindow) Set(id uint32, value *DataSegment) bool {
_, f := w.cache[id]
if f {
return false
}
w.cache[id] = value
return true
}
func (w *ReceivingWindow) Has(id uint32) bool {
_, f := w.cache[id]
return f
}
func (w *ReceivingWindow) Remove(id uint32) *DataSegment {
v, f := w.cache[id]
if !f {
return nil
}
delete(w.cache, id)
return v
}
type AckList struct {
writer SegmentWriter
timestamps []uint32
numbers []uint32
nextFlush []uint32
flushCandidates []uint32
dirty bool
}
func NewAckList(writer SegmentWriter) *AckList {
return &AckList{
writer: writer,
timestamps: make([]uint32, 0, 128),
numbers: make([]uint32, 0, 128),
nextFlush: make([]uint32, 0, 128),
flushCandidates: make([]uint32, 0, 128),
}
}
func (l *AckList) Add(number uint32, timestamp uint32) {
l.timestamps = append(l.timestamps, timestamp)
l.numbers = append(l.numbers, number)
l.nextFlush = append(l.nextFlush, 0)
l.dirty = true
}
func (l *AckList) Clear(una uint32) {
count := 0
for i := 0; i < len(l.numbers); i++ {
if l.numbers[i] < una {
continue
}
if i != count {
l.numbers[count] = l.numbers[i]
l.timestamps[count] = l.timestamps[i]
l.nextFlush[count] = l.nextFlush[i]
}
count++
}
if count < len(l.numbers) {
l.numbers = l.numbers[:count]
l.timestamps = l.timestamps[:count]
l.nextFlush = l.nextFlush[:count]
l.dirty = true
}
}
func (l *AckList) Flush(current uint32, rto uint32) {
l.flushCandidates = l.flushCandidates[:0]
seg := NewAckSegment()
for i := 0; i < len(l.numbers); i++ {
if l.nextFlush[i] > current {
if len(l.flushCandidates) < cap(l.flushCandidates) {
l.flushCandidates = append(l.flushCandidates, l.numbers[i])
}
continue
}
seg.PutNumber(l.numbers[i])
seg.PutTimestamp(l.timestamps[i])
timeout := rto / 2
if timeout < 20 {
timeout = 20
}
l.nextFlush[i] = current + timeout
if seg.IsFull() {
l.writer.Write(seg)
seg.Release()
seg = NewAckSegment()
l.dirty = false
}
}
if l.dirty || !seg.IsEmpty() {
for _, number := range l.flushCandidates {
if seg.IsFull() {
break
}
seg.PutNumber(number)
}
l.writer.Write(seg)
l.dirty = false
}
seg.Release()
}
type ReceivingWorker struct {
sync.RWMutex
conn *Connection
leftOver buf.MultiBuffer
window *ReceivingWindow
acklist *AckList
nextNumber uint32
windowSize uint32
}
func NewReceivingWorker(kcp *Connection) *ReceivingWorker {
worker := &ReceivingWorker{
conn: kcp,
window: NewReceivingWindow(),
windowSize: kcp.Config.GetReceivingInFlightSize(),
}
worker.acklist = NewAckList(worker)
return worker
}
func (w *ReceivingWorker) Release() {
w.Lock()
buf.ReleaseMulti(w.leftOver)
w.leftOver = nil
w.Unlock()
}
func (w *ReceivingWorker) ProcessSendingNext(number uint32) {
w.Lock()
defer w.Unlock()
w.acklist.Clear(number)
}
func (w *ReceivingWorker) ProcessSegment(seg *DataSegment) {
w.Lock()
defer w.Unlock()
number := seg.Number
idx := number - w.nextNumber
if idx >= w.windowSize {
return
}
w.acklist.Clear(seg.SendingNext)
w.acklist.Add(number, seg.Timestamp)
if !w.window.Set(seg.Number, seg) {
seg.Release()
}
}
func (w *ReceivingWorker) ReadMultiBuffer() buf.MultiBuffer {
if w.leftOver != nil {
mb := w.leftOver
w.leftOver = nil
return mb
}
mb := make(buf.MultiBuffer, 0, 32)
w.Lock()
defer w.Unlock()
for {
seg := w.window.Remove(w.nextNumber)
if seg == nil {
break
}
w.nextNumber++
mb = append(mb, seg.Detach())
seg.Release()
}
return mb
}
func (w *ReceivingWorker) Read(b []byte) int {
mb := w.ReadMultiBuffer()
if mb.IsEmpty() {
return 0
}
mb, nBytes := buf.SplitBytes(mb, b)
if !mb.IsEmpty() {
w.leftOver = mb
}
return nBytes
}
func (w *ReceivingWorker) IsDataAvailable() bool {
w.RLock()
defer w.RUnlock()
return w.window.Has(w.nextNumber)
}
func (w *ReceivingWorker) NextNumber() uint32 {
w.RLock()
defer w.RUnlock()
return w.nextNumber
}
func (w *ReceivingWorker) Flush(current uint32) {
w.Lock()
defer w.Unlock()
w.acklist.Flush(current, w.conn.roundTrip.Timeout())
}
func (w *ReceivingWorker) Write(seg Segment) error {
ackSeg := seg.(*AckSegment)
ackSeg.Conv = w.conn.meta.Conversation
ackSeg.ReceivingNext = w.nextNumber
ackSeg.ReceivingWindow = w.nextNumber + w.windowSize
ackSeg.Option = 0
if w.conn.State() == StateReadyToClose {
ackSeg.Option = SegmentOptionClose
}
return w.conn.output.Write(ackSeg)
}
func (*ReceivingWorker) CloseRead() {
}
func (w *ReceivingWorker) UpdateNecessary() bool {
w.RLock()
defer w.RUnlock()
return len(w.acklist.numbers) > 0
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/sending.go | transport/internet/kcp/sending.go | package kcp
import (
"container/list"
"sync"
"github.com/v2fly/v2ray-core/v5/common/buf"
)
type SendingWindow struct {
cache *list.List
totalInFlightSize uint32
writer SegmentWriter
onPacketLoss func(uint32)
}
func NewSendingWindow(writer SegmentWriter, onPacketLoss func(uint32)) *SendingWindow {
window := &SendingWindow{
cache: list.New(),
writer: writer,
onPacketLoss: onPacketLoss,
}
return window
}
func (sw *SendingWindow) Release() {
if sw == nil {
return
}
for sw.cache.Len() > 0 {
seg := sw.cache.Front().Value.(*DataSegment)
seg.Release()
sw.cache.Remove(sw.cache.Front())
}
}
func (sw *SendingWindow) Len() uint32 {
return uint32(sw.cache.Len())
}
func (sw *SendingWindow) IsEmpty() bool {
return sw.cache.Len() == 0
}
func (sw *SendingWindow) Push(number uint32, b *buf.Buffer) {
seg := NewDataSegment()
seg.Number = number
seg.payload = b
sw.cache.PushBack(seg)
}
func (sw *SendingWindow) FirstNumber() uint32 {
return sw.cache.Front().Value.(*DataSegment).Number
}
func (sw *SendingWindow) Clear(una uint32) {
for !sw.IsEmpty() {
seg := sw.cache.Front().Value.(*DataSegment)
if seg.Number >= una {
break
}
seg.Release()
sw.cache.Remove(sw.cache.Front())
}
}
func (sw *SendingWindow) HandleFastAck(number uint32, rto uint32) {
if sw.IsEmpty() {
return
}
sw.Visit(func(seg *DataSegment) bool {
if number == seg.Number || number-seg.Number > 0x7FFFFFFF {
return false
}
if seg.transmit > 0 && seg.timeout > rto/3 {
seg.timeout -= rto / 3
}
return true
})
}
func (sw *SendingWindow) Visit(visitor func(seg *DataSegment) bool) {
if sw.IsEmpty() {
return
}
for e := sw.cache.Front(); e != nil; e = e.Next() {
seg := e.Value.(*DataSegment)
if !visitor(seg) {
break
}
}
}
func (sw *SendingWindow) Flush(current uint32, rto uint32, maxInFlightSize uint32) {
if sw.IsEmpty() {
return
}
var lost uint32
var inFlightSize uint32
sw.Visit(func(segment *DataSegment) bool {
if current-segment.timeout >= 0x7FFFFFFF {
return true
}
if segment.transmit == 0 {
// First time
sw.totalInFlightSize++
} else {
lost++
}
segment.timeout = current + rto
segment.Timestamp = current
segment.transmit++
sw.writer.Write(segment)
inFlightSize++
return inFlightSize < maxInFlightSize
})
if sw.onPacketLoss != nil && inFlightSize > 0 && sw.totalInFlightSize != 0 {
rate := lost * 100 / sw.totalInFlightSize
sw.onPacketLoss(rate)
}
}
func (sw *SendingWindow) Remove(number uint32) bool {
if sw.IsEmpty() {
return false
}
for e := sw.cache.Front(); e != nil; e = e.Next() {
seg := e.Value.(*DataSegment)
if seg.Number > number {
return false
} else if seg.Number == number {
if sw.totalInFlightSize > 0 {
sw.totalInFlightSize--
}
seg.Release()
sw.cache.Remove(e)
return true
}
}
return false
}
type SendingWorker struct {
sync.RWMutex
conn *Connection
window *SendingWindow
firstUnacknowledged uint32
nextNumber uint32
remoteNextNumber uint32
controlWindow uint32
fastResend uint32
windowSize uint32
firstUnacknowledgedUpdated bool
closed bool
}
func NewSendingWorker(kcp *Connection) *SendingWorker {
worker := &SendingWorker{
conn: kcp,
fastResend: 2,
remoteNextNumber: 32,
controlWindow: kcp.Config.GetSendingInFlightSize(),
windowSize: kcp.Config.GetSendingBufferSize(),
}
worker.window = NewSendingWindow(worker, worker.OnPacketLoss)
return worker
}
func (w *SendingWorker) Release() {
w.Lock()
w.window.Release()
w.closed = true
w.Unlock()
}
func (w *SendingWorker) ProcessReceivingNext(nextNumber uint32) {
w.Lock()
defer w.Unlock()
w.ProcessReceivingNextWithoutLock(nextNumber)
}
func (w *SendingWorker) ProcessReceivingNextWithoutLock(nextNumber uint32) {
w.window.Clear(nextNumber)
w.FindFirstUnacknowledged()
}
func (w *SendingWorker) FindFirstUnacknowledged() {
first := w.firstUnacknowledged
if !w.window.IsEmpty() {
w.firstUnacknowledged = w.window.FirstNumber()
} else {
w.firstUnacknowledged = w.nextNumber
}
if first != w.firstUnacknowledged {
w.firstUnacknowledgedUpdated = true
}
}
func (w *SendingWorker) processAck(number uint32) bool {
// number < v.firstUnacknowledged || number >= v.nextNumber
if number-w.firstUnacknowledged > 0x7FFFFFFF || number-w.nextNumber < 0x7FFFFFFF {
return false
}
removed := w.window.Remove(number)
if removed {
w.FindFirstUnacknowledged()
}
return removed
}
func (w *SendingWorker) ProcessSegment(current uint32, seg *AckSegment, rto uint32) {
defer seg.Release()
w.Lock()
defer w.Unlock()
if w.closed {
return
}
if w.remoteNextNumber < seg.ReceivingWindow {
w.remoteNextNumber = seg.ReceivingWindow
}
w.ProcessReceivingNextWithoutLock(seg.ReceivingNext)
if seg.IsEmpty() {
return
}
var maxack uint32
var maxackRemoved bool
for _, number := range seg.NumberList {
removed := w.processAck(number)
if maxack < number {
maxack = number
maxackRemoved = removed
}
}
if maxackRemoved {
w.window.HandleFastAck(maxack, rto)
if current-seg.Timestamp < 10000 {
w.conn.roundTrip.Update(current-seg.Timestamp, current)
}
}
}
func (w *SendingWorker) Push(b *buf.Buffer) bool {
w.Lock()
defer w.Unlock()
if w.closed {
return false
}
if w.window.Len() > w.windowSize {
return false
}
w.window.Push(w.nextNumber, b)
w.nextNumber++
return true
}
func (w *SendingWorker) Write(seg Segment) error {
dataSeg := seg.(*DataSegment)
dataSeg.Conv = w.conn.meta.Conversation
dataSeg.SendingNext = w.firstUnacknowledged
dataSeg.Option = 0
if w.conn.State() == StateReadyToClose {
dataSeg.Option = SegmentOptionClose
}
return w.conn.output.Write(dataSeg)
}
func (w *SendingWorker) OnPacketLoss(lossRate uint32) {
if !w.conn.Config.Congestion || w.conn.roundTrip.Timeout() == 0 {
return
}
if lossRate >= 15 {
w.controlWindow = 3 * w.controlWindow / 4
} else if lossRate <= 5 {
w.controlWindow += w.controlWindow / 4
}
if w.controlWindow < 16 {
w.controlWindow = 16
}
if w.controlWindow > 2*w.conn.Config.GetSendingInFlightSize() {
w.controlWindow = 2 * w.conn.Config.GetSendingInFlightSize()
}
}
func (w *SendingWorker) Flush(current uint32) {
w.Lock()
if w.closed {
w.Unlock()
return
}
cwnd := w.conn.Config.GetSendingInFlightSize()
if cwnd > w.remoteNextNumber-w.firstUnacknowledged {
cwnd = w.remoteNextNumber - w.firstUnacknowledged
}
if w.conn.Config.Congestion && cwnd > w.controlWindow {
cwnd = w.controlWindow
}
cwnd *= 20 // magic
if !w.window.IsEmpty() {
w.window.Flush(current, w.conn.roundTrip.Timeout(), cwnd)
w.firstUnacknowledgedUpdated = false
}
updated := w.firstUnacknowledgedUpdated
w.firstUnacknowledgedUpdated = false
w.Unlock()
if updated {
w.conn.Ping(current, CommandPing)
}
}
func (w *SendingWorker) CloseWrite() {
w.Lock()
defer w.Unlock()
w.window.Clear(0xFFFFFFFF)
}
func (w *SendingWorker) IsEmpty() bool {
w.RLock()
defer w.RUnlock()
return w.window.IsEmpty()
}
func (w *SendingWorker) UpdateNecessary() bool {
return !w.IsEmpty()
}
func (w *SendingWorker) FirstUnacknowledged() uint32 {
w.RLock()
defer w.RUnlock()
return w.firstUnacknowledged
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/io_test.go | transport/internet/kcp/io_test.go | package kcp_test
import (
"testing"
. "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
)
func TestKCPPacketReader(t *testing.T) {
reader := KCPPacketReader{
Security: &SimpleAuthenticator{},
}
testCases := []struct {
Input []byte
Output []Segment
}{
{
Input: []byte{},
Output: nil,
},
{
Input: []byte{1},
Output: nil,
},
}
for _, testCase := range testCases {
seg := reader.Read(testCase.Input)
if testCase.Output == nil && seg != nil {
t.Errorf("Expect nothing returned, but actually %v", seg)
} else if testCase.Output != nil && seg == nil {
t.Errorf("Expect some output, but got nil")
}
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/config.go | transport/internet/kcp/config.go | package kcp
import (
"crypto/cipher"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
const protocolName = "mkcp"
// GetMTUValue returns the value of MTU settings.
func (c *Config) GetMTUValue() uint32 {
if c == nil || c.Mtu == nil {
return 1350
}
return c.Mtu.Value
}
// GetTTIValue returns the value of TTI settings.
func (c *Config) GetTTIValue() uint32 {
if c == nil || c.Tti == nil {
return 50
}
return c.Tti.Value
}
// GetUplinkCapacityValue returns the value of UplinkCapacity settings.
func (c *Config) GetUplinkCapacityValue() uint32 {
if c == nil || c.UplinkCapacity == nil {
return 5
}
return c.UplinkCapacity.Value
}
// GetDownlinkCapacityValue returns the value of DownlinkCapacity settings.
func (c *Config) GetDownlinkCapacityValue() uint32 {
if c == nil || c.DownlinkCapacity == nil {
return 20
}
return c.DownlinkCapacity.Value
}
// GetWriteBufferSize returns the size of WriterBuffer in bytes.
func (c *Config) GetWriteBufferSize() uint32 {
if c == nil || c.WriteBuffer == nil {
return 2 * 1024 * 1024
}
return c.WriteBuffer.Size
}
// GetReadBufferSize returns the size of ReadBuffer in bytes.
func (c *Config) GetReadBufferSize() uint32 {
if c == nil || c.ReadBuffer == nil {
return 2 * 1024 * 1024
}
return c.ReadBuffer.Size
}
// GetSecurity returns the security settings.
func (c *Config) GetSecurity() (cipher.AEAD, error) {
if c.Seed != nil {
return NewAEADAESGCMBasedOnSeed(c.Seed.Seed), nil
}
return NewSimpleAuthenticator(), nil
}
func (c *Config) GetPackerHeader() (internet.PacketHeader, error) {
if c.HeaderConfig != nil {
rawConfig, err := serial.GetInstanceOf(c.HeaderConfig)
if err != nil {
return nil, err
}
return internet.CreatePacketHeader(rawConfig)
}
return nil, nil
}
func (c *Config) GetSendingInFlightSize() uint32 {
size := c.GetUplinkCapacityValue() * 1024 * 1024 / c.GetMTUValue() / (1000 / c.GetTTIValue())
if size < 8 {
size = 8
}
return size
}
func (c *Config) GetSendingBufferSize() uint32 {
return c.GetWriteBufferSize() / c.GetMTUValue()
}
func (c *Config) GetReceivingInFlightSize() uint32 {
size := c.GetDownlinkCapacityValue() * 1024 * 1024 / c.GetMTUValue() / (1000 / c.GetTTIValue())
if size < 8 {
size = 8
}
return size
}
func (c *Config) GetReceivingBufferSize() uint32 {
return c.GetReadBufferSize() / c.GetMTUValue()
}
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/crypt_test.go | transport/internet/kcp/crypt_test.go | package kcp_test
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/v2fly/v2ray-core/v5/common"
. "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
)
func TestSimpleAuthenticator(t *testing.T) {
cache := make([]byte, 512)
payload := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g'}
auth := NewSimpleAuthenticator()
b := auth.Seal(cache[:0], nil, payload, nil)
c, err := auth.Open(cache[:0], nil, b, nil)
common.Must(err)
if r := cmp.Diff(c, payload); r != "" {
t.Error(r)
}
}
func TestSimpleAuthenticator2(t *testing.T) {
cache := make([]byte, 512)
payload := []byte{'a', 'b'}
auth := NewSimpleAuthenticator()
b := auth.Seal(cache[:0], nil, payload, nil)
c, err := auth.Open(cache[:0], nil, b, nil)
common.Must(err)
if r := cmp.Diff(c, payload); r != "" {
t.Error(r)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/connection.go | transport/internet/kcp/connection.go | package kcp
import (
"bytes"
"io"
"net"
"runtime"
"sync"
"sync/atomic"
"time"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/signal"
"github.com/v2fly/v2ray-core/v5/common/signal/semaphore"
)
var (
ErrIOTimeout = newError("Read/Write timeout")
ErrClosedListener = newError("Listener closed.")
ErrClosedConnection = newError("Connection closed.")
)
// State of the connection
type State int32
// Is returns true if current State is one of the candidates.
func (s State) Is(states ...State) bool {
for _, state := range states {
if s == state {
return true
}
}
return false
}
const (
StateActive State = 0 // Connection is active
StateReadyToClose State = 1 // Connection is closed locally
StatePeerClosed State = 2 // Connection is closed on remote
StateTerminating State = 3 // Connection is ready to be destroyed locally
StatePeerTerminating State = 4 // Connection is ready to be destroyed on remote
StateTerminated State = 5 // Connection is destroyed.
)
func nowMillisec() int64 {
now := time.Now()
return now.Unix()*1000 + int64(now.Nanosecond()/1000000)
}
type RoundTripInfo struct {
sync.RWMutex
variation uint32
srtt uint32
rto uint32
minRtt uint32
updatedTimestamp uint32
}
func (info *RoundTripInfo) UpdatePeerRTO(rto uint32, current uint32) {
info.Lock()
defer info.Unlock()
if current-info.updatedTimestamp < 3000 {
return
}
info.updatedTimestamp = current
info.rto = rto
}
func (info *RoundTripInfo) Update(rtt uint32, current uint32) {
if rtt > 0x7FFFFFFF {
return
}
info.Lock()
defer info.Unlock()
// https://tools.ietf.org/html/rfc6298
if info.srtt == 0 {
info.srtt = rtt
info.variation = rtt / 2
} else {
delta := rtt - info.srtt
if info.srtt > rtt {
delta = info.srtt - rtt
}
info.variation = (3*info.variation + delta) / 4
info.srtt = (7*info.srtt + rtt) / 8
if info.srtt < info.minRtt {
info.srtt = info.minRtt
}
}
var rto uint32
if info.minRtt < 4*info.variation {
rto = info.srtt + 4*info.variation
} else {
rto = info.srtt + info.variation
}
if rto > 10000 {
rto = 10000
}
info.rto = rto * 5 / 4
info.updatedTimestamp = current
}
func (info *RoundTripInfo) Timeout() uint32 {
info.RLock()
defer info.RUnlock()
return info.rto
}
func (info *RoundTripInfo) SmoothedTime() uint32 {
info.RLock()
defer info.RUnlock()
return info.srtt
}
type Updater struct {
interval int64
shouldContinue func() bool
shouldTerminate func() bool
updateFunc func()
notifier *semaphore.Instance
}
func NewUpdater(interval uint32, shouldContinue func() bool, shouldTerminate func() bool, updateFunc func()) *Updater {
u := &Updater{
interval: int64(time.Duration(interval) * time.Millisecond),
shouldContinue: shouldContinue,
shouldTerminate: shouldTerminate,
updateFunc: updateFunc,
notifier: semaphore.New(1),
}
return u
}
func (u *Updater) WakeUp() {
select {
case <-u.notifier.Wait():
go u.run()
default:
}
}
func (u *Updater) run() {
defer u.notifier.Signal()
if u.shouldTerminate() {
return
}
ticker := time.NewTicker(u.Interval())
for u.shouldContinue() {
u.updateFunc()
<-ticker.C
}
ticker.Stop()
}
func (u *Updater) Interval() time.Duration {
return time.Duration(atomic.LoadInt64(&u.interval))
}
func (u *Updater) SetInterval(d time.Duration) {
atomic.StoreInt64(&u.interval, int64(d))
}
type ConnMetadata struct {
LocalAddr net.Addr
RemoteAddr net.Addr
Conversation uint16
}
// Connection is a KCP connection over UDP.
type Connection struct {
meta ConnMetadata
closer io.Closer
rd time.Time
wd time.Time // write deadline
since int64
dataInput *signal.Notifier
dataOutput *signal.Notifier
Config *Config
state State
stateBeginTime uint32
lastIncomingTime uint32
lastPingTime uint32
mss uint32
roundTrip *RoundTripInfo
receivingWorker *ReceivingWorker
sendingWorker *SendingWorker
output SegmentWriter
dataUpdater *Updater
pingUpdater *Updater
}
// NewConnection create a new KCP connection between local and remote.
func NewConnection(meta ConnMetadata, writer PacketWriter, closer io.Closer, config *Config) *Connection {
newError("#", meta.Conversation, " creating connection to ", meta.RemoteAddr).WriteToLog()
conn := &Connection{
meta: meta,
closer: closer,
since: nowMillisec(),
dataInput: signal.NewNotifier(),
dataOutput: signal.NewNotifier(),
Config: config,
output: NewRetryableWriter(NewSegmentWriter(writer)),
mss: config.GetMTUValue() - uint32(writer.Overhead()) - DataSegmentOverhead,
roundTrip: &RoundTripInfo{
rto: 100,
minRtt: config.GetTTIValue(),
},
}
conn.receivingWorker = NewReceivingWorker(conn)
conn.sendingWorker = NewSendingWorker(conn)
isTerminating := func() bool {
return conn.State().Is(StateTerminating, StateTerminated)
}
isTerminated := func() bool {
return conn.State() == StateTerminated
}
conn.dataUpdater = NewUpdater(
config.GetTTIValue(),
func() bool {
return !isTerminating() && (conn.sendingWorker.UpdateNecessary() || conn.receivingWorker.UpdateNecessary())
},
isTerminating,
conn.updateTask)
conn.pingUpdater = NewUpdater(
5000, // 5 seconds
func() bool { return !isTerminated() },
isTerminated,
conn.updateTask)
conn.pingUpdater.WakeUp()
return conn
}
func (c *Connection) Elapsed() uint32 {
return uint32(nowMillisec() - c.since)
}
// ReadMultiBuffer implements buf.Reader.
func (c *Connection) ReadMultiBuffer() (buf.MultiBuffer, error) {
if c == nil {
return nil, io.EOF
}
for {
if c.State().Is(StateReadyToClose, StateTerminating, StateTerminated) {
return nil, io.EOF
}
mb := c.receivingWorker.ReadMultiBuffer()
if !mb.IsEmpty() {
c.dataUpdater.WakeUp()
return mb, nil
}
if c.State() == StatePeerTerminating {
return nil, io.EOF
}
if err := c.waitForDataInput(); err != nil {
return nil, err
}
}
}
func (c *Connection) waitForDataInput() error {
for i := 0; i < 16; i++ {
select {
case <-c.dataInput.Wait():
return nil
default:
runtime.Gosched()
}
}
duration := time.Second * 16
if !c.rd.IsZero() {
duration = time.Until(c.rd)
if duration < 0 {
return ErrIOTimeout
}
}
timeout := time.NewTimer(duration)
defer timeout.Stop()
select {
case <-c.dataInput.Wait():
case <-timeout.C:
if !c.rd.IsZero() && c.rd.Before(time.Now()) {
return ErrIOTimeout
}
}
return nil
}
// Read implements the Conn Read method.
func (c *Connection) Read(b []byte) (int, error) {
if c == nil {
return 0, io.EOF
}
for {
if c.State().Is(StateReadyToClose, StateTerminating, StateTerminated) {
return 0, io.EOF
}
nBytes := c.receivingWorker.Read(b)
if nBytes > 0 {
c.dataUpdater.WakeUp()
return nBytes, nil
}
if err := c.waitForDataInput(); err != nil {
return 0, err
}
}
}
func (c *Connection) waitForDataOutput() error {
for i := 0; i < 16; i++ {
select {
case <-c.dataOutput.Wait():
return nil
default:
runtime.Gosched()
}
}
duration := time.Second * 16
if !c.wd.IsZero() {
duration = time.Until(c.wd)
if duration < 0 {
return ErrIOTimeout
}
}
timeout := time.NewTimer(duration)
defer timeout.Stop()
select {
case <-c.dataOutput.Wait():
case <-timeout.C:
if !c.wd.IsZero() && c.wd.Before(time.Now()) {
return ErrIOTimeout
}
}
return nil
}
// Write implements io.Writer.
func (c *Connection) Write(b []byte) (int, error) {
reader := bytes.NewReader(b)
if err := c.writeMultiBufferInternal(reader); err != nil {
return 0, err
}
return len(b), nil
}
// WriteMultiBuffer implements buf.Writer.
func (c *Connection) WriteMultiBuffer(mb buf.MultiBuffer) error {
reader := &buf.MultiBufferContainer{
MultiBuffer: mb,
}
defer reader.Close()
return c.writeMultiBufferInternal(reader)
}
func (c *Connection) writeMultiBufferInternal(reader io.Reader) error {
updatePending := false
defer func() {
if updatePending {
c.dataUpdater.WakeUp()
}
}()
var b *buf.Buffer
defer func() {
b.Release()
}()
for {
for {
if c == nil || c.State() != StateActive {
return io.ErrClosedPipe
}
if b == nil {
b = buf.New()
_, err := b.ReadFrom(io.LimitReader(reader, int64(c.mss)))
if err != nil {
return nil
}
}
if !c.sendingWorker.Push(b) {
break
}
updatePending = true
b = nil
}
if updatePending {
c.dataUpdater.WakeUp()
updatePending = false
}
if err := c.waitForDataOutput(); err != nil {
return err
}
}
}
func (c *Connection) SetState(state State) {
current := c.Elapsed()
atomic.StoreInt32((*int32)(&c.state), int32(state))
atomic.StoreUint32(&c.stateBeginTime, current)
newError("#", c.meta.Conversation, " entering state ", state, " at ", current).AtDebug().WriteToLog()
switch state {
case StateReadyToClose:
c.receivingWorker.CloseRead()
case StatePeerClosed:
c.sendingWorker.CloseWrite()
case StateTerminating:
c.receivingWorker.CloseRead()
c.sendingWorker.CloseWrite()
c.pingUpdater.SetInterval(time.Second)
case StatePeerTerminating:
c.sendingWorker.CloseWrite()
c.pingUpdater.SetInterval(time.Second)
case StateTerminated:
c.receivingWorker.CloseRead()
c.sendingWorker.CloseWrite()
c.pingUpdater.SetInterval(time.Second)
c.dataUpdater.WakeUp()
c.pingUpdater.WakeUp()
go c.Terminate()
}
}
// Close closes the connection.
func (c *Connection) Close() error {
if c == nil {
return ErrClosedConnection
}
c.dataInput.Signal()
c.dataOutput.Signal()
switch c.State() {
case StateReadyToClose, StateTerminating, StateTerminated:
return ErrClosedConnection
case StateActive:
c.SetState(StateReadyToClose)
case StatePeerClosed:
c.SetState(StateTerminating)
case StatePeerTerminating:
c.SetState(StateTerminated)
}
newError("#", c.meta.Conversation, " closing connection to ", c.meta.RemoteAddr).WriteToLog()
return nil
}
// LocalAddr returns the local network address. The Addr returned is shared by all invocations of LocalAddr, so do not modify it.
func (c *Connection) LocalAddr() net.Addr {
if c == nil {
return nil
}
return c.meta.LocalAddr
}
// RemoteAddr returns the remote network address. The Addr returned is shared by all invocations of RemoteAddr, so do not modify it.
func (c *Connection) RemoteAddr() net.Addr {
if c == nil {
return nil
}
return c.meta.RemoteAddr
}
// SetDeadline sets the deadline associated with the listener. A zero time value disables the deadline.
func (c *Connection) SetDeadline(t time.Time) error {
if err := c.SetReadDeadline(t); err != nil {
return err
}
return c.SetWriteDeadline(t)
}
// SetReadDeadline implements the Conn SetReadDeadline method.
func (c *Connection) SetReadDeadline(t time.Time) error {
if c == nil || c.State() != StateActive {
return ErrClosedConnection
}
c.rd = t
return nil
}
// SetWriteDeadline implements the Conn SetWriteDeadline method.
func (c *Connection) SetWriteDeadline(t time.Time) error {
if c == nil || c.State() != StateActive {
return ErrClosedConnection
}
c.wd = t
return nil
}
// kcp update, input loop
func (c *Connection) updateTask() {
c.flush()
}
func (c *Connection) Terminate() {
if c == nil {
return
}
newError("#", c.meta.Conversation, " terminating connection to ", c.RemoteAddr()).WriteToLog()
// v.SetState(StateTerminated)
c.dataInput.Signal()
c.dataOutput.Signal()
c.closer.Close()
c.sendingWorker.Release()
c.receivingWorker.Release()
c.output.Release()
}
func (c *Connection) HandleOption(opt SegmentOption) {
if (opt & SegmentOptionClose) == SegmentOptionClose {
c.OnPeerClosed()
}
}
func (c *Connection) OnPeerClosed() {
switch c.State() {
case StateReadyToClose:
c.SetState(StateTerminating)
case StateActive:
c.SetState(StatePeerClosed)
}
}
// Input when you received a low level packet (eg. UDP packet), call it
func (c *Connection) Input(segments []Segment) {
current := c.Elapsed()
atomic.StoreUint32(&c.lastIncomingTime, current)
for _, seg := range segments {
if seg.Conversation() != c.meta.Conversation {
break
}
switch seg := seg.(type) {
case *DataSegment:
c.HandleOption(seg.Option)
c.receivingWorker.ProcessSegment(seg)
if c.receivingWorker.IsDataAvailable() {
c.dataInput.Signal()
}
c.dataUpdater.WakeUp()
case *AckSegment:
c.HandleOption(seg.Option)
c.sendingWorker.ProcessSegment(current, seg, c.roundTrip.Timeout())
c.dataOutput.Signal()
c.dataUpdater.WakeUp()
case *CmdOnlySegment:
c.HandleOption(seg.Option)
if seg.Command() == CommandTerminate {
switch c.State() {
case StateActive, StatePeerClosed:
c.SetState(StatePeerTerminating)
case StateReadyToClose:
c.SetState(StateTerminating)
case StateTerminating:
c.SetState(StateTerminated)
}
}
if seg.Option == SegmentOptionClose || seg.Command() == CommandTerminate {
c.dataInput.Signal()
c.dataOutput.Signal()
}
c.sendingWorker.ProcessReceivingNext(seg.ReceivingNext)
c.receivingWorker.ProcessSendingNext(seg.SendingNext)
c.roundTrip.UpdatePeerRTO(seg.PeerRTO, current)
seg.Release()
default:
}
}
}
func (c *Connection) flush() {
current := c.Elapsed()
if c.State() == StateTerminated {
return
}
if c.State() == StateActive && current-atomic.LoadUint32(&c.lastIncomingTime) >= 30000 {
c.Close()
}
if c.State() == StateReadyToClose && c.sendingWorker.IsEmpty() {
c.SetState(StateTerminating)
}
if c.State() == StateTerminating {
newError("#", c.meta.Conversation, " sending terminating cmd.").AtDebug().WriteToLog()
c.Ping(current, CommandTerminate)
if current-atomic.LoadUint32(&c.stateBeginTime) > 8000 {
c.SetState(StateTerminated)
}
return
}
if c.State() == StatePeerTerminating && current-atomic.LoadUint32(&c.stateBeginTime) > 4000 {
c.SetState(StateTerminating)
}
if c.State() == StateReadyToClose && current-atomic.LoadUint32(&c.stateBeginTime) > 15000 {
c.SetState(StateTerminating)
}
// flush acknowledges
c.receivingWorker.Flush(current)
c.sendingWorker.Flush(current)
if current-atomic.LoadUint32(&c.lastPingTime) >= 3000 {
c.Ping(current, CommandPing)
}
}
func (c *Connection) State() State {
return State(atomic.LoadInt32((*int32)(&c.state)))
}
func (c *Connection) Ping(current uint32, cmd Command) {
seg := NewCmdOnlySegment()
seg.Conv = c.meta.Conversation
seg.Cmd = cmd
seg.ReceivingNext = c.receivingWorker.NextNumber()
seg.SendingNext = c.sendingWorker.FirstUnacknowledged()
seg.PeerRTO = c.roundTrip.Timeout()
if c.State() == StateReadyToClose {
seg.Option = SegmentOptionClose
}
c.output.Write(seg)
atomic.StoreUint32(&c.lastPingTime, current)
seg.Release()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/segment.go | transport/internet/kcp/segment.go | package kcp
import (
"encoding/binary"
"github.com/v2fly/v2ray-core/v5/common/buf"
)
// Command is a KCP command that indicate the purpose of a Segment.
type Command byte
const (
// CommandACK indicates an AckSegment.
CommandACK Command = 0
// CommandData indicates a DataSegment.
CommandData Command = 1
// CommandTerminate indicates that peer terminates the connection.
CommandTerminate Command = 2
// CommandPing indicates a ping.
CommandPing Command = 3
)
type SegmentOption byte
const (
SegmentOptionClose SegmentOption = 1
)
type Segment interface {
Release()
Conversation() uint16
Command() Command
ByteSize() int32
Serialize([]byte)
parse(conv uint16, cmd Command, opt SegmentOption, buf []byte) (bool, []byte)
}
const (
DataSegmentOverhead = 18
)
type DataSegment struct {
Conv uint16
Option SegmentOption
Timestamp uint32
Number uint32
SendingNext uint32
payload *buf.Buffer
timeout uint32
transmit uint32
}
func NewDataSegment() *DataSegment {
return new(DataSegment)
}
func (s *DataSegment) parse(conv uint16, cmd Command, opt SegmentOption, buf []byte) (bool, []byte) {
s.Conv = conv
s.Option = opt
if len(buf) < 15 {
return false, nil
}
s.Timestamp = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.Number = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.SendingNext = binary.BigEndian.Uint32(buf)
buf = buf[4:]
dataLen := int(binary.BigEndian.Uint16(buf))
buf = buf[2:]
if len(buf) < dataLen {
return false, nil
}
s.Data().Clear()
s.Data().Write(buf[:dataLen])
buf = buf[dataLen:]
return true, buf
}
func (s *DataSegment) Conversation() uint16 {
return s.Conv
}
func (*DataSegment) Command() Command {
return CommandData
}
func (s *DataSegment) Detach() *buf.Buffer {
r := s.payload
s.payload = nil
return r
}
func (s *DataSegment) Data() *buf.Buffer {
if s.payload == nil {
s.payload = buf.New()
}
return s.payload
}
func (s *DataSegment) Serialize(b []byte) {
binary.BigEndian.PutUint16(b, s.Conv)
b[2] = byte(CommandData)
b[3] = byte(s.Option)
binary.BigEndian.PutUint32(b[4:], s.Timestamp)
binary.BigEndian.PutUint32(b[8:], s.Number)
binary.BigEndian.PutUint32(b[12:], s.SendingNext)
binary.BigEndian.PutUint16(b[16:], uint16(s.payload.Len()))
copy(b[18:], s.payload.Bytes())
}
func (s *DataSegment) ByteSize() int32 {
return 2 + 1 + 1 + 4 + 4 + 4 + 2 + s.payload.Len()
}
func (s *DataSegment) Release() {
s.payload.Release()
s.payload = nil
}
type AckSegment struct {
Conv uint16
Option SegmentOption
ReceivingWindow uint32
ReceivingNext uint32
Timestamp uint32
NumberList []uint32
}
const ackNumberLimit = 128
func NewAckSegment() *AckSegment {
return new(AckSegment)
}
func (s *AckSegment) parse(conv uint16, cmd Command, opt SegmentOption, buf []byte) (bool, []byte) {
s.Conv = conv
s.Option = opt
if len(buf) < 13 {
return false, nil
}
s.ReceivingWindow = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.ReceivingNext = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.Timestamp = binary.BigEndian.Uint32(buf)
buf = buf[4:]
count := int(buf[0])
buf = buf[1:]
if len(buf) < count*4 {
return false, nil
}
for i := 0; i < count; i++ {
s.PutNumber(binary.BigEndian.Uint32(buf))
buf = buf[4:]
}
return true, buf
}
func (s *AckSegment) Conversation() uint16 {
return s.Conv
}
func (*AckSegment) Command() Command {
return CommandACK
}
func (s *AckSegment) PutTimestamp(timestamp uint32) {
if timestamp-s.Timestamp < 0x7FFFFFFF {
s.Timestamp = timestamp
}
}
func (s *AckSegment) PutNumber(number uint32) {
s.NumberList = append(s.NumberList, number)
}
func (s *AckSegment) IsFull() bool {
return len(s.NumberList) == ackNumberLimit
}
func (s *AckSegment) IsEmpty() bool {
return len(s.NumberList) == 0
}
func (s *AckSegment) ByteSize() int32 {
return 2 + 1 + 1 + 4 + 4 + 4 + 1 + int32(len(s.NumberList)*4)
}
func (s *AckSegment) Serialize(b []byte) {
binary.BigEndian.PutUint16(b, s.Conv)
b[2] = byte(CommandACK)
b[3] = byte(s.Option)
binary.BigEndian.PutUint32(b[4:], s.ReceivingWindow)
binary.BigEndian.PutUint32(b[8:], s.ReceivingNext)
binary.BigEndian.PutUint32(b[12:], s.Timestamp)
b[16] = byte(len(s.NumberList))
n := 17
for _, number := range s.NumberList {
binary.BigEndian.PutUint32(b[n:], number)
n += 4
}
}
func (s *AckSegment) Release() {}
type CmdOnlySegment struct {
Conv uint16
Cmd Command
Option SegmentOption
SendingNext uint32
ReceivingNext uint32
PeerRTO uint32
}
func NewCmdOnlySegment() *CmdOnlySegment {
return new(CmdOnlySegment)
}
func (s *CmdOnlySegment) parse(conv uint16, cmd Command, opt SegmentOption, buf []byte) (bool, []byte) {
s.Conv = conv
s.Cmd = cmd
s.Option = opt
if len(buf) < 12 {
return false, nil
}
s.SendingNext = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.ReceivingNext = binary.BigEndian.Uint32(buf)
buf = buf[4:]
s.PeerRTO = binary.BigEndian.Uint32(buf)
buf = buf[4:]
return true, buf
}
func (s *CmdOnlySegment) Conversation() uint16 {
return s.Conv
}
func (s *CmdOnlySegment) Command() Command {
return s.Cmd
}
func (*CmdOnlySegment) ByteSize() int32 {
return 2 + 1 + 1 + 4 + 4 + 4
}
func (s *CmdOnlySegment) Serialize(b []byte) {
binary.BigEndian.PutUint16(b, s.Conv)
b[2] = byte(s.Cmd)
b[3] = byte(s.Option)
binary.BigEndian.PutUint32(b[4:], s.SendingNext)
binary.BigEndian.PutUint32(b[8:], s.ReceivingNext)
binary.BigEndian.PutUint32(b[12:], s.PeerRTO)
}
func (*CmdOnlySegment) Release() {}
func ReadSegment(buf []byte) (Segment, []byte) {
if len(buf) < 4 {
return nil, nil
}
conv := binary.BigEndian.Uint16(buf)
buf = buf[2:]
cmd := Command(buf[0])
opt := SegmentOption(buf[1])
buf = buf[2:]
var seg Segment
switch cmd {
case CommandData:
seg = NewDataSegment()
case CommandACK:
seg = NewAckSegment()
default:
seg = NewCmdOnlySegment()
}
valid, extra := seg.parse(conv, cmd, opt, buf)
if !valid {
return nil, nil
}
return seg, extra
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/connection_test.go | transport/internet/kcp/connection_test.go | package kcp_test
import (
"io"
"testing"
"time"
"github.com/v2fly/v2ray-core/v5/common/buf"
. "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
)
type NoOpCloser int
func (NoOpCloser) Close() error {
return nil
}
func TestConnectionReadTimeout(t *testing.T) {
conn := NewConnection(ConnMetadata{Conversation: 1}, &KCPPacketWriter{
Writer: buf.DiscardBytes,
}, NoOpCloser(0), &Config{})
conn.SetReadDeadline(time.Now().Add(time.Second))
b := make([]byte, 1024)
nBytes, err := conn.Read(b)
if nBytes != 0 || err == nil {
t.Error("unexpected read: ", nBytes, err)
}
conn.Terminate()
}
func TestConnectionInterface(t *testing.T) {
_ = (io.Writer)(new(Connection))
_ = (io.Reader)(new(Connection))
_ = (buf.Reader)(new(Connection))
_ = (buf.Writer)(new(Connection))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/io.go | transport/internet/kcp/io.go | package kcp
import (
"crypto/cipher"
"crypto/rand"
"io"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
type PacketReader interface {
Read([]byte) []Segment
}
type PacketWriter interface {
Overhead() int
io.Writer
}
type KCPPacketReader struct { // nolint: revive
Security cipher.AEAD
Header internet.PacketHeader
}
func (r *KCPPacketReader) Read(b []byte) []Segment {
if r.Header != nil {
if int32(len(b)) <= r.Header.Size() {
return nil
}
b = b[r.Header.Size():]
}
if r.Security != nil {
nonceSize := r.Security.NonceSize()
overhead := r.Security.Overhead()
if len(b) <= nonceSize+overhead {
return nil
}
out, err := r.Security.Open(b[nonceSize:nonceSize], b[:nonceSize], b[nonceSize:], nil)
if err != nil {
return nil
}
b = out
}
var result []Segment
for len(b) > 0 {
seg, x := ReadSegment(b)
if seg == nil {
break
}
result = append(result, seg)
b = x
}
return result
}
type KCPPacketWriter struct { // nolint: revive
Header internet.PacketHeader
Security cipher.AEAD
Writer io.Writer
}
func (w *KCPPacketWriter) Overhead() int {
overhead := 0
if w.Header != nil {
overhead += int(w.Header.Size())
}
if w.Security != nil {
overhead += w.Security.Overhead()
}
return overhead
}
func (w *KCPPacketWriter) Write(b []byte) (int, error) {
bb := buf.StackNew()
defer bb.Release()
if w.Header != nil {
w.Header.Serialize(bb.Extend(w.Header.Size()))
}
if w.Security != nil {
nonceSize := w.Security.NonceSize()
common.Must2(bb.ReadFullFrom(rand.Reader, int32(nonceSize)))
nonce := bb.BytesFrom(int32(-nonceSize))
encrypted := bb.Extend(int32(w.Security.Overhead() + len(b)))
w.Security.Seal(encrypted[:0], nonce, b, nil)
} else {
bb.Write(b)
}
_, err := w.Writer.Write(bb.Bytes())
return len(b), err
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/xor_amd64.go | transport/internet/kcp/xor_amd64.go | package kcp
//go:noescape
func xorfwd(x []byte)
//go:noescape
func xorbkd(x []byte)
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/cryptreal.go | transport/internet/kcp/cryptreal.go | package kcp
import (
"crypto/aes"
"crypto/cipher"
"crypto/sha256"
"github.com/v2fly/v2ray-core/v5/common"
)
func NewAEADAESGCMBasedOnSeed(seed string) cipher.AEAD {
hashedSeed := sha256.Sum256([]byte(seed))
aesBlock := common.Must2(aes.NewCipher(hashedSeed[:16])).(cipher.Block)
return common.Must2(cipher.NewGCM(aesBlock)).(cipher.AEAD)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/kcp_test.go | transport/internet/kcp/kcp_test.go | package kcp_test
import (
"context"
"crypto/rand"
"io"
"testing"
"time"
"github.com/v2fly/v2ray-core/v5/common/environment/deferredpersistentstorage"
"github.com/v2fly/v2ray-core/v5/common/environment/filesystemimpl"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/environment/systemnetworkimpl"
"github.com/v2fly/v2ray-core/v5/common/environment/transientstorageimpl"
"github.com/google/go-cmp/cmp"
"golang.org/x/sync/errgroup"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/errors"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
. "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
)
func TestDialAndListen(t *testing.T) {
ctx := context.Background()
defaultNetworkImpl := systemnetworkimpl.NewSystemNetworkDefault()
defaultFilesystemImpl := filesystemimpl.NewDefaultFileSystemDefaultImpl()
deferredPersistentStorageImpl := deferredpersistentstorage.NewDeferredPersistentStorage(ctx)
rootEnv := environment.NewRootEnvImpl(ctx,
transientstorageimpl.NewScopedTransientStorageImpl(), defaultNetworkImpl.Dialer(), defaultNetworkImpl.Listener(),
defaultFilesystemImpl, deferredPersistentStorageImpl)
proxyEnvironment := rootEnv.ProxyEnvironment("o")
transportEnvironment, err := proxyEnvironment.NarrowScopeToTransport("kcp")
if err != nil {
t.Fatal(err)
}
ctx = envctx.ContextWithEnvironment(ctx, transportEnvironment)
listener, err := NewListener(ctx, net.LocalHostIP, net.Port(0), &internet.MemoryStreamConfig{
ProtocolName: "mkcp",
ProtocolSettings: &Config{},
}, func(conn internet.Connection) {
go func(c internet.Connection) {
payload := make([]byte, 4096)
for {
nBytes, err := c.Read(payload)
if err != nil {
break
}
for idx, b := range payload[:nBytes] {
payload[idx] = b ^ 'c'
}
c.Write(payload[:nBytes])
}
c.Close()
}(conn)
})
common.Must(err)
defer listener.Close()
port := net.Port(listener.Addr().(*net.UDPAddr).Port)
var errg errgroup.Group
for i := 0; i < 10; i++ {
errg.Go(func() error {
clientConn, err := DialKCP(ctx, net.UDPDestination(net.LocalHostIP, port), &internet.MemoryStreamConfig{
ProtocolName: "mkcp",
ProtocolSettings: &Config{},
})
if err != nil {
return err
}
defer clientConn.Close()
clientSend := make([]byte, 1024*1024)
rand.Read(clientSend)
go clientConn.Write(clientSend)
clientReceived := make([]byte, 1024*1024)
common.Must2(io.ReadFull(clientConn, clientReceived))
clientExpected := make([]byte, 1024*1024)
for idx, b := range clientSend {
clientExpected[idx] = b ^ 'c'
}
if r := cmp.Diff(clientReceived, clientExpected); r != "" {
return errors.New(r)
}
return nil
})
}
if err := errg.Wait(); err != nil {
t.Fatal(err)
}
for i := 0; i < 60 && listener.ActiveConnections() > 0; i++ {
time.Sleep(500 * time.Millisecond)
}
if v := listener.ActiveConnections(); v != 0 {
t.Error("active connections: ", v)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/config.pb.go | transport/internet/kcp/config.pb.go | package kcp
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Maximum Transmission Unit, in bytes.
type MTU struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *MTU) Reset() {
*x = MTU{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MTU) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MTU) ProtoMessage() {}
func (x *MTU) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MTU.ProtoReflect.Descriptor instead.
func (*MTU) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{0}
}
func (x *MTU) GetValue() uint32 {
if x != nil {
return x.Value
}
return 0
}
// Transmission Time Interview, in milli-sec.
type TTI struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TTI) Reset() {
*x = TTI{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TTI) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TTI) ProtoMessage() {}
func (x *TTI) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TTI.ProtoReflect.Descriptor instead.
func (*TTI) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{1}
}
func (x *TTI) GetValue() uint32 {
if x != nil {
return x.Value
}
return 0
}
// Uplink capacity, in MB.
type UplinkCapacity struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *UplinkCapacity) Reset() {
*x = UplinkCapacity{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *UplinkCapacity) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UplinkCapacity) ProtoMessage() {}
func (x *UplinkCapacity) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UplinkCapacity.ProtoReflect.Descriptor instead.
func (*UplinkCapacity) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{2}
}
func (x *UplinkCapacity) GetValue() uint32 {
if x != nil {
return x.Value
}
return 0
}
// Downlink capacity, in MB.
type DownlinkCapacity struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *DownlinkCapacity) Reset() {
*x = DownlinkCapacity{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *DownlinkCapacity) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DownlinkCapacity) ProtoMessage() {}
func (x *DownlinkCapacity) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DownlinkCapacity.ProtoReflect.Descriptor instead.
func (*DownlinkCapacity) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{3}
}
func (x *DownlinkCapacity) GetValue() uint32 {
if x != nil {
return x.Value
}
return 0
}
type WriteBuffer struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Buffer size in bytes.
Size uint32 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *WriteBuffer) Reset() {
*x = WriteBuffer{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WriteBuffer) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WriteBuffer) ProtoMessage() {}
func (x *WriteBuffer) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use WriteBuffer.ProtoReflect.Descriptor instead.
func (*WriteBuffer) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{4}
}
func (x *WriteBuffer) GetSize() uint32 {
if x != nil {
return x.Size
}
return 0
}
type ReadBuffer struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Buffer size in bytes.
Size uint32 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ReadBuffer) Reset() {
*x = ReadBuffer{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ReadBuffer) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReadBuffer) ProtoMessage() {}
func (x *ReadBuffer) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ReadBuffer.ProtoReflect.Descriptor instead.
func (*ReadBuffer) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{5}
}
func (x *ReadBuffer) GetSize() uint32 {
if x != nil {
return x.Size
}
return 0
}
type ConnectionReuse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Enable bool `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ConnectionReuse) Reset() {
*x = ConnectionReuse{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ConnectionReuse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ConnectionReuse) ProtoMessage() {}
func (x *ConnectionReuse) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ConnectionReuse.ProtoReflect.Descriptor instead.
func (*ConnectionReuse) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{6}
}
func (x *ConnectionReuse) GetEnable() bool {
if x != nil {
return x.Enable
}
return false
}
// Maximum Transmission Unit, in bytes.
type EncryptionSeed struct {
state protoimpl.MessageState `protogen:"open.v1"`
Seed string `protobuf:"bytes,1,opt,name=seed,proto3" json:"seed,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EncryptionSeed) Reset() {
*x = EncryptionSeed{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EncryptionSeed) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EncryptionSeed) ProtoMessage() {}
func (x *EncryptionSeed) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[7]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EncryptionSeed.ProtoReflect.Descriptor instead.
func (*EncryptionSeed) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{7}
}
func (x *EncryptionSeed) GetSeed() string {
if x != nil {
return x.Seed
}
return ""
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Mtu *MTU `protobuf:"bytes,1,opt,name=mtu,proto3" json:"mtu,omitempty"`
Tti *TTI `protobuf:"bytes,2,opt,name=tti,proto3" json:"tti,omitempty"`
UplinkCapacity *UplinkCapacity `protobuf:"bytes,3,opt,name=uplink_capacity,json=uplinkCapacity,proto3" json:"uplink_capacity,omitempty"`
DownlinkCapacity *DownlinkCapacity `protobuf:"bytes,4,opt,name=downlink_capacity,json=downlinkCapacity,proto3" json:"downlink_capacity,omitempty"`
Congestion bool `protobuf:"varint,5,opt,name=congestion,proto3" json:"congestion,omitempty"`
WriteBuffer *WriteBuffer `protobuf:"bytes,6,opt,name=write_buffer,json=writeBuffer,proto3" json:"write_buffer,omitempty"`
ReadBuffer *ReadBuffer `protobuf:"bytes,7,opt,name=read_buffer,json=readBuffer,proto3" json:"read_buffer,omitempty"`
HeaderConfig *anypb.Any `protobuf:"bytes,8,opt,name=header_config,json=headerConfig,proto3" json:"header_config,omitempty"`
Seed *EncryptionSeed `protobuf:"bytes,10,opt,name=seed,proto3" json:"seed,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_kcp_config_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_kcp_config_proto_msgTypes[8]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_kcp_config_proto_rawDescGZIP(), []int{8}
}
func (x *Config) GetMtu() *MTU {
if x != nil {
return x.Mtu
}
return nil
}
func (x *Config) GetTti() *TTI {
if x != nil {
return x.Tti
}
return nil
}
func (x *Config) GetUplinkCapacity() *UplinkCapacity {
if x != nil {
return x.UplinkCapacity
}
return nil
}
func (x *Config) GetDownlinkCapacity() *DownlinkCapacity {
if x != nil {
return x.DownlinkCapacity
}
return nil
}
func (x *Config) GetCongestion() bool {
if x != nil {
return x.Congestion
}
return false
}
func (x *Config) GetWriteBuffer() *WriteBuffer {
if x != nil {
return x.WriteBuffer
}
return nil
}
func (x *Config) GetReadBuffer() *ReadBuffer {
if x != nil {
return x.ReadBuffer
}
return nil
}
func (x *Config) GetHeaderConfig() *anypb.Any {
if x != nil {
return x.HeaderConfig
}
return nil
}
func (x *Config) GetSeed() *EncryptionSeed {
if x != nil {
return x.Seed
}
return nil
}
var File_transport_internet_kcp_config_proto protoreflect.FileDescriptor
const file_transport_internet_kcp_config_proto_rawDesc = "" +
"\n" +
"#transport/internet/kcp/config.proto\x12!v2ray.core.transport.internet.kcp\x1a\x19google/protobuf/any.proto\x1a common/protoext/extensions.proto\"\x1b\n" +
"\x03MTU\x12\x14\n" +
"\x05value\x18\x01 \x01(\rR\x05value\"\x1b\n" +
"\x03TTI\x12\x14\n" +
"\x05value\x18\x01 \x01(\rR\x05value\"&\n" +
"\x0eUplinkCapacity\x12\x14\n" +
"\x05value\x18\x01 \x01(\rR\x05value\"(\n" +
"\x10DownlinkCapacity\x12\x14\n" +
"\x05value\x18\x01 \x01(\rR\x05value\"!\n" +
"\vWriteBuffer\x12\x12\n" +
"\x04size\x18\x01 \x01(\rR\x04size\" \n" +
"\n" +
"ReadBuffer\x12\x12\n" +
"\x04size\x18\x01 \x01(\rR\x04size\")\n" +
"\x0fConnectionReuse\x12\x16\n" +
"\x06enable\x18\x01 \x01(\bR\x06enable\"$\n" +
"\x0eEncryptionSeed\x12\x12\n" +
"\x04seed\x18\x01 \x01(\tR\x04seed\"\xa7\x05\n" +
"\x06Config\x128\n" +
"\x03mtu\x18\x01 \x01(\v2&.v2ray.core.transport.internet.kcp.MTUR\x03mtu\x128\n" +
"\x03tti\x18\x02 \x01(\v2&.v2ray.core.transport.internet.kcp.TTIR\x03tti\x12Z\n" +
"\x0fuplink_capacity\x18\x03 \x01(\v21.v2ray.core.transport.internet.kcp.UplinkCapacityR\x0euplinkCapacity\x12`\n" +
"\x11downlink_capacity\x18\x04 \x01(\v23.v2ray.core.transport.internet.kcp.DownlinkCapacityR\x10downlinkCapacity\x12\x1e\n" +
"\n" +
"congestion\x18\x05 \x01(\bR\n" +
"congestion\x12Q\n" +
"\fwrite_buffer\x18\x06 \x01(\v2..v2ray.core.transport.internet.kcp.WriteBufferR\vwriteBuffer\x12N\n" +
"\vread_buffer\x18\a \x01(\v2-.v2ray.core.transport.internet.kcp.ReadBufferR\n" +
"readBuffer\x129\n" +
"\rheader_config\x18\b \x01(\v2\x14.google.protobuf.AnyR\fheaderConfig\x12E\n" +
"\x04seed\x18\n" +
" \x01(\v21.v2ray.core.transport.internet.kcp.EncryptionSeedR\x04seed: \x82\xb5\x18\x1c\n" +
"\ttransport\x12\x03kcp\x8a\xff)\x04mkcp\x90\xff)\x01J\x04\b\t\x10\n" +
"B\x84\x01\n" +
"%com.v2ray.core.transport.internet.kcpP\x01Z5github.com/v2fly/v2ray-core/v5/transport/internet/kcp\xaa\x02!V2Ray.Core.Transport.Internet.Kcpb\x06proto3"
var (
file_transport_internet_kcp_config_proto_rawDescOnce sync.Once
file_transport_internet_kcp_config_proto_rawDescData []byte
)
func file_transport_internet_kcp_config_proto_rawDescGZIP() []byte {
file_transport_internet_kcp_config_proto_rawDescOnce.Do(func() {
file_transport_internet_kcp_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_kcp_config_proto_rawDesc), len(file_transport_internet_kcp_config_proto_rawDesc)))
})
return file_transport_internet_kcp_config_proto_rawDescData
}
var file_transport_internet_kcp_config_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_transport_internet_kcp_config_proto_goTypes = []any{
(*MTU)(nil), // 0: v2ray.core.transport.internet.kcp.MTU
(*TTI)(nil), // 1: v2ray.core.transport.internet.kcp.TTI
(*UplinkCapacity)(nil), // 2: v2ray.core.transport.internet.kcp.UplinkCapacity
(*DownlinkCapacity)(nil), // 3: v2ray.core.transport.internet.kcp.DownlinkCapacity
(*WriteBuffer)(nil), // 4: v2ray.core.transport.internet.kcp.WriteBuffer
(*ReadBuffer)(nil), // 5: v2ray.core.transport.internet.kcp.ReadBuffer
(*ConnectionReuse)(nil), // 6: v2ray.core.transport.internet.kcp.ConnectionReuse
(*EncryptionSeed)(nil), // 7: v2ray.core.transport.internet.kcp.EncryptionSeed
(*Config)(nil), // 8: v2ray.core.transport.internet.kcp.Config
(*anypb.Any)(nil), // 9: google.protobuf.Any
}
var file_transport_internet_kcp_config_proto_depIdxs = []int32{
0, // 0: v2ray.core.transport.internet.kcp.Config.mtu:type_name -> v2ray.core.transport.internet.kcp.MTU
1, // 1: v2ray.core.transport.internet.kcp.Config.tti:type_name -> v2ray.core.transport.internet.kcp.TTI
2, // 2: v2ray.core.transport.internet.kcp.Config.uplink_capacity:type_name -> v2ray.core.transport.internet.kcp.UplinkCapacity
3, // 3: v2ray.core.transport.internet.kcp.Config.downlink_capacity:type_name -> v2ray.core.transport.internet.kcp.DownlinkCapacity
4, // 4: v2ray.core.transport.internet.kcp.Config.write_buffer:type_name -> v2ray.core.transport.internet.kcp.WriteBuffer
5, // 5: v2ray.core.transport.internet.kcp.Config.read_buffer:type_name -> v2ray.core.transport.internet.kcp.ReadBuffer
9, // 6: v2ray.core.transport.internet.kcp.Config.header_config:type_name -> google.protobuf.Any
7, // 7: v2ray.core.transport.internet.kcp.Config.seed:type_name -> v2ray.core.transport.internet.kcp.EncryptionSeed
8, // [8:8] is the sub-list for method output_type
8, // [8:8] is the sub-list for method input_type
8, // [8:8] is the sub-list for extension type_name
8, // [8:8] is the sub-list for extension extendee
0, // [0:8] is the sub-list for field type_name
}
func init() { file_transport_internet_kcp_config_proto_init() }
func file_transport_internet_kcp_config_proto_init() {
if File_transport_internet_kcp_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_kcp_config_proto_rawDesc), len(file_transport_internet_kcp_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 9,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_kcp_config_proto_goTypes,
DependencyIndexes: file_transport_internet_kcp_config_proto_depIdxs,
MessageInfos: file_transport_internet_kcp_config_proto_msgTypes,
}.Build()
File_transport_internet_kcp_config_proto = out.File
file_transport_internet_kcp_config_proto_goTypes = nil
file_transport_internet_kcp_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/kcp.go | transport/internet/kcp/kcp.go | // Package kcp - A Fast and Reliable ARQ Protocol
//
// Acknowledgement:
//
// skywind3000@github for inventing the KCP protocol
// xtaci@github for translating to Golang
package kcp
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/output.go | transport/internet/kcp/output.go | package kcp
import (
"io"
"sync"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/retry"
)
type SegmentWriter interface {
Write(seg Segment) error
Release()
}
type SimpleSegmentWriter struct {
sync.Mutex
buffer *buf.Buffer
writer io.Writer
closed bool
}
func NewSegmentWriter(writer io.Writer) SegmentWriter {
return &SimpleSegmentWriter{
writer: writer,
buffer: buf.New(),
}
}
func (w *SimpleSegmentWriter) Write(seg Segment) error {
w.Lock()
defer w.Unlock()
if w.closed {
return io.ErrClosedPipe
}
w.buffer.Clear()
rawBytes := w.buffer.Extend(seg.ByteSize())
seg.Serialize(rawBytes)
_, err := w.writer.Write(w.buffer.Bytes())
return err
}
func (w *SimpleSegmentWriter) Release() {
w.Lock()
defer w.Unlock()
w.buffer.Release()
w.closed = true
}
type RetryableWriter struct {
writer SegmentWriter
}
func NewRetryableWriter(writer SegmentWriter) SegmentWriter {
return &RetryableWriter{
writer: writer,
}
}
func (w *RetryableWriter) Write(seg Segment) error {
return retry.Timed(5, 100).On(func() error {
return w.writer.Write(seg)
})
}
func (w *RetryableWriter) Release() {
w.writer.Release()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/segment_test.go | transport/internet/kcp/segment_test.go | package kcp_test
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
. "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
)
func TestBadSegment(t *testing.T) {
seg, buf := ReadSegment(nil)
if seg != nil {
t.Error("non-nil seg")
}
if len(buf) != 0 {
t.Error("buf len: ", len(buf))
}
}
func TestDataSegment(t *testing.T) {
seg := &DataSegment{
Conv: 1,
Timestamp: 3,
Number: 4,
SendingNext: 5,
}
seg.Data().Write([]byte{'a', 'b', 'c', 'd'})
nBytes := seg.ByteSize()
bytes := make([]byte, nBytes)
seg.Serialize(bytes)
iseg, _ := ReadSegment(bytes)
seg2 := iseg.(*DataSegment)
if r := cmp.Diff(seg2, seg, cmpopts.IgnoreUnexported(DataSegment{})); r != "" {
t.Error(r)
}
if r := cmp.Diff(seg2.Data().Bytes(), seg.Data().Bytes()); r != "" {
t.Error(r)
}
}
func Test1ByteDataSegment(t *testing.T) {
seg := &DataSegment{
Conv: 1,
Timestamp: 3,
Number: 4,
SendingNext: 5,
}
seg.Data().WriteByte('a')
nBytes := seg.ByteSize()
bytes := make([]byte, nBytes)
seg.Serialize(bytes)
iseg, _ := ReadSegment(bytes)
seg2 := iseg.(*DataSegment)
if r := cmp.Diff(seg2, seg, cmpopts.IgnoreUnexported(DataSegment{})); r != "" {
t.Error(r)
}
if r := cmp.Diff(seg2.Data().Bytes(), seg.Data().Bytes()); r != "" {
t.Error(r)
}
}
func TestACKSegment(t *testing.T) {
seg := &AckSegment{
Conv: 1,
ReceivingWindow: 2,
ReceivingNext: 3,
Timestamp: 10,
NumberList: []uint32{1, 3, 5, 7, 9},
}
nBytes := seg.ByteSize()
bytes := make([]byte, nBytes)
seg.Serialize(bytes)
iseg, _ := ReadSegment(bytes)
seg2 := iseg.(*AckSegment)
if r := cmp.Diff(seg2, seg); r != "" {
t.Error(r)
}
}
func TestCmdSegment(t *testing.T) {
seg := &CmdOnlySegment{
Conv: 1,
Cmd: CommandPing,
Option: SegmentOptionClose,
SendingNext: 11,
ReceivingNext: 13,
PeerRTO: 15,
}
nBytes := seg.ByteSize()
bytes := make([]byte, nBytes)
seg.Serialize(bytes)
iseg, _ := ReadSegment(bytes)
seg2 := iseg.(*CmdOnlySegment)
if r := cmp.Diff(seg2, seg); r != "" {
t.Error(r)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/kcp/xor.go | transport/internet/kcp/xor.go | //go:build !amd64
// +build !amd64
package kcp
// xorfwd performs XOR forwards in words, x[i] ^= x[i-4], i from 0 to len
func xorfwd(x []byte) {
for i := 4; i < len(x); i++ {
x[i] ^= x[i-4]
}
}
// xorbkd performs XOR backwords in words, x[i] ^= x[i-4], i from len to 0
func xorbkd(x []byte) {
for i := len(x) - 1; i >= 4; i-- {
x[i] ^= x[i-4]
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/request.go | transport/internet/request/request.go | package request
import (
"context"
"github.com/v2fly/v2ray-core/v5/common/net"
)
type TransportClientAssembly interface {
Tripper() Tripper
AutoImplDialer() Dialer
}
type TransportClientAssemblyReceiver interface {
OnTransportClientAssemblyReady(TransportClientAssembly)
}
type TransportServerAssembly interface {
TripperReceiver() TripperReceiver
SessionReceiver() SessionReceiver
AutoImplListener() Listener
}
type TransportServerAssemblyReceiver interface {
OnTransportServerAssemblyReady(TransportServerAssembly)
}
type SessionCreator interface {
NewSession(ctx context.Context, opts ...SessionOption) (Session, error)
}
type SessionReceiver interface {
OnNewSession(ctx context.Context, sess Session, opts ...SessionOption) error
}
type Dialer interface {
Dial(ctx context.Context) (net.Conn, error)
}
type Listener interface {
Listen(ctx context.Context) (net.Listener, error)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/reverser.go | transport/internet/request/reverser.go | package request
import "context"
type ReverserImpl interface {
OnOtherRoundTrip(ctx context.Context, req Request, opts ...RoundTripperOption) (resp Response, err error)
OnAuthenticatedServerIntentRoundTrip(ctx context.Context, serverPublic []byte, req Request, opts ...RoundTripperOption) (resp Response, err error)
}
type ReverserAccessChecker interface {
CheckReverserAccess(ctx context.Context, serverKey []byte) (clientKey []byte, err error)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler.go | transport/internet/request/assembler.go | package request
import (
"io"
)
type SessionAssemblerClient interface {
SessionCreator
TransportClientAssemblyReceiver
}
type SessionAssemblerServer interface {
TripperReceiver
TransportServerAssemblyReceiver
}
type SessionOption interface {
RoundTripperOption()
}
type Session interface {
io.ReadWriteCloser
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripper.go | transport/internet/request/roundtripper.go | package request
import (
"context"
"io"
"github.com/v2fly/v2ray-core/v5/common"
)
type RoundTripperClient interface {
Tripper
TransportClientAssemblyReceiver
}
type RoundTripperServer interface {
common.Runnable
TransportServerAssemblyReceiver
}
type Tripper interface {
RoundTrip(ctx context.Context, req Request, opts ...RoundTripperOption) (resp Response, err error)
}
type TripperReceiver interface {
OnRoundTrip(ctx context.Context, req Request, opts ...RoundTripperOption) (resp Response, err error)
}
type RoundTripperOption interface {
RoundTripperOption()
}
type Request struct {
Data []byte
ConnectionTag []byte
}
type Response struct {
Data []byte
}
type OptionSupportsStreamingResponse interface {
RoundTripperOption
GetResponseWriter() io.Writer
}
type OptionSupportsStreamingResponseExtensionFlusher interface {
Flush()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/options.go | transport/internet/request/options.go | package request
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/simple/errors.generated.go | transport/internet/request/assembler/simple/errors.generated.go | package simple
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/simple/client.go | transport/internet/request/assembler/simple/client.go | package simple
import (
"bytes"
"context"
"crypto/rand"
"io"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
func newClient(config *ClientConfig) request.SessionAssemblerClient {
return &simpleAssemblerClient{config: config}
}
type simpleAssemblerClient struct {
assembly request.TransportClientAssembly
config *ClientConfig
}
func (s *simpleAssemblerClient) OnTransportClientAssemblyReady(assembly request.TransportClientAssembly) {
s.assembly = assembly
}
func (s *simpleAssemblerClient) NewSession(ctx context.Context, opts ...request.SessionOption) (request.Session, error) {
sessionID := make([]byte, 16)
_, err := io.ReadFull(rand.Reader, sessionID)
if err != nil {
return nil, err
}
sessionContext, finish := context.WithCancel(ctx)
session := &simpleAssemblerClientSession{
sessionID: sessionID, tripper: s.assembly.Tripper(), readBuffer: bytes.NewBuffer(nil),
ctx: sessionContext, finish: finish, writerChan: make(chan []byte), readerChan: make(chan []byte, 16), assembler: s,
}
go session.keepRunning()
return session, nil
}
type simpleAssemblerClientSession struct {
sessionID []byte
currentWriteWait int
assembler *simpleAssemblerClient
tripper request.Tripper
readBuffer *bytes.Buffer
writerChan chan []byte
readerChan chan []byte
ctx context.Context
finish func()
}
func (s *simpleAssemblerClientSession) keepRunning() {
s.currentWriteWait = int(s.assembler.config.InitialPollingIntervalMs)
for s.ctx.Err() == nil {
s.runOnce()
}
}
func (s *simpleAssemblerClientSession) runOnce() {
sendBuffer := bytes.NewBuffer(nil)
if s.currentWriteWait != 0 {
waitTimer := time.NewTimer(time.Millisecond * time.Duration(s.currentWriteWait))
waitForFirstWrite := true
copyFromWriterLoop:
for {
select {
case <-s.ctx.Done():
return
case data := <-s.writerChan:
sendBuffer.Write(data)
if sendBuffer.Len() >= int(s.assembler.config.MaxWriteSize) {
break copyFromWriterLoop
}
if waitForFirstWrite {
waitForFirstWrite = false
waitTimer.Reset(time.Millisecond * time.Duration(s.assembler.config.WaitSubsequentWriteMs))
}
case <-waitTimer.C:
break copyFromWriterLoop
}
}
waitTimer.Stop()
}
firstRound := true
pollConnection := true
for sendBuffer.Len() != 0 || firstRound {
firstRound = false
sendAmount := sendBuffer.Len()
if sendAmount > int(s.assembler.config.MaxWriteSize) {
sendAmount = int(s.assembler.config.MaxWriteSize)
}
data := sendBuffer.Next(sendAmount)
if len(data) != 0 {
pollConnection = false
}
for {
resp, err := s.tripper.RoundTrip(s.ctx, request.Request{Data: data, ConnectionTag: s.sessionID})
if err != nil {
newError("failed to send data").Base(err).WriteToLog()
if s.ctx.Err() != nil {
return
}
time.Sleep(time.Millisecond * time.Duration(s.assembler.config.FailedRetryIntervalMs))
continue
}
if len(resp.Data) != 0 {
s.readerChan <- resp.Data
}
if len(resp.Data) != 0 {
pollConnection = false
}
break
}
}
if pollConnection {
s.currentWriteWait = int(s.assembler.config.BackoffFactor * float32(s.currentWriteWait))
if s.currentWriteWait > int(s.assembler.config.MaxPollingIntervalMs) {
s.currentWriteWait = int(s.assembler.config.MaxPollingIntervalMs)
}
if s.currentWriteWait < int(s.assembler.config.MinPollingIntervalMs) {
s.currentWriteWait = int(s.assembler.config.MinPollingIntervalMs)
}
} else {
s.currentWriteWait = int(0)
}
}
func (s *simpleAssemblerClientSession) Read(p []byte) (n int, err error) {
if s.readBuffer.Len() == 0 {
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case data := <-s.readerChan:
s.readBuffer.Write(data)
}
}
n, err = s.readBuffer.Read(p)
if err == io.EOF {
s.readBuffer.Reset()
return 0, nil
}
return
}
func (s *simpleAssemblerClientSession) Write(p []byte) (n int, err error) {
buf := make([]byte, len(p))
copy(buf, p)
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case s.writerChan <- buf:
return len(p), nil
}
}
func (s *simpleAssemblerClientSession) Close() error {
s.finish()
return nil
}
func init() {
common.Must(common.RegisterConfig((*ClientConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
clientConfig, ok := config.(*ClientConfig)
if !ok {
return nil, newError("not a ClientConfig")
}
return newClient(clientConfig), nil
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/simple/simple.go | transport/internet/request/assembler/simple/simple.go | package simple
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/simple/server.go | transport/internet/request/assembler/simple/server.go | package simple
import (
"bytes"
"context"
"sync"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
func newServer(config *ServerConfig) request.SessionAssemblerServer {
return &simpleAssemblerServer{}
}
type simpleAssemblerServer struct {
sessions sync.Map
assembly request.TransportServerAssembly
}
func (s *simpleAssemblerServer) OnTransportServerAssemblyReady(assembly request.TransportServerAssembly) {
s.assembly = assembly
}
func (s *simpleAssemblerServer) OnRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption,
) (resp request.Response, err error) {
connectionID := req.ConnectionTag
session := newSimpleAssemblerServerSession(ctx)
loadedSession, loaded := s.sessions.LoadOrStore(string(connectionID), session)
if loaded {
session = loadedSession.(*simpleAssemblerServerSession)
} else {
if err := s.assembly.SessionReceiver().OnNewSession(ctx, session); err != nil {
return request.Response{}, newError("failed to create new session").Base(err)
}
}
return session.OnRoundTrip(ctx, req, opts...)
}
func newSimpleAssemblerServerSession(ctx context.Context) *simpleAssemblerServerSession {
sessionCtx, finish := context.WithCancel(ctx)
return &simpleAssemblerServerSession{
readBuffer: bytes.NewBuffer(nil),
readChan: make(chan []byte, 16),
requestProcessed: make(chan struct{}),
writeLock: new(sync.Mutex),
writeBuffer: bytes.NewBuffer(nil),
maxWriteSize: 4096,
ctx: sessionCtx,
finish: finish,
}
}
type simpleAssemblerServerSession struct {
maxWriteSize int
readBuffer *bytes.Buffer
readChan chan []byte
requestProcessed chan struct{}
writeLock *sync.Mutex
writeBuffer *bytes.Buffer
ctx context.Context
finish func()
}
func (s *simpleAssemblerServerSession) Read(p []byte) (n int, err error) {
if s.readBuffer.Len() == 0 {
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case data := <-s.readChan:
s.readBuffer.Write(data)
}
}
return s.readBuffer.Read(p)
}
func (s *simpleAssemblerServerSession) Write(p []byte) (n int, err error) {
s.writeLock.Lock()
n, err = s.writeBuffer.Write(p)
length := s.writeBuffer.Len()
s.writeLock.Unlock()
if err != nil {
return 0, err
}
if length > s.maxWriteSize {
select {
case <-s.requestProcessed:
case <-s.ctx.Done():
return 0, s.ctx.Err()
}
}
return
}
func (s *simpleAssemblerServerSession) Close() error {
s.finish()
return nil
}
func (s *simpleAssemblerServerSession) OnRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption,
) (resp request.Response, err error) {
if len(req.Data) > 0 {
select {
case <-s.ctx.Done():
return request.Response{}, s.ctx.Err()
case s.readChan <- req.Data:
}
}
s.writeLock.Lock()
nextWrite := s.writeBuffer.Next(s.maxWriteSize)
data := make([]byte, len(nextWrite))
copy(data, nextWrite)
s.writeLock.Unlock()
select {
case s.requestProcessed <- struct{}{}:
case <-s.ctx.Done():
return request.Response{}, s.ctx.Err()
default:
}
return request.Response{Data: data}, nil
}
func init() {
common.Must(common.RegisterConfig((*ServerConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
serverConfig, ok := config.(*ServerConfig)
if !ok {
return nil, newError("not a SimpleServerConfig")
}
return newServer(serverConfig), nil
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/simple/config.pb.go | transport/internet/request/assembler/simple/config.pb.go | package simple
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type ClientConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
MaxWriteSize int32 `protobuf:"varint,1,opt,name=max_write_size,json=maxWriteSize,proto3" json:"max_write_size,omitempty"`
WaitSubsequentWriteMs int32 `protobuf:"varint,2,opt,name=wait_subsequent_write_ms,json=waitSubsequentWriteMs,proto3" json:"wait_subsequent_write_ms,omitempty"`
InitialPollingIntervalMs int32 `protobuf:"varint,3,opt,name=initial_polling_interval_ms,json=initialPollingIntervalMs,proto3" json:"initial_polling_interval_ms,omitempty"`
MaxPollingIntervalMs int32 `protobuf:"varint,4,opt,name=max_polling_interval_ms,json=maxPollingIntervalMs,proto3" json:"max_polling_interval_ms,omitempty"`
MinPollingIntervalMs int32 `protobuf:"varint,5,opt,name=min_polling_interval_ms,json=minPollingIntervalMs,proto3" json:"min_polling_interval_ms,omitempty"`
BackoffFactor float32 `protobuf:"fixed32,6,opt,name=backoff_factor,json=backoffFactor,proto3" json:"backoff_factor,omitempty"`
FailedRetryIntervalMs int32 `protobuf:"varint,7,opt,name=failed_retry_interval_ms,json=failedRetryIntervalMs,proto3" json:"failed_retry_interval_ms,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ClientConfig) Reset() {
*x = ClientConfig{}
mi := &file_transport_internet_request_assembler_simple_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ClientConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ClientConfig) ProtoMessage() {}
func (x *ClientConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_assembler_simple_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ClientConfig.ProtoReflect.Descriptor instead.
func (*ClientConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_assembler_simple_config_proto_rawDescGZIP(), []int{0}
}
func (x *ClientConfig) GetMaxWriteSize() int32 {
if x != nil {
return x.MaxWriteSize
}
return 0
}
func (x *ClientConfig) GetWaitSubsequentWriteMs() int32 {
if x != nil {
return x.WaitSubsequentWriteMs
}
return 0
}
func (x *ClientConfig) GetInitialPollingIntervalMs() int32 {
if x != nil {
return x.InitialPollingIntervalMs
}
return 0
}
func (x *ClientConfig) GetMaxPollingIntervalMs() int32 {
if x != nil {
return x.MaxPollingIntervalMs
}
return 0
}
func (x *ClientConfig) GetMinPollingIntervalMs() int32 {
if x != nil {
return x.MinPollingIntervalMs
}
return 0
}
func (x *ClientConfig) GetBackoffFactor() float32 {
if x != nil {
return x.BackoffFactor
}
return 0
}
func (x *ClientConfig) GetFailedRetryIntervalMs() int32 {
if x != nil {
return x.FailedRetryIntervalMs
}
return 0
}
type ServerConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
MaxWriteSize int32 `protobuf:"varint,1,opt,name=max_write_size,json=maxWriteSize,proto3" json:"max_write_size,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServerConfig) Reset() {
*x = ServerConfig{}
mi := &file_transport_internet_request_assembler_simple_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServerConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerConfig) ProtoMessage() {}
func (x *ServerConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_assembler_simple_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerConfig.ProtoReflect.Descriptor instead.
func (*ServerConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_assembler_simple_config_proto_rawDescGZIP(), []int{1}
}
func (x *ServerConfig) GetMaxWriteSize() int32 {
if x != nil {
return x.MaxWriteSize
}
return 0
}
var File_transport_internet_request_assembler_simple_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_assembler_simple_config_proto_rawDesc = "" +
"\n" +
"8transport/internet/request/assembler/simple/config.proto\x126v2ray.core.transport.internet.request.assembler.simple\x1a common/protoext/extensions.proto\"\xac\x03\n" +
"\fClientConfig\x12$\n" +
"\x0emax_write_size\x18\x01 \x01(\x05R\fmaxWriteSize\x127\n" +
"\x18wait_subsequent_write_ms\x18\x02 \x01(\x05R\x15waitSubsequentWriteMs\x12=\n" +
"\x1binitial_polling_interval_ms\x18\x03 \x01(\x05R\x18initialPollingIntervalMs\x125\n" +
"\x17max_polling_interval_ms\x18\x04 \x01(\x05R\x14maxPollingIntervalMs\x125\n" +
"\x17min_polling_interval_ms\x18\x05 \x01(\x05R\x14minPollingIntervalMs\x12%\n" +
"\x0ebackoff_factor\x18\x06 \x01(\x02R\rbackoffFactor\x127\n" +
"\x18failed_retry_interval_ms\x18\a \x01(\x05R\x15failedRetryIntervalMs:0\x82\xb5\x18,\n" +
"\"transport.request.assembler.client\x12\x06simple\"f\n" +
"\fServerConfig\x12$\n" +
"\x0emax_write_size\x18\x01 \x01(\x05R\fmaxWriteSize:0\x82\xb5\x18,\n" +
"\"transport.request.assembler.server\x12\x06simpleB\xc3\x01\n" +
":com.v2ray.core.transport.internet.request.assembler.simpleP\x01ZJgithub.com/v2fly/v2ray-core/v5/transport/internet/request/assembler/simple\xaa\x026V2Ray.Core.Transport.Internet.Request.Assembler.Simpleb\x06proto3"
var (
file_transport_internet_request_assembler_simple_config_proto_rawDescOnce sync.Once
file_transport_internet_request_assembler_simple_config_proto_rawDescData []byte
)
func file_transport_internet_request_assembler_simple_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_assembler_simple_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_assembler_simple_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembler_simple_config_proto_rawDesc), len(file_transport_internet_request_assembler_simple_config_proto_rawDesc)))
})
return file_transport_internet_request_assembler_simple_config_proto_rawDescData
}
var file_transport_internet_request_assembler_simple_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_request_assembler_simple_config_proto_goTypes = []any{
(*ClientConfig)(nil), // 0: v2ray.core.transport.internet.request.assembler.simple.ClientConfig
(*ServerConfig)(nil), // 1: v2ray.core.transport.internet.request.assembler.simple.ServerConfig
}
var file_transport_internet_request_assembler_simple_config_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_request_assembler_simple_config_proto_init() }
func file_transport_internet_request_assembler_simple_config_proto_init() {
if File_transport_internet_request_assembler_simple_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembler_simple_config_proto_rawDesc), len(file_transport_internet_request_assembler_simple_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_assembler_simple_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_assembler_simple_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_assembler_simple_config_proto_msgTypes,
}.Build()
File_transport_internet_request_assembler_simple_config_proto = out.File
file_transport_internet_request_assembler_simple_config_proto_goTypes = nil
file_transport_internet_request_assembler_simple_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/udpassemblerServer.go | transport/internet/request/assembler/packetconn/udpassemblerServer.go | package packetconn
import (
"crypto/rand"
"io"
"net"
"sync"
"time"
"golang.org/x/net/context"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
net2 "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
type packet struct {
addr string
data []byte
}
type wrappedPacketConn struct {
connLock *sync.Mutex
conn map[string]*serverSession
readChan chan packet
ctx context.Context
finish func()
}
func (w *wrappedPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
select {
case pack := <-w.readChan:
n := copy(p, pack.data)
if n < len(pack.data) {
return n, nil, io.ErrShortBuffer
}
return n, &net.UDPAddr{IP: net2.IP(pack.addr)}, nil
case <-w.ctx.Done():
return 0, nil, w.ctx.Err()
}
}
func (w *wrappedPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
w.connLock.Lock()
conn := w.conn[string(addr.(*net.UDPAddr).IP)]
w.connLock.Unlock()
return conn.Write(p)
}
func (w *wrappedPacketConn) Close() error {
w.finish()
return nil
}
func (w *wrappedPacketConn) LocalAddr() net.Addr {
return nil
}
func (w *wrappedPacketConn) SetDeadline(t time.Time) error {
return nil
}
func (w *wrappedPacketConn) SetReadDeadline(t time.Time) error {
return nil
}
func (w *wrappedPacketConn) SetWriteDeadline(t time.Time) error {
return nil
}
func (w wrappedPacketConn) OnNewSession(ctx context.Context, sess request.Session, opts ...request.SessionOption) error {
imaginaryAddr := net2.UDPAddr{
IP: net2.AnyIPv6.IP(),
Port: 0,
}
rand.Read([]byte(imaginaryAddr.IP))
session := newServerSession(ctx, sess, string(imaginaryAddr.IP), &w)
w.connLock.Lock()
w.conn[string(imaginaryAddr.IP)] = session
w.connLock.Unlock()
session.start()
return nil
}
func newServerSession(ctx context.Context, sess request.Session, name string, listener *wrappedPacketConn) *serverSession {
_ = ctx
return &serverSession{session: sess, name: name, listener: listener}
}
type serverSession struct {
name string
session request.Session
listener *wrappedPacketConn
}
func (s *serverSession) start() {
go func() {
for {
select {
case <-s.listener.ctx.Done():
return
default:
buf := make([]byte, 2000)
n, err := s.session.Read(buf)
if err != nil || n > 2000 {
return
}
s.listener.readChan <- packet{s.name, buf[:n]}
}
}
}()
}
func (s *serverSession) Write(p []byte) (int, error) {
return s.session.Write(p)
}
type udpAssemblerServer struct {
ctx context.Context
streamSettings *internet.MemoryStreamConfig
assembly request.TransportServerAssembly
req2packs *requestToPacketConnServer
listener internet.Listener
}
func (u *udpAssemblerServer) Start() error {
listener, err := u.listen(net2.LocalHostIP, 0)
if err != nil {
return newError("failed to listen").Base(err).AtError()
}
u.listener = listener
return nil
}
func (u *udpAssemblerServer) Close() error {
return u.listener.Close()
}
func (u *udpAssemblerServer) OnRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
return u.req2packs.OnRoundTrip(ctx, req, opts...)
}
func (u *udpAssemblerServer) OnTransportServerAssemblyReady(assembly request.TransportServerAssembly) {
u.assembly = assembly
}
func newUDPAssemblerServer(ctx context.Context, config *ServerConfig, streamSettings *internet.MemoryStreamConfig) *udpAssemblerServer {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
transportEnvironmentWrapped := &wrappedTransportEnvironment{TransportEnvironment: transportEnvironment}
transportEnvironmentWrapped.server = newRequestToPacketConnServer(ctx, config)
wrappedContext := envctx.ContextWithEnvironment(ctx, transportEnvironmentWrapped)
return &udpAssemblerServer{ctx: wrappedContext, streamSettings: streamSettings, req2packs: transportEnvironmentWrapped.server}
}
func (u *udpAssemblerServer) listen(address net2.Address, port net2.Port) (internet.Listener, error) {
return internet.ListenTCP(u.ctx, address, port, u.streamSettings, func(connection internet.Connection) {
err := u.assembly.SessionReceiver().OnNewSession(u.ctx, connection)
if err != nil {
newError("failed to handle new session").Base(err).WriteToLog()
}
})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/errors.generated.go | transport/internet/request/assembler/packetconn/errors.generated.go | package packetconn
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/udpassemblerClient.go | transport/internet/request/assembler/packetconn/udpassemblerClient.go | package packetconn
import (
"io"
gonet "net"
"sync"
"time"
"golang.org/x/net/context"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
type udpAssemblerClient struct {
ctx context.Context
streamSettings *internet.MemoryStreamConfig
assembly request.TransportClientAssembly
req2connc *requestToPacketConnClient
}
func (u *udpAssemblerClient) NewSession(ctx context.Context, opts ...request.SessionOption) (request.Session, error) {
return u.dial(net.Destination{})
}
func (u *udpAssemblerClient) OnTransportClientAssemblyReady(assembly request.TransportClientAssembly) {
u.assembly = assembly
u.req2connc.OnTransportClientAssemblyReady(assembly)
}
func newWrappedConn(in io.ReadWriteCloser) net.Conn {
return wrappedConn{in}
}
type wrappedConn struct {
io.ReadWriteCloser
}
func (w wrappedConn) LocalAddr() gonet.Addr {
return nil
}
func (w wrappedConn) RemoteAddr() gonet.Addr {
return nil
}
func (w wrappedConn) SetDeadline(t time.Time) error {
return nil
}
func (w wrappedConn) SetReadDeadline(t time.Time) error {
return nil
}
func (w wrappedConn) SetWriteDeadline(t time.Time) error {
return nil
}
func newWrappedPacketConn(ctx context.Context) *wrappedPacketConn {
ctxWithCancel, cancel := context.WithCancel(ctx)
return &wrappedPacketConn{
conn: make(map[string]*serverSession),
readChan: make(chan packet, 16), ctx: ctxWithCancel, finish: cancel, connLock: &sync.Mutex{},
}
}
func newUDPAssemblerClient(ctx context.Context, config *ClientConfig, streamSettings *internet.MemoryStreamConfig) *udpAssemblerClient {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
transportEnvironmentWrapped := &wrappedTransportEnvironment{TransportEnvironment: transportEnvironment}
transportEnvironmentWrapped.client, _ = newRequestToPacketConnClient(ctx, config)
wrappedContext := envctx.ContextWithEnvironment(ctx, transportEnvironmentWrapped)
return &udpAssemblerClient{ctx: wrappedContext, streamSettings: streamSettings, req2connc: transportEnvironmentWrapped.client}
}
func (u *udpAssemblerClient) dial(dest net.Destination) (internet.Connection, error) {
_ = dest
return internet.Dial(u.ctx, net.TCPDestination(net.LocalHostIP, 0), u.streamSettings)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/req2packet.go | transport/internet/request/assembler/packetconn/req2packet.go | package packetconn
import (
"bytes"
"context"
"crypto/rand"
"io"
"sync"
"time"
"github.com/golang-collections/go-datastructures/queue"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
func newRequestToPacketConnClient(ctx context.Context, config *ClientConfig) (*requestToPacketConnClient, error) { //nolint: unparam
return &requestToPacketConnClient{ctx: ctx, config: config}, nil
}
type requestToPacketConnClient struct {
assembly request.TransportClientAssembly
ctx context.Context
config *ClientConfig
}
func (r *requestToPacketConnClient) OnTransportClientAssemblyReady(assembly request.TransportClientAssembly) {
r.assembly = assembly
}
func (r *requestToPacketConnClient) Dial() (io.ReadWriteCloser, error) {
sessionID := make([]byte, 16)
_, err := rand.Read(sessionID)
if err != nil {
return nil, err
}
ctxWithCancel, cancel := context.WithCancel(r.ctx)
clientSess := &requestToPacketConnClientSession{
sessionID: sessionID,
currentPollingInterval: int(r.config.PollingIntervalInitial),
maxRequestSize: int(r.config.MaxRequestSize),
maxWriteDelay: int(r.config.MaxWriteDelay),
assembly: r.assembly,
writerChan: make(chan []byte, 256),
readerChan: make(chan []byte, 256),
ctx: ctxWithCancel,
finish: cancel,
}
go clientSess.keepRunning()
return clientSess, nil
}
type requestToPacketConnClientSession struct {
sessionID []byte
currentPollingInterval int
maxRequestSize int
maxWriteDelay int
assembly request.TransportClientAssembly
writerChan chan []byte
readerChan chan []byte
ctx context.Context
finish func()
nextWrite []byte
}
func (r *requestToPacketConnClientSession) keepRunning() {
for r.ctx.Err() == nil {
r.runOnce()
}
}
func (r *requestToPacketConnClientSession) runOnce() {
requestBody := bytes.NewBuffer(nil)
waitTimer := time.NewTimer(time.Duration(r.currentPollingInterval) * time.Millisecond)
var seenPacket bool
packetBundler := NewPacketBundle()
copyFromChan:
for {
select {
case <-r.ctx.Done():
return
case <-waitTimer.C:
break copyFromChan
case packet := <-r.writerChan:
if !seenPacket {
seenPacket = true
waitTimer.Stop()
waitTimer.Reset(time.Duration(r.maxWriteDelay) * time.Millisecond)
}
sizeOffset := packetBundler.Overhead() + len(packet)
if requestBody.Len()+sizeOffset > r.maxRequestSize {
r.nextWrite = packet
break copyFromChan
}
err := packetBundler.WriteToBundle(packet, requestBody)
if err != nil {
newError("failed to write to bundle").Base(err).WriteToLog()
}
}
}
waitTimer.Stop()
go func() {
reader, writer := io.Pipe()
defer writer.Close()
streamingRespOpt := &pipedStreamingRespOption{writer}
go func() {
for {
if packet, err := packetBundler.ReadFromBundle(reader); err == nil {
r.readerChan <- packet
} else {
return
}
}
}()
resp, err := r.assembly.Tripper().RoundTrip(r.ctx, request.Request{Data: requestBody.Bytes(), ConnectionTag: r.sessionID},
streamingRespOpt)
if err != nil {
newError("failed to roundtrip").Base(err).WriteToLog()
if r.ctx.Err() != nil {
return
}
}
if len(resp.Data) != 0 {
respReader := bytes.NewReader(resp.Data)
for respReader.Len() != 0 {
packet, err := packetBundler.ReadFromBundle(respReader)
if err != nil {
newError("failed to read from bundle").Base(err).WriteToLog()
if r.ctx.Err() != nil {
return
}
}
r.readerChan <- packet
}
}
}()
}
type pipedStreamingRespOption struct {
writer *io.PipeWriter
}
func (p *pipedStreamingRespOption) RoundTripperOption() {
}
func (p *pipedStreamingRespOption) GetResponseWriter() io.Writer {
return p.writer
}
func (r *requestToPacketConnClientSession) Write(p []byte) (n int, err error) {
buf := make([]byte, len(p))
copy(buf, p)
select {
case <-r.ctx.Done():
return 0, r.ctx.Err()
case r.writerChan <- buf:
return len(p), nil
}
}
func (r *requestToPacketConnClientSession) Read(p []byte) (n int, err error) {
select {
case <-r.ctx.Done():
return 0, r.ctx.Err()
case buf := <-r.readerChan:
copy(p, buf)
return len(buf), nil
}
}
func (r *requestToPacketConnClientSession) Close() error {
r.finish()
return nil
}
func newRequestToPacketConnServer(ctx context.Context, config *ServerConfig) *requestToPacketConnServer {
return &requestToPacketConnServer{
sessionMap: sync.Map{},
ctx: ctx,
config: config,
}
}
type requestToPacketConnServer struct {
packetSessionReceiver request.SessionReceiver
sessionMap sync.Map
ctx context.Context
config *ServerConfig
}
func (r *requestToPacketConnServer) onSessionReceiverReady(sessrecv request.SessionReceiver) {
r.packetSessionReceiver = sessrecv
}
func (r *requestToPacketConnServer) OnRoundTrip(ctx context.Context, req request.Request,
opts ...request.RoundTripperOption,
) (resp request.Response, err error) {
SessionID := req.ConnectionTag
if SessionID == nil {
return request.Response{}, newError("nil session id")
}
sessionID := string(SessionID)
var session *requestToPacketConnServerSession
sessionAny, found := r.sessionMap.Load(sessionID)
if found {
var ok bool
session, ok = sessionAny.(*requestToPacketConnServerSession)
if !ok {
return request.Response{}, newError("failed to cast session")
}
}
if !found {
ctxWithFinish, finish := context.WithCancel(ctx)
session = &requestToPacketConnServerSession{
SessionID: SessionID,
writingConnectionQueue: queue.New(64),
writerChan: make(chan []byte, int(r.config.PacketWritingBuffer)),
readerChan: make(chan []byte, 256),
ctx: ctxWithFinish,
finish: finish,
server: r,
maxWriteSize: int(r.config.MaxWriteSize),
maxWriteDuration: int(r.config.MaxWriteDurationMs),
maxSimultaneousWriteConnection: int(r.config.MaxSimultaneousWriteConnection),
}
_, loaded := r.sessionMap.LoadOrStore(sessionID, session)
if !loaded {
err = r.packetSessionReceiver.OnNewSession(ctx, session)
}
}
if err != nil {
return request.Response{}, err
}
return session.OnRoundTrip(ctx, req, opts...)
}
func (r *requestToPacketConnServer) removeSessionID(sessionID []byte) {
r.sessionMap.Delete(string(sessionID))
}
type requestToPacketConnServerSession struct {
SessionID []byte
writingConnectionQueue *queue.Queue
writerChan chan []byte
readerChan chan []byte
ctx context.Context
finish func()
server *requestToPacketConnServer
maxWriteSize int
maxWriteDuration int
maxSimultaneousWriteConnection int
}
func (r *requestToPacketConnServerSession) Read(p []byte) (n int, err error) {
select {
case <-r.ctx.Done():
return 0, r.ctx.Err()
case buf := <-r.readerChan:
copy(p, buf)
return len(buf), nil
}
}
var debugStats struct {
packetWritten int
packetDropped int
}
/*
var _ = func() bool {
go func() {
for {
time.Sleep(time.Second)
newError("packet written: ", debugStats.packetWritten, " packet dropped: ", debugStats.packetDropped).WriteToLog()
}
}()
return true
}()*/
func (r *requestToPacketConnServerSession) Write(p []byte) (n int, err error) {
buf := make([]byte, len(p))
copy(buf, p)
select {
case <-r.ctx.Done():
return 0, r.ctx.Err()
case r.writerChan <- buf:
debugStats.packetWritten++
return len(p), nil
default: // This write will be called from global listener's routine, it must not block
debugStats.packetDropped++
return len(p), nil
}
}
func (r *requestToPacketConnServerSession) Close() error {
r.server.removeSessionID(r.SessionID)
r.finish()
return nil
}
type writingConnection struct {
focus func()
finish func()
finishCtx context.Context
}
func (r *requestToPacketConnServerSession) OnRoundTrip(ctx context.Context, req request.Request,
opts ...request.RoundTripperOption,
) (resp request.Response, err error) {
// TODO: fix connection graceful close
var streamingRespWriter io.Writer
var streamingRespWriterFlusher request.OptionSupportsStreamingResponseExtensionFlusher
for _, opt := range opts {
if streamingRespOpt, ok := opt.(request.OptionSupportsStreamingResponse); ok {
streamingRespWriter = streamingRespOpt.GetResponseWriter()
if streamingRespWriterFlusherOpt, ok := opt.(request.OptionSupportsStreamingResponseExtensionFlusher); ok {
streamingRespWriterFlusher = streamingRespWriterFlusherOpt
}
}
}
packetBundler := NewPacketBundle()
reqReader := bytes.NewReader(req.Data)
for reqReader.Len() != 0 {
packet, err := packetBundler.ReadFromBundle(reqReader)
if err != nil {
err = newError("failed to read from bundle").Base(err)
return request.Response{}, err
}
r.readerChan <- packet
}
onFocusCtx, focus := context.WithCancel(ctx)
onFinishCtx, finish := context.WithCancel(ctx)
r.writingConnectionQueue.Put(&writingConnection{
focus: focus,
finish: finish,
finishCtx: onFinishCtx,
})
amountToEnd := r.writingConnectionQueue.Len() - int64(r.maxSimultaneousWriteConnection)
for amountToEnd > 0 {
{
_, _ = r.writingConnectionQueue.TakeUntil(func(i interface{}) bool {
i.(*writingConnection).finish()
amountToEnd--
return amountToEnd > 0
})
}
}
{
_, _ = r.writingConnectionQueue.TakeUntil(func(i interface{}) bool {
i.(*writingConnection).focus()
return false
})
}
bufferedRespWriter := bytes.NewBuffer(nil)
finishWrite := func() {
resp.Data = bufferedRespWriter.Bytes()
{
_, _ = r.writingConnectionQueue.TakeUntil(func(i interface{}) bool {
i.(*writingConnection).focus()
if i.(*writingConnection).finishCtx.Err() != nil { //nolint: gosimple
return true
}
return false
})
}
}
progressiveSend := streamingRespWriter != nil
var respWriter io.Writer
if progressiveSend {
respWriter = streamingRespWriter
} else {
respWriter = bufferedRespWriter
}
var bytesSent int
onReceivePacket := func(packet []byte) bool {
bytesSent += len(packet) + packetBundler.Overhead()
err := packetBundler.WriteToBundle(packet, respWriter)
if err != nil {
newError("failed to write to bundle").Base(err).WriteToLog()
}
if streamingRespWriterFlusher != nil {
streamingRespWriterFlusher.Flush()
}
if bytesSent >= r.maxWriteSize {
return false
}
return true
}
finishWriteTimer := time.NewTimer(time.Millisecond * time.Duration(r.maxWriteDuration))
if !progressiveSend {
select {
case <-onFocusCtx.Done():
case <-onFinishCtx.Done():
finishWrite()
return resp, nil
}
} else {
select {
case <-onFinishCtx.Done():
finishWrite()
return resp, nil
default:
}
}
firstRead := true
for {
select {
case <-onFinishCtx.Done():
finishWrite()
finishWriteTimer.Stop()
return resp, nil
case packet := <-r.writerChan:
keepSending := onReceivePacket(packet)
if firstRead {
firstRead = false
}
if !keepSending {
finishWrite()
finishWriteTimer.Stop()
return resp, nil
}
case <-finishWriteTimer.C:
finishWrite()
return resp, nil
}
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/packetbundle.go | transport/internet/request/assembler/packetconn/packetbundle.go | package packetconn
import (
"encoding/binary"
"io"
)
func NewPacketBundle() PacketBundle {
return &packetBundle{}
}
type packetBundle struct{}
func (p *packetBundle) Overhead() int {
return 2
}
func (p *packetBundle) WriteToBundle(b []byte, writer io.Writer) (err error) {
err = binary.Write(writer, binary.BigEndian, uint16(len(b)))
if err != nil {
return
}
_, err = writer.Write(b)
return
}
func (p *packetBundle) ReadFromBundle(writer io.Reader) (b []byte, err error) {
var length uint16
err = binary.Read(writer, binary.BigEndian, &length)
if err != nil {
return
}
b = make([]byte, length)
n, err := io.ReadFull(writer, b)
if err != nil {
return
}
if n != int(length) {
return nil, io.ErrUnexpectedEOF
}
return
}
type PacketBundle interface {
Overhead() int
WriteToBundle(b []byte, writer io.Writer) (err error)
ReadFromBundle(writer io.Reader) (b []byte, err error)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/packetConn.pb.go | transport/internet/request/assembler/packetconn/packetConn.pb.go | package packetconn
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type ClientConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
UnderlyingTransportSetting *anypb.Any `protobuf:"bytes,1,opt,name=underlying_transport_setting,json=underlyingTransportSetting,proto3" json:"underlying_transport_setting,omitempty"`
UnderlyingTransportName string `protobuf:"bytes,2,opt,name=underlying_transport_name,json=underlyingTransportName,proto3" json:"underlying_transport_name,omitempty"`
MaxWriteDelay int32 `protobuf:"varint,3,opt,name=max_write_delay,json=maxWriteDelay,proto3" json:"max_write_delay,omitempty"`
MaxRequestSize int32 `protobuf:"varint,4,opt,name=max_request_size,json=maxRequestSize,proto3" json:"max_request_size,omitempty"`
PollingIntervalInitial int32 `protobuf:"varint,5,opt,name=polling_interval_initial,json=pollingIntervalInitial,proto3" json:"polling_interval_initial,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ClientConfig) Reset() {
*x = ClientConfig{}
mi := &file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ClientConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ClientConfig) ProtoMessage() {}
func (x *ClientConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ClientConfig.ProtoReflect.Descriptor instead.
func (*ClientConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescGZIP(), []int{0}
}
func (x *ClientConfig) GetUnderlyingTransportSetting() *anypb.Any {
if x != nil {
return x.UnderlyingTransportSetting
}
return nil
}
func (x *ClientConfig) GetUnderlyingTransportName() string {
if x != nil {
return x.UnderlyingTransportName
}
return ""
}
func (x *ClientConfig) GetMaxWriteDelay() int32 {
if x != nil {
return x.MaxWriteDelay
}
return 0
}
func (x *ClientConfig) GetMaxRequestSize() int32 {
if x != nil {
return x.MaxRequestSize
}
return 0
}
func (x *ClientConfig) GetPollingIntervalInitial() int32 {
if x != nil {
return x.PollingIntervalInitial
}
return 0
}
type ServerConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
UnderlyingTransportSetting *anypb.Any `protobuf:"bytes,1,opt,name=underlying_transport_setting,json=underlyingTransportSetting,proto3" json:"underlying_transport_setting,omitempty"`
UnderlyingTransportName string `protobuf:"bytes,2,opt,name=underlying_transport_name,json=underlyingTransportName,proto3" json:"underlying_transport_name,omitempty"`
MaxWriteSize int32 `protobuf:"varint,3,opt,name=max_write_size,json=maxWriteSize,proto3" json:"max_write_size,omitempty"`
MaxWriteDurationMs int32 `protobuf:"varint,4,opt,name=max_write_duration_ms,json=maxWriteDurationMs,proto3" json:"max_write_duration_ms,omitempty"`
MaxSimultaneousWriteConnection int32 `protobuf:"varint,5,opt,name=max_simultaneous_write_connection,json=maxSimultaneousWriteConnection,proto3" json:"max_simultaneous_write_connection,omitempty"`
PacketWritingBuffer int32 `protobuf:"varint,6,opt,name=packet_writing_buffer,json=packetWritingBuffer,proto3" json:"packet_writing_buffer,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServerConfig) Reset() {
*x = ServerConfig{}
mi := &file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServerConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerConfig) ProtoMessage() {}
func (x *ServerConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerConfig.ProtoReflect.Descriptor instead.
func (*ServerConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescGZIP(), []int{1}
}
func (x *ServerConfig) GetUnderlyingTransportSetting() *anypb.Any {
if x != nil {
return x.UnderlyingTransportSetting
}
return nil
}
func (x *ServerConfig) GetUnderlyingTransportName() string {
if x != nil {
return x.UnderlyingTransportName
}
return ""
}
func (x *ServerConfig) GetMaxWriteSize() int32 {
if x != nil {
return x.MaxWriteSize
}
return 0
}
func (x *ServerConfig) GetMaxWriteDurationMs() int32 {
if x != nil {
return x.MaxWriteDurationMs
}
return 0
}
func (x *ServerConfig) GetMaxSimultaneousWriteConnection() int32 {
if x != nil {
return x.MaxSimultaneousWriteConnection
}
return 0
}
func (x *ServerConfig) GetPacketWritingBuffer() int32 {
if x != nil {
return x.PacketWritingBuffer
}
return 0
}
var File_transport_internet_request_assembler_packetconn_packetConn_proto protoreflect.FileDescriptor
const file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDesc = "" +
"\n" +
"@transport/internet/request/assembler/packetconn/packetConn.proto\x12:v2ray.core.transport.internet.request.assembler.packetconn\x1a common/protoext/extensions.proto\x1a\x19google/protobuf/any.proto\"\xe4\x02\n" +
"\fClientConfig\x12V\n" +
"\x1cunderlying_transport_setting\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\x1aunderlyingTransportSetting\x12:\n" +
"\x19underlying_transport_name\x18\x02 \x01(\tR\x17underlyingTransportName\x12&\n" +
"\x0fmax_write_delay\x18\x03 \x01(\x05R\rmaxWriteDelay\x12(\n" +
"\x10max_request_size\x18\x04 \x01(\x05R\x0emaxRequestSize\x128\n" +
"\x18polling_interval_initial\x18\x05 \x01(\x05R\x16pollingIntervalInitial:4\x82\xb5\x180\n" +
"\"transport.request.assembler.client\x12\n" +
"packetconn\"\xb0\x03\n" +
"\fServerConfig\x12V\n" +
"\x1cunderlying_transport_setting\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\x1aunderlyingTransportSetting\x12:\n" +
"\x19underlying_transport_name\x18\x02 \x01(\tR\x17underlyingTransportName\x12$\n" +
"\x0emax_write_size\x18\x03 \x01(\x05R\fmaxWriteSize\x121\n" +
"\x15max_write_duration_ms\x18\x04 \x01(\x05R\x12maxWriteDurationMs\x12I\n" +
"!max_simultaneous_write_connection\x18\x05 \x01(\x05R\x1emaxSimultaneousWriteConnection\x122\n" +
"\x15packet_writing_buffer\x18\x06 \x01(\x05R\x13packetWritingBuffer:4\x82\xb5\x180\n" +
"\"transport.request.assembler.server\x12\n" +
"packetconnB\xcf\x01\n" +
">com.v2ray.core.transport.internet.request.assembler.packetconnP\x01ZNgithub.com/v2fly/v2ray-core/v5/transport/internet/request/assembler/packetconn\xaa\x02:V2Ray.Core.Transport.Internet.Request.Assembler.Packetconnb\x06proto3"
var (
file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescOnce sync.Once
file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescData []byte
)
func file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescGZIP() []byte {
file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescOnce.Do(func() {
file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDesc), len(file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDesc)))
})
return file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDescData
}
var file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_request_assembler_packetconn_packetConn_proto_goTypes = []any{
(*ClientConfig)(nil), // 0: v2ray.core.transport.internet.request.assembler.packetconn.ClientConfig
(*ServerConfig)(nil), // 1: v2ray.core.transport.internet.request.assembler.packetconn.ServerConfig
(*anypb.Any)(nil), // 2: google.protobuf.Any
}
var file_transport_internet_request_assembler_packetconn_packetConn_proto_depIdxs = []int32{
2, // 0: v2ray.core.transport.internet.request.assembler.packetconn.ClientConfig.underlying_transport_setting:type_name -> google.protobuf.Any
2, // 1: v2ray.core.transport.internet.request.assembler.packetconn.ServerConfig.underlying_transport_setting:type_name -> google.protobuf.Any
2, // [2:2] is the sub-list for method output_type
2, // [2:2] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_transport_internet_request_assembler_packetconn_packetConn_proto_init() }
func file_transport_internet_request_assembler_packetconn_packetConn_proto_init() {
if File_transport_internet_request_assembler_packetconn_packetConn_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDesc), len(file_transport_internet_request_assembler_packetconn_packetConn_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_assembler_packetconn_packetConn_proto_goTypes,
DependencyIndexes: file_transport_internet_request_assembler_packetconn_packetConn_proto_depIdxs,
MessageInfos: file_transport_internet_request_assembler_packetconn_packetConn_proto_msgTypes,
}.Build()
File_transport_internet_request_assembler_packetconn_packetConn_proto = out.File
file_transport_internet_request_assembler_packetconn_packetConn_proto_goTypes = nil
file_transport_internet_request_assembler_packetconn_packetConn_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/udpassembler.go | transport/internet/request/assembler/packetconn/udpassembler.go | package packetconn
import (
"golang.org/x/net/context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
type wrappedTransportEnvironment struct {
environment.TransportEnvironment
client *requestToPacketConnClient
server *requestToPacketConnServer
}
func (w *wrappedTransportEnvironment) Listen(ctx context.Context, addr net.Addr, sockopt *internet.SocketConfig) (net.Listener, error) {
return nil, newError("not implemented")
}
func (w *wrappedTransportEnvironment) ListenPacket(ctx context.Context, addr net.Addr, sockopt *internet.SocketConfig) (net.PacketConn, error) {
packetConn := newWrappedPacketConn(ctx)
w.server.onSessionReceiverReady(packetConn)
return packetConn, nil
}
func (w *wrappedTransportEnvironment) Dial(ctx context.Context, source net.Address, destination net.Destination, sockopt *internet.SocketConfig) (net.Conn, error) {
session, err := w.client.Dial()
if err != nil {
return nil, err
}
return newWrappedConn(session), nil
}
func (w *wrappedTransportEnvironment) Dialer() internet.SystemDialer {
return w
}
func (w *wrappedTransportEnvironment) Listener() internet.SystemListener {
return w
}
func newUDPAssemblerServerFromConfig(ctx context.Context, config *ServerConfig) (*udpAssemblerServer, error) {
instance, err := serial.GetInstanceOf(config.UnderlyingTransportSetting)
if err != nil {
return nil, newError("failed to get instance of underlying transport").Base(err).AtError()
}
memcfg := &internet.MemoryStreamConfig{ProtocolName: config.UnderlyingTransportName, ProtocolSettings: instance}
return newUDPAssemblerServer(ctx, config, memcfg), nil
}
func newUDPAssemblerClientFromConfig(ctx context.Context, config *ClientConfig) (*udpAssemblerClient, error) {
instance, err := serial.GetInstanceOf(config.UnderlyingTransportSetting)
if err != nil {
return nil, newError("failed to get instance of underlying transport").Base(err).AtError()
}
memcfg := &internet.MemoryStreamConfig{ProtocolName: config.UnderlyingTransportName, ProtocolSettings: instance}
return newUDPAssemblerClient(ctx, config, memcfg), nil
}
func init() {
common.Must(common.RegisterConfig((*ServerConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
serverConfig, ok := config.(*ServerConfig)
if !ok {
return nil, newError("not a ServerConfig")
}
return newUDPAssemblerServerFromConfig(ctx, serverConfig)
}))
common.Must(common.RegisterConfig((*ClientConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
clientConfig, ok := config.(*ClientConfig)
if !ok {
return nil, newError("not a ClientConfig")
}
return newUDPAssemblerClientFromConfig(ctx, clientConfig)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembler/packetconn/packetconn.go | transport/internet/request/assembler/packetconn/packetconn.go | package packetconn
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/reverser.go | transport/internet/request/roundtripperreverserserver/reverser.go | package roundtripperreverserserver
import (
"context"
"net"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
v2net "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
func NewReverser(ctx context.Context, config *Config) (*Reverser, error) {
reverser := &Reverser{
ctx: ctx,
config: config,
}
if err := reverser.init(); err != nil {
return nil, newError("failed to initialize Reverser").Base(err).AtError()
}
return reverser, nil
}
type Reverser struct {
ctx context.Context
config *Config
rttServer request.RoundTripperServer
reverser request.ReverserImpl
accessChecker request.ReverserAccessChecker
}
func (s *Reverser) OnRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
serverIntent := len(req.ConnectionTag) == 16
if serverIntent {
serverPublic, err := s.accessChecker.CheckReverserAccess(ctx, req.ConnectionTag)
if err != nil {
return request.Response{}, newError("reverser access check failed").Base(err).AtError()
}
reverserImpl, err := s.reverser.OnAuthenticatedServerIntentRoundTrip(ctx, serverPublic, req, opts...)
if err != nil {
return request.Response{}, newError("failed to handle authenticated server round trip").Base(err).AtError()
}
return reverserImpl, nil
}
if len(req.ConnectionTag) != 32 {
return request.Response{}, newError("invalid ConnectionTag length")
}
reverserImpl, err := s.reverser.OnOtherRoundTrip(ctx, req, opts...)
if err != nil {
return request.Response{}, newError("failed to handle client round trip").Base(err).AtError()
}
return reverserImpl, nil
}
func (s *Reverser) Listen(ctx context.Context) (v2net.Listener, error) {
systemNetworkCapabilitySet := envctx.EnvironmentFromContext(s.ctx).(environment.SystemNetworkCapabilitySet)
listener := systemNetworkCapabilitySet.Listener()
addr, err := v2net.ParseDestination(s.config.Listen)
if err != nil {
return nil, newError("invalid listen address " + s.config.Listen).Base(err).AtError()
}
netaddr := &net.TCPAddr{IP: addr.Address.IP(), Port: int(addr.Port)}
l, err := listener.Listen(ctx, netaddr, nil)
if err != nil {
return nil, newError("failed to listen on " + s.config.Listen).Base(err).AtError()
}
return l, nil
}
func (s *Reverser) init() error {
if s.config == nil {
return newError("nil ServerConfig")
}
if s.config.AccessPassphrase == "" {
return newError("empty AccessPassphrase in ServerConfig")
}
accessChecker, err := NewPasswordAccessChecker(s.config.AccessPassphrase)
if err != nil {
return newError("failed to create AccessChecker").Base(err).AtError()
}
s.accessChecker = accessChecker
ReverserImplInst, err := NewReverserImpl()
if err != nil {
return newError("failed to create ReverserImpl").Base(err).AtError()
}
s.reverser = ReverserImplInst
if s.config.RoundTripperServer == nil {
return newError("nil RoundTripperServer in ServerConfig")
}
RoundTripperServerConfig, err := serial.GetInstanceOf(s.config.RoundTripperServer)
if err != nil {
return newError("failed to get instance of RoundTripperServer").Base(err).AtError()
}
RoundTripperServerObj, err := common.CreateObject(s.ctx, RoundTripperServerConfig)
if err != nil {
return newError("failed to create RoundTripperServer").Base(err).AtError()
}
RoundTripperServerTyped, ok := RoundTripperServerObj.(request.RoundTripperServer)
if !ok {
return newError("RoundTripperServer is not a valid request.RoundTripperServer")
}
s.rttServer = RoundTripperServerTyped
s.rttServer.OnTransportServerAssemblyReady(s)
if err := s.rttServer.Start(); err != nil {
return newError("failed to start RoundTripperServer").Base(err).AtError()
}
return nil
}
func (s *Reverser) TripperReceiver() request.TripperReceiver {
return s
}
func (s *Reverser) SessionReceiver() request.SessionReceiver {
return nil
}
func (s *Reverser) AutoImplListener() request.Listener {
return s
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/reverserimpl.go | transport/internet/request/roundtripperreverserserver/reverserimpl.go | package roundtripperreverserserver
import (
"context"
"sync"
"time"
"github.com/v2fly/v2ray-core/v5/common/task"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
func NewReverserImpl() (request.ReverserImpl, error) {
r := &ReverserImpl{
timeoutDuration: 5 * time.Minute,
}
// configure periodic cleaner
r.periodicCleaner = &task.Periodic{
Interval: time.Second * 30,
Execute: func() error {
now := time.Now()
r.serverPublicKeyToStateMap.Range(func(k, v interface{}) bool {
ss, ok := v.(*serverState)
if !ok {
return true
}
if now.Sub(ss.lastSeen) > r.timeoutDuration {
r.serverPublicKeyToStateMap.Delete(k)
r.serverPrivateKeyToPublicKey.Delete(ss.privateKey)
}
return true
})
return nil
},
}
// start the cleaner; return error if Start fails
if err := r.periodicCleaner.Start(); err != nil {
return nil, err
}
return r, nil
}
type ReverserImpl struct {
serverPublicKeyToStateMap sync.Map
serverPrivateKeyToPublicKey sync.Map
clientTemporaryKeyToStateMap sync.Map
// cleanup fields
periodicCleaner *task.Periodic
timeoutDuration time.Duration
}
// StopCleanup stops the periodic cleaner (if running).
func (r *ReverserImpl) StopCleanup() error {
if r.periodicCleaner == nil {
return nil
}
return r.periodicCleaner.Close()
}
func (r *ReverserImpl) OnOtherRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
_ = ctx
_ = opts
routingKey := req.ConnectionTag
if len(routingKey) != 32 {
return request.Response{}, newError("invalid routing key")
}
sourceKey := routingKey[:16]
destKey := routingKey[16:]
if _, ok := r.serverPrivateKeyToPublicKey.Load(string(sourceKey)); ok {
stateInterface, clientOk := r.clientTemporaryKeyToStateMap.Load(string(destKey))
if clientOk {
state := stateInterface.(*clientState)
message := &reverserMessage{
Data: req.Data,
}
select {
case state.messageQueue <- message:
default:
return request.Response{}, newError("client message queue full")
}
return request.Response{}, nil
}
return request.Response{}, newError("no client found for the given routing key")
}
// try if this is a client to server message
stateInterface, _ := r.clientTemporaryKeyToStateMap.LoadOrStore(string(sourceKey), &clientState{
messageQueue: make(chan *reverserMessage, 1),
})
state := stateInterface.(*clientState)
defer func() {
r.clientTemporaryKeyToStateMap.Delete(string(sourceKey))
}()
serverStateInterface, ok := r.serverPublicKeyToStateMap.Load(string(destKey))
if ok {
serverStateInst := serverStateInterface.(*serverState)
message := &reverserMessage{
Data: req.Data,
}
timeOutTimer := time.NewTimer(time.Second * 25)
select {
case serverStateInst.messageQueue <- message:
case <-timeOutTimer.C:
return request.Response{}, newError("server message queue full timeout")
}
select {
case respMessage := <-state.messageQueue:
timeOutTimer.Stop()
return request.Response{
Data: respMessage.Data,
}, nil
case <-timeOutTimer.C:
return request.Response{}, newError("client message queue empty timeout")
}
}
return request.Response{}, newError("no server found for the given routing key")
}
func (r *ReverserImpl) OnAuthenticatedServerIntentRoundTrip(ctx context.Context, serverPublic []byte, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
_ = ctx
_ = opts
if len(req.ConnectionTag) != 16 {
return request.Response{}, newError("invalid server private key")
}
if len(serverPublic) != 16 {
return request.Response{}, newError("invalid server public key")
}
serverPrivate := req.ConnectionTag
// store mapping from private -> public
r.serverPrivateKeyToPublicKey.Store(string(serverPrivate), string(serverPublic))
stateInterface, _ := r.serverPublicKeyToStateMap.LoadOrStore(string(serverPublic), &serverState{
messageQueue: make(chan *reverserMessage, 16),
lastSeen: time.Now(),
})
state := stateInterface.(*serverState)
state.lastSeen = time.Now()
timeOutTimer := time.NewTimer(time.Minute)
select {
case message := <-state.messageQueue:
timeOutTimer.Stop()
return request.Response{
Data: message.Data,
}, nil
case <-timeOutTimer.C:
return request.Response{}, nil
}
}
func (r *ReverserImpl) __CleanupNow____TestOnly() {
// trigger cleanup immediately for testing purposes
r.periodicCleaner.Execute()
}
type clientState struct {
messageQueue chan *reverserMessage
}
type serverState struct {
messageQueue chan *reverserMessage
lastSeen time.Time
privateKey string
}
type reverserMessage struct {
Data []byte
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/errors.generated.go | transport/internet/request/roundtripperreverserserver/errors.generated.go | package roundtripperreverserserver
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/accesschecker_password_test.go | transport/internet/request/roundtripperreverserserver/accesschecker_password_test.go | package roundtripperreverserserver
import (
"bytes"
"context"
"math"
"strings"
"testing"
"github.com/v2fly/struc"
)
func TestGenerateTokenLength(t *testing.T) {
p, err := NewPasswordAccessChecker("test-password")
if err != nil {
t.Fatalf("failed to create checker: %v", err)
}
tok, err := p.GenerateToken(12345)
if err != nil {
t.Fatalf("GenerateToken failed: %v", err)
}
if len(tok) != 16 {
t.Fatalf("expected token length 16, got %d", len(tok))
}
}
func TestGenerateAndCheckRoundTrip(t *testing.T) {
p, err := NewPasswordAccessChecker("another-secret")
if err != nil {
t.Fatalf("failed to create checker: %v", err)
}
userID := int64(42)
serverKey, err := p.GenerateToken(userID)
if err != nil {
t.Fatalf("GenerateToken failed: %v", err)
}
clientKey, err := p.CheckReverserAccess(context.Background(), serverKey)
if err != nil {
t.Fatalf("CheckReverserAccess failed: %v", err)
}
if len(clientKey) != 16 {
t.Fatalf("expected client key length 16, got %d", len(clientKey))
}
// decrypt clientKey using internal block to inspect contents
decrypted := make([]byte, 16)
p.block.Decrypt(decrypted, clientKey)
token := &tokenUnpacked{}
if err := struc.Unpack(bytes.NewReader(decrypted), token); err != nil {
t.Fatalf("failed to unpack client token: %v", err)
}
if token.Check != 0 {
t.Fatalf("expected check 0, got %d", token.Check)
}
if token.UserID != -userID {
t.Fatalf("expected userID %d, got %d", -userID, token.UserID)
}
}
func TestPasswordAccessChecker_ValidRoundTrip(t *testing.T) {
p, err := NewPasswordAccessChecker("test-password")
if err != nil {
t.Fatalf("NewPasswordAccessChecker failed: %v", err)
}
userID := int64(42)
token, err := p.GenerateToken(userID)
if err != nil {
t.Fatalf("GenerateToken failed: %v", err)
}
clientKey, err := p.CheckReverserAccess(context.TODO(), token)
if err != nil {
t.Fatalf("CheckReverserAccess failed: %v", err)
}
// decrypt clientKey and verify contents
buf := make([]byte, 16)
p.block.Decrypt(buf, clientKey)
tok := &tokenUnpacked{}
if err := struc.Unpack(bytes.NewReader(buf), tok); err != nil {
t.Fatalf("failed to unpack client token: %v", err)
}
if tok.Check != 0 {
t.Fatalf("unexpected Check value: got %d want 0", tok.Check)
}
if tok.UserID != -userID {
t.Fatalf("unexpected UserID: got %d want %d", tok.UserID, -userID)
}
}
func TestPasswordAccessChecker_InvalidKeyLength(t *testing.T) {
p, err := NewPasswordAccessChecker("test-password")
if err != nil {
t.Fatalf("NewPasswordAccessChecker failed: %v", err)
}
_, err = p.CheckReverserAccess(context.TODO(), []byte{1, 2, 3})
if err == nil {
t.Fatalf("expected error for invalid key length, got nil")
}
if !strings.Contains(err.Error(), "invalid server key length") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPasswordAccessChecker_InvalidTokenCheckValue(t *testing.T) {
p, err := NewPasswordAccessChecker("test-password")
if err != nil {
t.Fatalf("NewPasswordAccessChecker failed: %v", err)
}
// craft a token with non-zero Check
buf := bytes.NewBuffer(make([]byte, 0, 16))
if err := struc.Pack(buf, &tokenUnpacked{UserID: 7, Check: 1}); err != nil {
t.Fatalf("failed to pack token: %v", err)
}
plain := buf.Bytes()
if len(plain) != 16 {
t.Fatalf("unexpected packed length: %d", len(plain))
}
encrypted := make([]byte, 16)
p.block.Encrypt(encrypted, plain)
_, err = p.CheckReverserAccess(context.TODO(), encrypted)
if err == nil {
t.Fatalf("expected error for invalid token check value, got nil")
}
if !strings.Contains(err.Error(), "invalid token check value") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestTokensNotInterchangeable(t *testing.T) {
p1, err := NewPasswordAccessChecker("password-one")
if err != nil {
t.Fatalf("failed to create checker p1: %v", err)
}
p2, err := NewPasswordAccessChecker("password-two")
if err != nil {
t.Fatalf("failed to create checker p2: %v", err)
}
userID := int64(7)
// token created by p1 should not be accepted by p2
tok1, err := p1.GenerateToken(userID)
if err != nil {
t.Fatalf("p1.GenerateToken failed: %v", err)
}
if _, err := p2.CheckReverserAccess(context.Background(), tok1); err == nil {
t.Fatalf("expected p2 to reject token generated by p1, but it accepted it")
}
// token created by p2 should not be accepted by p1
tok2, err := p2.GenerateToken(userID)
if err != nil {
t.Fatalf("p2.GenerateToken failed: %v", err)
}
if _, err := p1.CheckReverserAccess(context.Background(), tok2); err == nil {
t.Fatalf("expected p1 to reject token generated by p2, but it accepted it")
}
}
func TestCheckReverserAccess_NegativeUserID(t *testing.T) {
p, err := NewPasswordAccessChecker("neg-test")
if err != nil {
t.Fatalf("failed to create checker: %v", err)
}
// craft a token with negative UserID and Check == 0
buf := bytes.NewBuffer(make([]byte, 0, 16))
if err := struc.Pack(buf, &tokenUnpacked{UserID: -5, Check: 0}); err != nil {
t.Fatalf("failed to pack token: %v", err)
}
plain := buf.Bytes()
if len(plain) != 16 {
t.Fatalf("unexpected packed length: %d", len(plain))
}
serverKey := make([]byte, 16)
p.block.Encrypt(serverKey, plain)
if _, err := p.CheckReverserAccess(context.Background(), serverKey); err == nil {
t.Fatalf("expected error for negative userID token, got nil")
} else if !strings.Contains(err.Error(), "invalid token userID for server") {
t.Fatalf("unexpected error for negative userID token: %v", err)
}
}
func TestCheckReverserAccess_MinInt64Token(t *testing.T) {
p, err := NewPasswordAccessChecker("minint-test")
if err != nil {
t.Fatalf("failed to create checker: %v", err)
}
// craft a token with MinInt64 and Check == 0
buf := bytes.NewBuffer(make([]byte, 0, 16))
if err := struc.Pack(buf, &tokenUnpacked{UserID: math.MinInt64, Check: 0}); err != nil {
t.Fatalf("failed to pack token: %v", err)
}
plain := buf.Bytes()
if len(plain) != 16 {
t.Fatalf("unexpected packed length: %d", len(plain))
}
serverKey := make([]byte, 16)
p.block.Encrypt(serverKey, plain)
if _, err := p.CheckReverserAccess(context.Background(), serverKey); err == nil {
t.Fatalf("expected error for MinInt64 token, got nil")
} else if !strings.Contains(err.Error(), "invalid token userID: MinInt64") {
t.Fatalf("unexpected error for MinInt64 token: %v", err)
}
}
func TestGenerateTokensDifferentPasswords(t *testing.T) {
p1, err := NewPasswordAccessChecker("pw-a")
if err != nil {
t.Fatalf("failed to create checker p1: %v", err)
}
p2, err := NewPasswordAccessChecker("pw-b")
if err != nil {
t.Fatalf("failed to create checker p2: %v", err)
}
userID := int64(100)
tok1, err := p1.GenerateToken(userID)
if err != nil {
t.Fatalf("p1.GenerateToken failed: %v", err)
}
tok2, err := p2.GenerateToken(userID)
if err != nil {
t.Fatalf("p2.GenerateToken failed: %v", err)
}
if bytes.Equal(tok1, tok2) {
t.Fatalf("expected tokens from different passwords to differ, but they are equal")
}
}
func TestNewPasswordAccessChecker_EmptyPassword(t *testing.T) {
// ensure creating a checker with empty password succeeds and block is set
p, err := NewPasswordAccessChecker("")
if err != nil {
t.Fatalf("failed to create checker with empty password: %v", err)
}
if p.block == nil {
t.Fatalf("expected block to be initialized for empty password")
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/accesschecker_password.go | transport/internet/request/roundtripperreverserserver/accesschecker_password.go | package roundtripperreverserserver
import (
"bytes"
"context"
"crypto/aes"
"crypto/cipher"
"crypto/hkdf"
"crypto/sha256"
"math"
"github.com/v2fly/struc"
)
type PasswordAccessChecker struct {
Password string
block cipher.Block
}
// NewPasswordAccessChecker creates a PasswordAccessChecker from the given password
// and initializes its internal cipher block. It returns an error if initialization
// fails.
func NewPasswordAccessChecker(password string) (*PasswordAccessChecker, error) {
p := &PasswordAccessChecker{Password: password}
if err := p.init(); err != nil {
return nil, err
}
return p, nil
}
type tokenUnpacked struct {
UserID int64 `struc:"int64,little"`
Check uint64 `struc:"uint64,little"`
}
func (p *PasswordAccessChecker) CheckReverserAccess(ctx context.Context, serverKey []byte) (clientKey []byte, err error) {
if len(serverKey) != 16 {
return nil, newError("invalid server key length")
}
buffer := make([]byte, 16)
// Decrypt into buffer from serverKey
p.block.Decrypt(buffer, serverKey)
token := &tokenUnpacked{}
err = struc.Unpack(bytes.NewReader(buffer), token)
if err != nil {
return nil, newError("failed to unpack token").Base(err)
}
expectedCheck := uint64(0)
if token.Check != expectedCheck {
return nil, newError("invalid token check value")
}
if token.UserID == int64(math.MinInt64) {
return nil, newError("invalid token userID: MinInt64")
}
if token.UserID < 0 {
return nil, newError("invalid token userID for server: client token has negative userID")
}
// pack client token into a buffer with capacity 16
buf := bytes.NewBuffer(make([]byte, 0, 16))
err = struc.Pack(buf, &tokenUnpacked{
UserID: -token.UserID,
Check: expectedCheck,
})
if err != nil {
return nil, newError("failed to pack client token").Base(err)
}
clientKeyBuffer := buf.Bytes()
if len(clientKeyBuffer) != 16 {
return nil, newError("invalid packed client token length")
}
// encrypt into a fresh slice to avoid overlapping issues
encrypted := make([]byte, 16)
p.block.Encrypt(encrypted, clientKeyBuffer)
return encrypted, nil
}
func (p *PasswordAccessChecker) GenerateToken(userID int64) ([]byte, error) {
if userID == int64(math.MinInt64) {
return nil, newError("userID cannot be MinInt64")
}
expectedCheck := uint64(0)
// pack token into a buffer with capacity 16
buf := bytes.NewBuffer(make([]byte, 0, 16))
err := struc.Pack(buf, &tokenUnpacked{
UserID: userID,
Check: expectedCheck,
})
if err != nil {
return nil, newError("failed to pack token").Base(err)
}
buffer := buf.Bytes()
if len(buffer) != 16 {
return nil, newError("invalid packed token length")
}
encrypted := make([]byte, 16)
p.block.Encrypt(encrypted, buffer)
return encrypted, nil
}
func (p *PasswordAccessChecker) init() error {
block, err := createBlockFromPassword(p.Password)
if err != nil {
return newError("failed to create block from password").Base(err)
}
p.block = block
return nil
}
func createBlockFromPassword(password string) (cipher.Block, error) {
// derive a 16-byte key from the password with hkdf
key, err := hkdf.Expand(sha256.New, []byte(password), "v2ray-hd87BYQL-aBzumdEh-Yv4E6Rdu:request-roundtripperreverserserver"+"createBlockFromPassword", 16)
if err != nil {
return nil, newError("unable to derive key from password").Base(err)
}
block, err := aes.NewCipher(key)
if err != nil {
return nil, newError("unable to create AES cipher").Base(err)
}
return block, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/config.pb.go | transport/internet/request/roundtripperreverserserver/config.pb.go | package roundtripperreverserserver
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
RoundTripperServer *anypb.Any `protobuf:"bytes,2,opt,name=round_tripper_server,json=roundTripperServer,proto3" json:"round_tripper_server,omitempty"`
Listen string `protobuf:"bytes,3,opt,name=listen,proto3" json:"listen,omitempty"`
AccessPassphrase string `protobuf:"bytes,4,opt,name=access_passphrase,json=accessPassphrase,proto3" json:"access_passphrase,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_request_roundtripperreverserserver_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_roundtripperreverserserver_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetRoundTripperServer() *anypb.Any {
if x != nil {
return x.RoundTripperServer
}
return nil
}
func (x *Config) GetListen() string {
if x != nil {
return x.Listen
}
return ""
}
func (x *Config) GetAccessPassphrase() string {
if x != nil {
return x.AccessPassphrase
}
return ""
}
var File_transport_internet_request_roundtripperreverserserver_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_roundtripperreverserserver_config_proto_rawDesc = "" +
"\n" +
"Btransport/internet/request/roundtripperreverserserver/config.proto\x12@v2ray.core.transport.internet.request.roundtripperreverserserver\x1a common/protoext/extensions.proto\x1a\x19google/protobuf/any.proto\"\xc9\x01\n" +
"\x06Config\x12F\n" +
"\x14round_tripper_server\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x12roundTripperServer\x12\x16\n" +
"\x06listen\x18\x03 \x01(\tR\x06listen\x12+\n" +
"\x11access_passphrase\x18\x04 \x01(\tR\x10accessPassphrase:2\x82\xb5\x18.\n" +
",transport.request.roundtripperreverserserverB\xe0\x01\n" +
"Dcom.v2ray.core.transport.internet.request.roundtripperreverserserverP\x01ZTgithub.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripperreverserserver\xaa\x02?V2Ray.Core.Transport.Internet.Request.RoundtripperReverseServerb\x06proto3"
var (
file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescOnce sync.Once
file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescData []byte
)
func file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_roundtripperreverserserver_config_proto_rawDesc), len(file_transport_internet_request_roundtripperreverserserver_config_proto_rawDesc)))
})
return file_transport_internet_request_roundtripperreverserserver_config_proto_rawDescData
}
var file_transport_internet_request_roundtripperreverserserver_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_request_roundtripperreverserserver_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.request.roundtripperreverserserver.Config
(*anypb.Any)(nil), // 1: google.protobuf.Any
}
var file_transport_internet_request_roundtripperreverserserver_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.request.roundtripperreverserserver.Config.round_tripper_server:type_name -> google.protobuf.Any
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_request_roundtripperreverserserver_config_proto_init() }
func file_transport_internet_request_roundtripperreverserserver_config_proto_init() {
if File_transport_internet_request_roundtripperreverserserver_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_roundtripperreverserserver_config_proto_rawDesc), len(file_transport_internet_request_roundtripperreverserserver_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_roundtripperreverserserver_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_roundtripperreverserserver_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_roundtripperreverserserver_config_proto_msgTypes,
}.Build()
File_transport_internet_request_roundtripperreverserserver_config_proto = out.File
file_transport_internet_request_roundtripperreverserserver_config_proto_goTypes = nil
file_transport_internet_request_roundtripperreverserserver_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/reverserimpl_test.go | transport/internet/request/roundtripperreverserserver/reverserimpl_test.go | package roundtripperreverserserver
import (
"context"
"strings"
"testing"
"time"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
// helper to make a byte slice of given length filled with a pattern
func fill(b byte, n int) []byte {
res := make([]byte, n)
for i := range res {
res[i] = b
}
return res
}
// stopCleanup tries to call StopCleanup on concrete *ReverserImpl returned by NewReverserImpl.
func stopCleanup(t *testing.T, r request.ReverserImpl) {
if r == nil {
return
}
if impl, ok := r.(*ReverserImpl); ok {
if err := impl.StopCleanup(); err != nil {
t.Fatalf("StopCleanup failed: %v", err)
}
} else {
t.Fatalf("expected *ReverserImpl, got %T", r)
}
}
func TestOnOtherRoundTrip_InvalidRoutingKeyLength(t *testing.T) {
r, err := NewReverserImpl()
if err != nil {
// constructor currently never errors
t.Fatalf("unexpected constructor error: %v", err)
}
defer stopCleanup(t, r)
_, gotErr := r.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: []byte("short")})
if gotErr == nil {
t.Fatalf("expected error for invalid routing key length")
}
if !strings.Contains(gotErr.Error(), "invalid routing key") {
t.Fatalf("unexpected error: %v", gotErr)
}
}
func TestOnOtherRoundTrip_ServerToClient_NoClientFound(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
source := fill('A', 16)
dest := fill('B', 16)
impl.serverPrivateKeyToPublicKey.Store(string(source), string(source))
_, err := impl.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: append(source, dest...)})
if err == nil || !strings.Contains(err.Error(), "no client found") {
t.Fatalf("expected no client found error, got: %v", err)
}
}
func TestOnOtherRoundTrip_ServerToClient_Success(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
source := fill('S', 16)
dest := fill('C', 16)
impl.serverPrivateKeyToPublicKey.Store(string(source), string(source))
clientState := &clientState{messageQueue: make(chan *reverserMessage, 1)}
impl.clientTemporaryKeyToStateMap.Store(string(dest), clientState)
data := []byte("hello-client")
_, err := impl.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: append(source, dest...), Data: data})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
select {
case msg := <-clientState.messageQueue:
if string(msg.Data) != string(data) {
t.Fatalf("unexpected message data: got %q want %q", msg.Data, data)
}
default:
t.Fatalf("expected message queued for client but queue empty")
}
}
func TestOnOtherRoundTrip_ServerToClient_QueueFull(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
source := fill('F', 16)
dest := fill('Q', 16)
impl.serverPrivateKeyToPublicKey.Store(string(source), string(source))
clientState := &clientState{messageQueue: make(chan *reverserMessage, 1)}
// pre-fill queue so next send fails non-blocking
clientState.messageQueue <- &reverserMessage{Data: []byte("prefill")}
impl.clientTemporaryKeyToStateMap.Store(string(dest), clientState)
_, err := impl.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: append(source, dest...), Data: []byte("new")})
if err == nil || !strings.Contains(err.Error(), "client message queue full") {
t.Fatalf("expected queue full error, got: %v", err)
}
}
func TestOnOtherRoundTrip_ClientToServer_NoServerFound(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
source := fill('X', 16)
dest := fill('Y', 16)
_, err := impl.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: append(source, dest...), Data: []byte("ping")})
if err == nil || !strings.Contains(err.Error(), "no server found") {
t.Fatalf("expected no server found error, got: %v", err)
}
}
func TestOnOtherRoundTrip_ClientToServer_Success(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
source := fill('1', 16)
dest := fill('2', 16)
serverState := &serverState{messageQueue: make(chan *reverserMessage, 1)}
impl.serverPublicKeyToStateMap.Store(string(dest), serverState)
clientState := &clientState{messageQueue: make(chan *reverserMessage, 1)}
clientState.messageQueue <- &reverserMessage{Data: []byte("pong")}
impl.clientTemporaryKeyToStateMap.Store(string(source), clientState)
data := []byte("ping")
resp, err := impl.OnOtherRoundTrip(context.Background(), request.Request{ConnectionTag: append(source, dest...), Data: data})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// verify server received the original message
select {
case msg := <-serverState.messageQueue:
if string(msg.Data) != string(data) {
t.Fatalf("server message mismatch: got %q want %q", msg.Data, data)
}
default:
t.Fatalf("expected server to receive message but queue empty")
}
if string(resp.Data) != "pong" {
t.Fatalf("unexpected response data: got %q want %q", resp.Data, "pong")
}
}
func TestOnAuthenticatedServerIntentRoundTrip_InvalidPrivateKeyLength(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
serverPublic := fill('P', 16)
_, err := impl.OnAuthenticatedServerIntentRoundTrip(context.Background(), serverPublic, request.Request{ConnectionTag: fill('Z', 15)})
if err == nil || !strings.Contains(err.Error(), "invalid server private key") {
t.Fatalf("expected invalid server private key error, got: %v", err)
}
}
func TestOnAuthenticatedServerIntentRoundTrip_InvalidPublicKeyLength(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
_, err := impl.OnAuthenticatedServerIntentRoundTrip(context.Background(), fill('P', 15), request.Request{ConnectionTag: fill('K', 16)})
if err == nil || !strings.Contains(err.Error(), "invalid server public key") {
t.Fatalf("expected invalid server public key error, got: %v", err)
}
}
func TestOnAuthenticatedServerIntentRoundTrip_SuccessMessage(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
serverPublic := fill('P', 16)
serverPrivate := fill('K', 16)
state := &serverState{messageQueue: make(chan *reverserMessage, 1)}
state.messageQueue <- &reverserMessage{Data: []byte("welcome")}
impl.serverPublicKeyToStateMap.Store(string(serverPublic), state)
resp, err := impl.OnAuthenticatedServerIntentRoundTrip(context.Background(), serverPublic, request.Request{ConnectionTag: serverPrivate})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if string(resp.Data) != "welcome" {
t.Fatalf("unexpected response data: got %q want %q", resp.Data, "welcome")
}
if _, ok := impl.serverPrivateKeyToPublicKey.Load(string(serverPrivate)); !ok {
t.Fatalf("expected server private key mapping to be stored")
}
}
func TestSmoke(t *testing.T) {
if _, err := NewReverserImpl(); err != nil {
t.Fatalf("unexpected error constructing reverser: %v", err)
}
}
func TestPeriodicCleanupRemovesOldServer(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
// configure short durations for test speed
impl.timeoutDuration = 10 * time.Millisecond
impl.periodicCleaner.Interval = 5 * time.Millisecond
// insert a server state with lastSeen far in the past
old := &serverState{messageQueue: make(chan *reverserMessage, 1), lastSeen: time.Now().Add(-time.Hour)}
impl.serverPublicKeyToStateMap.Store("old-server", old)
// trigger cleanup now
impl.__CleanupNow____TestOnly()
if _, ok := impl.serverPublicKeyToStateMap.Load("old-server"); ok {
t.Fatalf("expected old server entry to be removed by cleaner")
}
}
func TestCleanupNowRemovesServerAndPrivateMapping(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
// create an old server entry with private key present in private->public map
publicKey := "old-server-public"
privateKey := "old-server-private"
old := &serverState{messageQueue: make(chan *reverserMessage, 1), lastSeen: time.Now().Add(-time.Hour), privateKey: privateKey}
impl.serverPublicKeyToStateMap.Store(publicKey, old)
impl.serverPrivateKeyToPublicKey.Store(privateKey, publicKey)
// trigger immediate cleanup
impl.__CleanupNow____TestOnly()
if _, ok := impl.serverPublicKeyToStateMap.Load(publicKey); ok {
t.Fatalf("expected old server entry to be removed by cleaner via CleanupNow")
}
if _, ok := impl.serverPrivateKeyToPublicKey.Load(privateKey); ok {
t.Fatalf("expected old private->public mapping to be removed by cleaner via CleanupNow")
}
}
func TestStopCleanupIdempotent(t *testing.T) {
r, _ := NewReverserImpl()
impl := r.(*ReverserImpl)
// first stop
if err := impl.StopCleanup(); err != nil {
t.Fatalf("StopCleanup failed: %v", err)
}
// second stop should not panic or return error
if err := impl.StopCleanup(); err != nil {
t.Fatalf("StopCleanup second call failed: %v", err)
}
}
func TestOnAuthenticatedServerIntentRoundTrip_UpdatesLastSeenAndMapping(t *testing.T) {
r, _ := NewReverserImpl()
defer stopCleanup(t, r)
impl := r.(*ReverserImpl)
serverPublic := fill('P', 16)
serverPrivate := fill('K', 16)
// pre-insert a server state that has an old lastSeen but contains a queued message
state := &serverState{messageQueue: make(chan *reverserMessage, 1), lastSeen: time.Now().Add(-time.Hour)}
state.messageQueue <- &reverserMessage{Data: []byte("welcome-back")}
impl.serverPublicKeyToStateMap.Store(string(serverPublic), state)
resp, err := impl.OnAuthenticatedServerIntentRoundTrip(context.Background(), serverPublic, request.Request{ConnectionTag: serverPrivate})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if string(resp.Data) != "welcome-back" {
t.Fatalf("unexpected response data: got %q want %q", resp.Data, "welcome-back")
}
// mapping from private -> public should be stored
if v, ok := impl.serverPrivateKeyToPublicKey.Load(string(serverPrivate)); !ok || v != string(serverPublic) {
t.Fatalf("expected private->public mapping stored, got %v (ok=%v)", v, ok)
}
// lastSeen should be updated to a recent time
si, ok := impl.serverPublicKeyToStateMap.Load(string(serverPublic))
if !ok {
t.Fatalf("expected server state to still exist after intent call")
}
ss := si.(*serverState)
if time.Since(ss.lastSeen) > time.Second*2 {
t.Fatalf("expected lastSeen to be updated recently, got %v", ss.lastSeen)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/clicommand/roundTripperReserseServerCli.go | transport/internet/request/roundtripperreverserserver/clicommand/roundTripperReserseServerCli.go | package clicommand
import (
"bytes"
"context"
"flag"
"os"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/environment/systemnetworkimpl"
"github.com/v2fly/v2ray-core/v5/main/commands/all/engineering"
"github.com/v2fly/v2ray-core/v5/main/commands/base"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripperreverserserver"
"google.golang.org/protobuf/encoding/protojson"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
var config *string
var cmdRTTReverseServer = &base.Command{
UsageLine: "{{.Exec}} engineering request-rtt-reverse-server",
Flag: func() flag.FlagSet {
fs := flag.NewFlagSet("", flag.ExitOnError)
config = fs.String("c", "", "")
return *fs
}(),
Run: func(cmd *base.Command, args []string) {
err := cmd.Flag.Parse(args)
if err != nil {
base.Fatalf("failed to parse flags: %v", err)
}
fd, err := os.Open(*config)
if err != nil {
base.Fatalf("failed to open config file %q: %v", *config, err)
}
defer func() { _ = fd.Close() }()
content := bytes.NewBuffer(nil)
_, err = content.ReadFrom(fd)
if err != nil {
base.Fatalf("failed to read config file %q: %v", *config, err)
}
var reverserConfig roundtripperreverserserver.Config
err = protojson.Unmarshal(content.Bytes(), &reverserConfig)
if err != nil {
base.Fatalf("failed to unmarshal JSON config from %q: %v", *config, err)
}
ctx := context.Background()
systemNetworkImpl := systemnetworkimpl.NewSystemNetworkDefault()
ctx = envctx.ContextWithEnvironment(ctx, systemNetworkImpl)
server, err := roundtripperreverserserver.NewReverser(ctx, &reverserConfig)
if err != nil {
base.Fatalf("failed to create RTT reverse server: %v", err)
}
_ = server
select {}
},
}
func init() {
engineering.AddCommand(cmdRTTReverseServer)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/clicommand/errors.generated.go | transport/internet/request/roundtripperreverserserver/clicommand/errors.generated.go | package clicommand
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripperreverserserver/clicommand/generate_token_cli.go | transport/internet/request/roundtripperreverserserver/clicommand/generate_token_cli.go | package clicommand
import (
"encoding/base64"
"flag"
"fmt"
"os"
"strconv"
"github.com/v2fly/v2ray-core/v5/main/commands/all/engineering"
"github.com/v2fly/v2ray-core/v5/main/commands/base"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripperreverserserver"
)
var (
genPassword *string
genPasswordShort *string
genUser *string
genOut *string
)
var cmdGenerateToken = &base.Command{
UsageLine: "{{.Exec}} engineering request-rtt-reverser-gen-token",
Flag: func() flag.FlagSet {
fs := flag.NewFlagSet("", flag.ExitOnError)
// user-facing flag name: access passphrase
genPassword = fs.String("access-passphrase", "", "access passphrase used to derive token key (required)")
// short alias for convenience
genPasswordShort = fs.String("p", "", "access passphrase (shorthand)")
genUser = fs.String("u", "", "userID (required, int64, positive)")
genOut = fs.String("o", "", "write base64 tokens to file (optional)")
return *fs
}(),
Run: func(cmd *base.Command, args []string) {
if err := cmd.Flag.Parse(args); err != nil {
base.Fatalf("failed to parse flags: %v", err)
}
// require password (either long form or short alias)
var passphrase string
if genPasswordShort != nil && *genPasswordShort != "" {
passphrase = *genPasswordShort
} else if genPassword != nil && *genPassword != "" {
passphrase = *genPassword
} else {
base.Fatalf("-access-passphrase (or -p) is required")
}
if *genUser == "" {
base.Fatalf("-u userID is required")
}
id, err := strconv.ParseInt(*genUser, 10, 64)
if err != nil {
base.Fatalf("invalid userID %q: %v", *genUser, err)
}
// require positive userID
if id <= 0 {
base.Fatalf("userID must be a positive integer")
}
checker, err := roundtripperreverserserver.NewPasswordAccessChecker(passphrase)
if err != nil {
base.Fatalf("failed to create PasswordAccessChecker: %v", err)
}
// generate private (positive) and public (negative) tokens
privToken, err := checker.GenerateToken(id)
if err != nil {
base.Fatalf("GenerateToken (private) failed: %v", err)
}
pubToken, err := checker.GenerateToken(-id)
if err != nil {
base.Fatalf("GenerateToken (public) failed: %v", err)
}
b64Priv := base64.StdEncoding.EncodeToString(privToken)
b64Pub := base64.StdEncoding.EncodeToString(pubToken)
if *genOut != "" {
content := fmt.Sprintf("private: %s\npublic: %s\n", b64Priv, b64Pub)
if err := os.WriteFile(*genOut, []byte(content), 0o600); err != nil {
base.Fatalf("failed to write tokens to file %q: %v", *genOut, err)
}
if _, err := fmt.Fprintf(os.Stdout, "wrote base64 tokens to %s\n", *genOut); err != nil {
base.Fatalf("failed to write token message: %v", err)
}
return
}
// print both tokens to stdout
fmt.Printf("private: %s\npublic: %s\n", b64Priv, b64Pub)
},
}
func init() {
engineering.AddCommand(cmdGenerateToken)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembly/hub.go | transport/internet/request/assembly/hub.go | package assembly
import (
"context"
gonet "net"
"time"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
type server struct {
tripper request.RoundTripperServer
assembler request.SessionAssemblerServer
addConn internet.ConnHandler
streamSettings *internet.MemoryStreamConfig
addr net.Address
port net.Port
}
func (s server) Listen(ctx context.Context) (net.Listener, error) {
return transportcommon.ListenWithSecuritySettings(ctx, s.addr, s.port, s.streamSettings)
}
func (s server) AutoImplListener() request.Listener {
return s
}
func (s server) Close() error {
if err := s.tripper.Close(); err != nil {
return newError("failed to close tripper").Base(err)
}
if runnableAssembler, ok := s.assembler.(common.Runnable); ok {
if err := runnableAssembler.Close(); err != nil {
return newError("failed to close assembler").Base(err)
}
}
return nil
}
func (s server) Addr() net.Addr {
// Unimplemented
return nil
}
type serverConnection struct {
request.Session
}
func (s serverConnection) LocalAddr() gonet.Addr {
return &net.UnixAddr{Name: "unimplemented"}
}
func (s serverConnection) RemoteAddr() gonet.Addr {
return &net.UnixAddr{Name: "unimplemented"}
}
func (s serverConnection) SetDeadline(t time.Time) error {
// Unimplemented
return nil
}
func (s serverConnection) SetReadDeadline(t time.Time) error {
// Unimplemented
return nil
}
func (s serverConnection) SetWriteDeadline(t time.Time) error {
// Unimplemented
return nil
}
func (s server) OnNewSession(ctx context.Context, sess request.Session, opts ...request.SessionOption) error {
s.addConn(&serverConnection{sess})
return nil
}
func (s server) SessionReceiver() request.SessionReceiver {
return s
}
func (s server) TripperReceiver() request.TripperReceiver {
return s.assembler
}
func listenRequest(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, addConn internet.ConnHandler) (internet.Listener, error) {
transportConfiguration := streamSettings.ProtocolSettings.(*Config)
serverAssembly := &server{addConn: addConn}
assemblerConfigInstance, err := serial.GetInstanceOf(transportConfiguration.Assembler)
if err != nil {
return nil, newError("failed to get config instance of assembler").Base(err)
}
assembler, err := common.CreateObject(ctx, assemblerConfigInstance)
if err != nil {
return nil, newError("failed to create assembler").Base(err)
}
if typedAssembler, ok := assembler.(request.SessionAssemblerServer); !ok {
return nil, newError("failed to type assert assembler to SessionAssemblerServer")
} else {
serverAssembly.assembler = typedAssembler
}
roundtripperConfigInstance, err := serial.GetInstanceOf(transportConfiguration.Roundtripper)
if err != nil {
return nil, newError("failed to get config instance of roundtripper").Base(err)
}
roundtripper, err := common.CreateObject(ctx, roundtripperConfigInstance)
if err != nil {
return nil, newError("failed to create roundtripper").Base(err)
}
if typedRoundtripper, ok := roundtripper.(request.RoundTripperServer); !ok {
return nil, newError("failed to type assert roundtripper to RoundTripperServer")
} else {
serverAssembly.tripper = typedRoundtripper
}
serverAssembly.addr = address
serverAssembly.port = port
serverAssembly.streamSettings = streamSettings
serverAssembly.assembler.OnTransportServerAssemblyReady(serverAssembly)
serverAssembly.tripper.OnTransportServerAssemblyReady(serverAssembly)
if err := serverAssembly.tripper.Start(); err != nil {
return nil, newError("failed to start tripper").Base(err)
}
if runnableAssembler, ok := serverAssembly.assembler.(common.Runnable); ok {
if err := runnableAssembler.Start(); err != nil {
return nil, newError("failed to start assembler").Base(err)
}
}
return serverAssembly, nil
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, listenRequest))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembly/dialer.go | transport/internet/request/assembly/dialer.go | package assembly
import (
"context"
gonet "net"
"time"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
type client struct {
tripper request.RoundTripperClient
assembler request.SessionAssemblerClient
streamSettings *internet.MemoryStreamConfig
dest net.Destination
}
func (c client) Dial(ctx context.Context) (net.Conn, error) {
return transportcommon.DialWithSecuritySettings(ctx, c.dest, c.streamSettings)
}
func (c client) AutoImplDialer() request.Dialer {
return c
}
func (c client) Tripper() request.Tripper {
return c.tripper
}
func (c client) dialRequestSession(ctx context.Context) (net.Conn, error) {
session, err := c.assembler.NewSession(ctx)
if err != nil {
return nil, newError("failed to create new session").Base(err)
}
return clientConnection{session}, nil
}
type clientConnection struct {
request.Session
}
func (c clientConnection) LocalAddr() gonet.Addr {
return &net.UnixAddr{Name: "unimplemented"}
}
func (c clientConnection) RemoteAddr() gonet.Addr {
return &net.UnixAddr{Name: "unimplemented"}
}
func (c clientConnection) SetDeadline(t time.Time) error {
// Unimplemented
return nil
}
func (c clientConnection) SetReadDeadline(t time.Time) error {
// Unimplemented
return nil
}
func (c clientConnection) SetWriteDeadline(t time.Time) error {
// Unimplemented
return nil
}
func dialRequest(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (net.Conn, error) {
clientAssembly := &client{}
transportConfiguration := streamSettings.ProtocolSettings.(*Config)
assemblerConfigInstance, err := serial.GetInstanceOf(transportConfiguration.Assembler)
if err != nil {
return nil, newError("failed to get config instance of assembler").Base(err)
}
assembler, err := common.CreateObject(ctx, assemblerConfigInstance)
if err != nil {
return nil, newError("failed to create assembler").Base(err)
}
if typedAssembler, ok := assembler.(request.SessionAssemblerClient); !ok {
return nil, newError("failed to type assert assembler to SessionAssemblerClient")
} else {
clientAssembly.assembler = typedAssembler
}
roundtripperConfigInstance, err := serial.GetInstanceOf(transportConfiguration.Roundtripper)
if err != nil {
return nil, newError("failed to get config instance of roundtripper").Base(err)
}
roundtripper, err := common.CreateObject(ctx, roundtripperConfigInstance)
if err != nil {
return nil, newError("failed to create roundtripper").Base(err)
}
if typedRoundtripper, ok := roundtripper.(request.RoundTripperClient); !ok {
return nil, newError("failed to type assert roundtripper to RoundTripperClient")
} else {
clientAssembly.tripper = typedRoundtripper
}
clientAssembly.streamSettings = streamSettings
clientAssembly.dest = dest
clientAssembly.assembler.OnTransportClientAssemblyReady(clientAssembly)
clientAssembly.tripper.OnTransportClientAssemblyReady(clientAssembly)
return clientAssembly.dialRequestSession(ctx)
}
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 := dialRequest(ctx, dest, streamSettings)
if err != nil {
return nil, newError("failed to dial request to ", dest).Base(err)
}
return internet.Connection(conn), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembly/errors.generated.go | transport/internet/request/assembly/errors.generated.go | package assembly
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembly/assembly.go | transport/internet/request/assembly/assembly.go | package assembly
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
const protocolName = "request"
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return nil, newError("request is a transport protocol.")
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/assembly/config.pb.go | transport/internet/request/assembly/config.pb.go | package assembly
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Assembler *anypb.Any `protobuf:"bytes,1,opt,name=assembler,proto3" json:"assembler,omitempty"`
Roundtripper *anypb.Any `protobuf:"bytes,2,opt,name=roundtripper,proto3" json:"roundtripper,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_request_assembly_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_assembly_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_request_assembly_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetAssembler() *anypb.Any {
if x != nil {
return x.Assembler
}
return nil
}
func (x *Config) GetRoundtripper() *anypb.Any {
if x != nil {
return x.Roundtripper
}
return nil
}
var File_transport_internet_request_assembly_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_assembly_config_proto_rawDesc = "" +
"\n" +
"0transport/internet/request/assembly/config.proto\x12.v2ray.core.transport.internet.request.assembly\x1a common/protoext/extensions.proto\x1a\x19google/protobuf/any.proto\"\x90\x01\n" +
"\x06Config\x122\n" +
"\tassembler\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\tassembler\x128\n" +
"\froundtripper\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\froundtripper:\x18\x82\xb5\x18\x14\n" +
"\ttransport\x12\arequestB\xab\x01\n" +
"2com.v2ray.core.transport.internet.request.assemblyP\x01ZBgithub.com/v2fly/v2ray-core/v5/transport/internet/request/assembly\xaa\x02.V2Ray.Core.Transport.Internet.Request.Assemblyb\x06proto3"
var (
file_transport_internet_request_assembly_config_proto_rawDescOnce sync.Once
file_transport_internet_request_assembly_config_proto_rawDescData []byte
)
func file_transport_internet_request_assembly_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_assembly_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_assembly_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembly_config_proto_rawDesc), len(file_transport_internet_request_assembly_config_proto_rawDesc)))
})
return file_transport_internet_request_assembly_config_proto_rawDescData
}
var file_transport_internet_request_assembly_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_request_assembly_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.request.assembly.Config
(*anypb.Any)(nil), // 1: google.protobuf.Any
}
var file_transport_internet_request_assembly_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.request.assembly.Config.assembler:type_name -> google.protobuf.Any
1, // 1: v2ray.core.transport.internet.request.assembly.Config.roundtripper:type_name -> google.protobuf.Any
2, // [2:2] is the sub-list for method output_type
2, // [2:2] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_transport_internet_request_assembly_config_proto_init() }
func file_transport_internet_request_assembly_config_proto_init() {
if File_transport_internet_request_assembly_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_assembly_config_proto_rawDesc), len(file_transport_internet_request_assembly_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_assembly_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_assembly_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_assembly_config_proto_msgTypes,
}.Build()
File_transport_internet_request_assembly_config_proto = out.File
file_transport_internet_request_assembly_config_proto_goTypes = nil
file_transport_internet_request_assembly_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/mekya/mekya.go | transport/internet/request/stereotype/mekya/mekya.go | package mekya
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/assembler/packetconn"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/assembly"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripper/httprt"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
const protocolName = "mekya"
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return nil, newError("meek is a transport")
}))
common.Must(internet.RegisterTransportDialer(protocolName, mekyaDial))
common.Must(internet.RegisterTransportListener(protocolName, mekyaListen))
}
func mekyaDial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
mekyaSetting := streamSettings.ProtocolSettings.(*Config)
packetConnAssembler := &packetconn.ClientConfig{}
packetConnAssembler.PollingIntervalInitial = mekyaSetting.PollingIntervalInitial
packetConnAssembler.MaxRequestSize = mekyaSetting.MaxRequestSize
packetConnAssembler.MaxWriteDelay = mekyaSetting.MaxWriteDelay
packetConnAssembler.UnderlyingTransportName = "kcp"
packetConnAssembler.UnderlyingTransportSetting = serial.ToTypedMessage(mekyaSetting.Kcp)
httprtSetting := &httprt.ClientConfig{
Http: &httprt.HTTPConfig{
UrlPrefix: mekyaSetting.Url,
},
H2PoolSize: mekyaSetting.H2PoolSize,
}
request := &assembly.Config{
Assembler: serial.ToTypedMessage(packetConnAssembler),
Roundtripper: serial.ToTypedMessage(httprtSetting),
}
constructedSetting := &internet.MemoryStreamConfig{
ProtocolName: "request",
ProtocolSettings: request,
SecurityType: streamSettings.SecurityType,
SecuritySettings: streamSettings.SecuritySettings,
SocketSettings: streamSettings.SocketSettings,
}
return internet.Dial(ctx, dest, constructedSetting)
}
func mekyaListen(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, callback internet.ConnHandler) (internet.Listener, error) {
mekyaSetting := streamSettings.ProtocolSettings.(*Config)
packetConnAssembler := &packetconn.ServerConfig{}
packetConnAssembler.MaxWriteSize = mekyaSetting.MaxWriteSize
packetConnAssembler.MaxSimultaneousWriteConnection = mekyaSetting.MaxSimultaneousWriteConnection
packetConnAssembler.MaxWriteDurationMs = mekyaSetting.MaxWriteDurationMs
packetConnAssembler.PacketWritingBuffer = mekyaSetting.PacketWritingBuffer
packetConnAssembler.UnderlyingTransportName = "kcp"
packetConnAssembler.UnderlyingTransportSetting = serial.ToTypedMessage(mekyaSetting.Kcp)
request := &assembly.Config{
Assembler: serial.ToTypedMessage(packetConnAssembler),
Roundtripper: serial.ToTypedMessage(&httprt.ServerConfig{}),
}
constructedSetting := &internet.MemoryStreamConfig{
ProtocolName: "request",
ProtocolSettings: request,
SecurityType: streamSettings.SecurityType,
SecuritySettings: streamSettings.SecuritySettings,
SocketSettings: streamSettings.SocketSettings,
}
return internet.ListenTCP(ctx, address, port, constructedSetting, callback)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/mekya/errors.generated.go | transport/internet/request/stereotype/mekya/errors.generated.go | package mekya
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/mekya/config.pb.go | transport/internet/request/stereotype/mekya/config.pb.go | package mekya
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
kcp "github.com/v2fly/v2ray-core/v5/transport/internet/kcp"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Kcp *kcp.Config `protobuf:"bytes,1,opt,name=kcp,proto3" json:"kcp,omitempty"`
// Client
MaxWriteDelay int32 `protobuf:"varint,1003,opt,name=max_write_delay,json=maxWriteDelay,proto3" json:"max_write_delay,omitempty"`
MaxRequestSize int32 `protobuf:"varint,1004,opt,name=max_request_size,json=maxRequestSize,proto3" json:"max_request_size,omitempty"`
PollingIntervalInitial int32 `protobuf:"varint,1005,opt,name=polling_interval_initial,json=pollingIntervalInitial,proto3" json:"polling_interval_initial,omitempty"`
// Server
MaxWriteSize int32 `protobuf:"varint,2003,opt,name=max_write_size,json=maxWriteSize,proto3" json:"max_write_size,omitempty"`
MaxWriteDurationMs int32 `protobuf:"varint,2004,opt,name=max_write_duration_ms,json=maxWriteDurationMs,proto3" json:"max_write_duration_ms,omitempty"`
MaxSimultaneousWriteConnection int32 `protobuf:"varint,2005,opt,name=max_simultaneous_write_connection,json=maxSimultaneousWriteConnection,proto3" json:"max_simultaneous_write_connection,omitempty"`
PacketWritingBuffer int32 `protobuf:"varint,2006,opt,name=packet_writing_buffer,json=packetWritingBuffer,proto3" json:"packet_writing_buffer,omitempty"`
// Roundtripper
Url string `protobuf:"bytes,3001,opt,name=url,proto3" json:"url,omitempty"`
H2PoolSize int32 `protobuf:"varint,3003,opt,name=h2_pool_size,json=h2PoolSize,proto3" json:"h2_pool_size,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_request_stereotype_mekya_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_stereotype_mekya_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_request_stereotype_mekya_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetKcp() *kcp.Config {
if x != nil {
return x.Kcp
}
return nil
}
func (x *Config) GetMaxWriteDelay() int32 {
if x != nil {
return x.MaxWriteDelay
}
return 0
}
func (x *Config) GetMaxRequestSize() int32 {
if x != nil {
return x.MaxRequestSize
}
return 0
}
func (x *Config) GetPollingIntervalInitial() int32 {
if x != nil {
return x.PollingIntervalInitial
}
return 0
}
func (x *Config) GetMaxWriteSize() int32 {
if x != nil {
return x.MaxWriteSize
}
return 0
}
func (x *Config) GetMaxWriteDurationMs() int32 {
if x != nil {
return x.MaxWriteDurationMs
}
return 0
}
func (x *Config) GetMaxSimultaneousWriteConnection() int32 {
if x != nil {
return x.MaxSimultaneousWriteConnection
}
return 0
}
func (x *Config) GetPacketWritingBuffer() int32 {
if x != nil {
return x.PacketWritingBuffer
}
return 0
}
func (x *Config) GetUrl() string {
if x != nil {
return x.Url
}
return ""
}
func (x *Config) GetH2PoolSize() int32 {
if x != nil {
return x.H2PoolSize
}
return 0
}
var File_transport_internet_request_stereotype_mekya_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_stereotype_mekya_config_proto_rawDesc = "" +
"\n" +
"8transport/internet/request/stereotype/mekya/config.proto\x126v2ray.core.transport.internet.request.stereotype.mekya\x1a common/protoext/extensions.proto\x1a#transport/internet/kcp/config.proto\"\x82\x04\n" +
"\x06Config\x12;\n" +
"\x03kcp\x18\x01 \x01(\v2).v2ray.core.transport.internet.kcp.ConfigR\x03kcp\x12'\n" +
"\x0fmax_write_delay\x18\xeb\a \x01(\x05R\rmaxWriteDelay\x12)\n" +
"\x10max_request_size\x18\xec\a \x01(\x05R\x0emaxRequestSize\x129\n" +
"\x18polling_interval_initial\x18\xed\a \x01(\x05R\x16pollingIntervalInitial\x12%\n" +
"\x0emax_write_size\x18\xd3\x0f \x01(\x05R\fmaxWriteSize\x122\n" +
"\x15max_write_duration_ms\x18\xd4\x0f \x01(\x05R\x12maxWriteDurationMs\x12J\n" +
"!max_simultaneous_write_connection\x18\xd5\x0f \x01(\x05R\x1emaxSimultaneousWriteConnection\x123\n" +
"\x15packet_writing_buffer\x18\xd6\x0f \x01(\x05R\x13packetWritingBuffer\x12\x11\n" +
"\x03url\x18\xb9\x17 \x01(\tR\x03url\x12!\n" +
"\fh2_pool_size\x18\xbb\x17 \x01(\x05R\n" +
"h2PoolSize:\x1a\x82\xb5\x18\x16\n" +
"\ttransport\x12\x05mekya\x90\xff)\x01B\xc3\x01\n" +
":com.v2ray.core.transport.internet.request.stereotype.mekyaP\x01ZJgithub.com/v2fly/v2ray-core/v5/transport/internet/request/stereotype/mekya\xaa\x026V2Ray.Core.Transport.Internet.Request.Stereotype.Mekyab\x06proto3"
var (
file_transport_internet_request_stereotype_mekya_config_proto_rawDescOnce sync.Once
file_transport_internet_request_stereotype_mekya_config_proto_rawDescData []byte
)
func file_transport_internet_request_stereotype_mekya_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_stereotype_mekya_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_stereotype_mekya_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_stereotype_mekya_config_proto_rawDesc), len(file_transport_internet_request_stereotype_mekya_config_proto_rawDesc)))
})
return file_transport_internet_request_stereotype_mekya_config_proto_rawDescData
}
var file_transport_internet_request_stereotype_mekya_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_request_stereotype_mekya_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.request.stereotype.mekya.Config
(*kcp.Config)(nil), // 1: v2ray.core.transport.internet.kcp.Config
}
var file_transport_internet_request_stereotype_mekya_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.request.stereotype.mekya.Config.kcp:type_name -> v2ray.core.transport.internet.kcp.Config
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_request_stereotype_mekya_config_proto_init() }
func file_transport_internet_request_stereotype_mekya_config_proto_init() {
if File_transport_internet_request_stereotype_mekya_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_stereotype_mekya_config_proto_rawDesc), len(file_transport_internet_request_stereotype_mekya_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_stereotype_mekya_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_stereotype_mekya_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_stereotype_mekya_config_proto_msgTypes,
}.Build()
File_transport_internet_request_stereotype_mekya_config_proto = out.File
file_transport_internet_request_stereotype_mekya_config_proto_goTypes = nil
file_transport_internet_request_stereotype_mekya_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/meek/errors.generated.go | transport/internet/request/stereotype/meek/errors.generated.go | package meek
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/meek/meek.go | transport/internet/request/stereotype/meek/meek.go | package meek
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/assembler/simple"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/assembly"
"github.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripper/httprt"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
const protocolName = "meek"
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return nil, newError("meek is a transport")
}))
common.Must(internet.RegisterTransportDialer(protocolName, meekDial))
common.Must(internet.RegisterTransportListener(protocolName, meekListen))
}
func meekDial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
meekSetting := streamSettings.ProtocolSettings.(*Config)
simpleAssembler := &simple.ClientConfig{
MaxWriteSize: 65536,
WaitSubsequentWriteMs: 10,
InitialPollingIntervalMs: 100,
MaxPollingIntervalMs: 1000,
MinPollingIntervalMs: 10,
BackoffFactor: 1.5,
FailedRetryIntervalMs: 1000,
}
httprtSetting := &httprt.ClientConfig{
Http: &httprt.HTTPConfig{
UrlPrefix: meekSetting.Url,
},
}
request := &assembly.Config{
Assembler: serial.ToTypedMessage(simpleAssembler),
Roundtripper: serial.ToTypedMessage(httprtSetting),
}
constructedSetting := &internet.MemoryStreamConfig{
ProtocolName: "request",
ProtocolSettings: request,
SecurityType: streamSettings.SecurityType,
SecuritySettings: streamSettings.SecuritySettings,
SocketSettings: streamSettings.SocketSettings,
}
return internet.Dial(ctx, dest, constructedSetting)
}
func meekListen(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, callback internet.ConnHandler) (internet.Listener, error) {
meekSetting := streamSettings.ProtocolSettings.(*Config)
simpleAssembler := &simple.ServerConfig{MaxWriteSize: 65536}
httprtSetting := &httprt.ServerConfig{NoDecodingSessionTag: true, Http: &httprt.HTTPConfig{UrlPrefix: meekSetting.Url}}
request := &assembly.Config{
Assembler: serial.ToTypedMessage(simpleAssembler),
Roundtripper: serial.ToTypedMessage(httprtSetting),
}
constructedSetting := &internet.MemoryStreamConfig{
ProtocolName: "request",
ProtocolSettings: request,
SecurityType: streamSettings.SecurityType,
SecuritySettings: streamSettings.SecuritySettings,
SocketSettings: streamSettings.SocketSettings,
}
return internet.ListenTCP(ctx, address, port, constructedSetting, callback)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/stereotype/meek/config.pb.go | transport/internet/request/stereotype/meek/config.pb.go | package meek
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_request_stereotype_meek_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_stereotype_meek_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_request_stereotype_meek_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetUrl() string {
if x != nil {
return x.Url
}
return ""
}
var File_transport_internet_request_stereotype_meek_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_stereotype_meek_config_proto_rawDesc = "" +
"\n" +
"7transport/internet/request/stereotype/meek/config.proto\x125v2ray.core.transport.internet.request.stereotype.meek\x1a common/protoext/extensions.proto\"5\n" +
"\x06Config\x12\x10\n" +
"\x03url\x18\x01 \x01(\tR\x03url:\x19\x82\xb5\x18\x15\n" +
"\ttransport\x12\x04meek\x90\xff)\x01B\xc0\x01\n" +
"9com.v2ray.core.transport.internet.request.stereotype.meekP\x01ZIgithub.com/v2fly/v2ray-core/v5/transport/internet/request/stereotype/meek\xaa\x025V2Ray.Core.Transport.Internet.Request.Stereotype.Meekb\x06proto3"
var (
file_transport_internet_request_stereotype_meek_config_proto_rawDescOnce sync.Once
file_transport_internet_request_stereotype_meek_config_proto_rawDescData []byte
)
func file_transport_internet_request_stereotype_meek_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_stereotype_meek_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_stereotype_meek_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_stereotype_meek_config_proto_rawDesc), len(file_transport_internet_request_stereotype_meek_config_proto_rawDesc)))
})
return file_transport_internet_request_stereotype_meek_config_proto_rawDescData
}
var file_transport_internet_request_stereotype_meek_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_request_stereotype_meek_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.request.stereotype.meek.Config
}
var file_transport_internet_request_stereotype_meek_config_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_request_stereotype_meek_config_proto_init() }
func file_transport_internet_request_stereotype_meek_config_proto_init() {
if File_transport_internet_request_stereotype_meek_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_stereotype_meek_config_proto_rawDesc), len(file_transport_internet_request_stereotype_meek_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_stereotype_meek_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_stereotype_meek_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_stereotype_meek_config_proto_msgTypes,
}.Build()
File_transport_internet_request_stereotype_meek_config_proto = out.File
file_transport_internet_request_stereotype_meek_config_proto_goTypes = nil
file_transport_internet_request_stereotype_meek_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripper/httprt/httprt.go | transport/internet/request/roundtripper/httprt/httprt.go | package httprt
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
import (
"bytes"
"context"
"encoding/base64"
"io"
gonet "net"
"net/http"
"time"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
)
func newHTTPRoundTripperClient(ctx context.Context, config *ClientConfig) request.RoundTripperClient {
_ = ctx
return &httpTripperClient{config: config}
}
type httpTripperClient struct {
httpRTT http.RoundTripper
config *ClientConfig
assembly request.TransportClientAssembly
}
type unimplementedBackDrop struct{}
func (u unimplementedBackDrop) RoundTrip(r *http.Request) (*http.Response, error) {
return nil, newError("unimplemented")
}
func (h *httpTripperClient) OnTransportClientAssemblyReady(assembly request.TransportClientAssembly) {
h.assembly = assembly
}
func (h *httpTripperClient) RoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
var streamingWriter io.Writer
for _, v := range opts {
if streamingResp, ok := v.(request.OptionSupportsStreamingResponse); ok {
streamingWriter = streamingResp.GetResponseWriter()
}
}
if h.httpRTT == nil {
var backDrop http.RoundTripper = unimplementedBackDrop{}
if h.config.AllowHttp {
backDrop = &http.Transport{
DialContext: func(_ context.Context, network, addr string) (gonet.Conn, error) {
return h.assembly.AutoImplDialer().Dial(ctx)
},
DialTLSContext: func(_ context.Context, network, addr string) (gonet.Conn, error) {
return nil, newError("unexpected dial of TLS")
},
}
}
h.httpRTT = transportcommon.NewALPNAwareHTTPRoundTripperWithH2Pool(ctx, func(ctx context.Context, addr string) (gonet.Conn, error) {
return h.assembly.AutoImplDialer().Dial(ctx)
}, backDrop, int(h.config.H2PoolSize))
}
connectionTagStr := base64.RawURLEncoding.EncodeToString(req.ConnectionTag)
httpRequest, err := http.NewRequest("POST", h.config.Http.UrlPrefix+h.config.Http.Path, bytes.NewReader(req.Data))
if err != nil {
return resp, err
}
httpRequest.Header.Set("X-Session-ID", connectionTagStr)
httpResp, err := h.httpRTT.RoundTrip(httpRequest)
if err != nil {
return resp, err
}
defer httpResp.Body.Close()
if httpResp.StatusCode != http.StatusOK {
newError("non-200 response: ", httpResp.Status).AtInfo().WriteToLog()
}
if streamingWriter == nil {
result, err := io.ReadAll(httpResp.Body)
if err != nil {
return request.Response{}, err
}
return request.Response{Data: result}, nil
}
_, err = io.Copy(streamingWriter, httpResp.Body)
if err != nil {
return request.Response{}, newError("unable to copy response").Base(err)
}
return request.Response{}, nil
}
func newHTTPRoundTripperServer(ctx context.Context, config *ServerConfig) request.RoundTripperServer {
return &httpTripperServer{ctx: ctx, config: config}
}
type httpTripperServer struct {
ctx context.Context
listener net.Listener
assembly request.TransportServerAssembly
config *ServerConfig
}
func (h *httpTripperServer) OnTransportServerAssemblyReady(assembly request.TransportServerAssembly) {
h.assembly = assembly
}
func (h *httpTripperServer) ServeHTTP(writer http.ResponseWriter, r *http.Request) {
h.onRequest(writer, r)
}
type httpRespStreamWriting struct {
resp http.ResponseWriter
used bool
}
func (h *httpRespStreamWriting) RoundTripperOption() {
}
func (h *httpRespStreamWriting) GetResponseWriter() io.Writer {
h.used = true
return h.resp
}
func (h *httpRespStreamWriting) Flush() {
if f, ok := h.resp.(http.Flusher); ok {
f.Flush()
}
}
func (h *httpTripperServer) onRequest(resp http.ResponseWriter, req *http.Request) {
tail := req.Header.Get("X-Session-ID")
data := []byte(tail)
if !h.config.NoDecodingSessionTag {
decodedData, err := base64.RawURLEncoding.DecodeString(tail)
if err != nil {
newError("unable to decode tag").Base(err).AtInfo().WriteToLog()
return
}
data = decodedData
}
body, err := io.ReadAll(req.Body)
req.Body.Close()
if err != nil {
newError("unable to read body").Base(err).AtInfo().WriteToLog()
}
streamingRespOption := &httpRespStreamWriting{resp: resp}
recvResp, err := h.assembly.TripperReceiver().OnRoundTrip(h.ctx, request.Request{Data: body, ConnectionTag: data},
streamingRespOption)
if err != nil {
newError("unable to process roundtrip").Base(err).AtInfo().WriteToLog()
}
if streamingRespOption.used {
return
}
_, err = io.Copy(resp, bytes.NewReader(recvResp.Data))
if err != nil {
newError("unable to send response").Base(err).AtInfo().WriteToLog()
}
}
func (h *httpTripperServer) Start() error {
listener, err := h.assembly.AutoImplListener().Listen(h.ctx)
if err != nil {
return newError("unable to create a listener for http tripper server").Base(err)
}
h.listener = listener
go func() {
httpServer := http.Server{
ReadHeaderTimeout: 240 * time.Second,
ReadTimeout: 240 * time.Second,
WriteTimeout: 240 * time.Second,
IdleTimeout: 240 * time.Second,
}
httpServer.Handler = h
err := httpServer.Serve(h.listener)
if err != nil {
newError("unable to serve listener for http tripper server").Base(err).WriteToLog()
}
}()
return nil
}
func (h *httpTripperServer) Close() error {
return h.listener.Close()
}
func init() {
common.Must(common.RegisterConfig((*ClientConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
clientConfig, ok := config.(*ClientConfig)
if !ok {
return nil, newError("not a ClientConfig")
}
return newHTTPRoundTripperClient(ctx, clientConfig), nil
}))
common.Must(common.RegisterConfig((*ServerConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
serverConfig, ok := config.(*ServerConfig)
if !ok {
return nil, newError("not a ServerConfig")
}
return newHTTPRoundTripperServer(ctx, serverConfig), nil
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripper/httprt/errors.generated.go | transport/internet/request/roundtripper/httprt/errors.generated.go | package httprt
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/request/roundtripper/httprt/config.pb.go | transport/internet/request/roundtripper/httprt/config.pb.go | package httprt
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type ClientConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
Http *HTTPConfig `protobuf:"bytes,1,opt,name=http,proto3" json:"http,omitempty"`
AllowHttp bool `protobuf:"varint,2,opt,name=allow_http,json=allowHttp,proto3" json:"allow_http,omitempty"`
H2PoolSize int32 `protobuf:"varint,3,opt,name=h2_pool_size,json=h2PoolSize,proto3" json:"h2_pool_size,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ClientConfig) Reset() {
*x = ClientConfig{}
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ClientConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ClientConfig) ProtoMessage() {}
func (x *ClientConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ClientConfig.ProtoReflect.Descriptor instead.
func (*ClientConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_roundtripper_httprt_config_proto_rawDescGZIP(), []int{0}
}
func (x *ClientConfig) GetHttp() *HTTPConfig {
if x != nil {
return x.Http
}
return nil
}
func (x *ClientConfig) GetAllowHttp() bool {
if x != nil {
return x.AllowHttp
}
return false
}
func (x *ClientConfig) GetH2PoolSize() int32 {
if x != nil {
return x.H2PoolSize
}
return 0
}
type ServerConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
Http *HTTPConfig `protobuf:"bytes,1,opt,name=http,proto3" json:"http,omitempty"`
NoDecodingSessionTag bool `protobuf:"varint,2,opt,name=no_decoding_session_tag,json=noDecodingSessionTag,proto3" json:"no_decoding_session_tag,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServerConfig) Reset() {
*x = ServerConfig{}
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServerConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerConfig) ProtoMessage() {}
func (x *ServerConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerConfig.ProtoReflect.Descriptor instead.
func (*ServerConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_roundtripper_httprt_config_proto_rawDescGZIP(), []int{1}
}
func (x *ServerConfig) GetHttp() *HTTPConfig {
if x != nil {
return x.Http
}
return nil
}
func (x *ServerConfig) GetNoDecodingSessionTag() bool {
if x != nil {
return x.NoDecodingSessionTag
}
return false
}
type HTTPConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
UrlPrefix string `protobuf:"bytes,2,opt,name=urlPrefix,proto3" json:"urlPrefix,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *HTTPConfig) Reset() {
*x = HTTPConfig{}
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *HTTPConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HTTPConfig) ProtoMessage() {}
func (x *HTTPConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HTTPConfig.ProtoReflect.Descriptor instead.
func (*HTTPConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_request_roundtripper_httprt_config_proto_rawDescGZIP(), []int{2}
}
func (x *HTTPConfig) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *HTTPConfig) GetUrlPrefix() string {
if x != nil {
return x.UrlPrefix
}
return ""
}
var File_transport_internet_request_roundtripper_httprt_config_proto protoreflect.FileDescriptor
const file_transport_internet_request_roundtripper_httprt_config_proto_rawDesc = "" +
"\n" +
";transport/internet/request/roundtripper/httprt/config.proto\x129v2ray.core.transport.internet.request.roundtripper.httprt\x1a common/protoext/extensions.proto\"\xdf\x01\n" +
"\fClientConfig\x12Y\n" +
"\x04http\x18\x01 \x01(\v2E.v2ray.core.transport.internet.request.roundtripper.httprt.HTTPConfigR\x04http\x12\x1d\n" +
"\n" +
"allow_http\x18\x02 \x01(\bR\tallowHttp\x12 \n" +
"\fh2_pool_size\x18\x03 \x01(\x05R\n" +
"h2PoolSize:3\x82\xb5\x18/\n" +
"%transport.request.roundtripper.client\x12\x06httprt\"\xd5\x01\n" +
"\fServerConfig\x12Y\n" +
"\x04http\x18\x01 \x01(\v2E.v2ray.core.transport.internet.request.roundtripper.httprt.HTTPConfigR\x04http\x125\n" +
"\x17no_decoding_session_tag\x18\x02 \x01(\bR\x14noDecodingSessionTag:3\x82\xb5\x18/\n" +
"%transport.request.roundtripper.server\x12\x06httprt\">\n" +
"\n" +
"HTTPConfig\x12\x12\n" +
"\x04path\x18\x01 \x01(\tR\x04path\x12\x1c\n" +
"\turlPrefix\x18\x02 \x01(\tR\turlPrefixB\xcc\x01\n" +
"=com.v2ray.core.transport.internet.request.roundtripper.httprtP\x01ZMgithub.com/v2fly/v2ray-core/v5/transport/internet/request/roundtripper/httprt\xaa\x029V2Ray.Core.Transport.Internet.Request.Roundtripper.httprtb\x06proto3"
var (
file_transport_internet_request_roundtripper_httprt_config_proto_rawDescOnce sync.Once
file_transport_internet_request_roundtripper_httprt_config_proto_rawDescData []byte
)
func file_transport_internet_request_roundtripper_httprt_config_proto_rawDescGZIP() []byte {
file_transport_internet_request_roundtripper_httprt_config_proto_rawDescOnce.Do(func() {
file_transport_internet_request_roundtripper_httprt_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_request_roundtripper_httprt_config_proto_rawDesc), len(file_transport_internet_request_roundtripper_httprt_config_proto_rawDesc)))
})
return file_transport_internet_request_roundtripper_httprt_config_proto_rawDescData
}
var file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
var file_transport_internet_request_roundtripper_httprt_config_proto_goTypes = []any{
(*ClientConfig)(nil), // 0: v2ray.core.transport.internet.request.roundtripper.httprt.ClientConfig
(*ServerConfig)(nil), // 1: v2ray.core.transport.internet.request.roundtripper.httprt.ServerConfig
(*HTTPConfig)(nil), // 2: v2ray.core.transport.internet.request.roundtripper.httprt.HTTPConfig
}
var file_transport_internet_request_roundtripper_httprt_config_proto_depIdxs = []int32{
2, // 0: v2ray.core.transport.internet.request.roundtripper.httprt.ClientConfig.http:type_name -> v2ray.core.transport.internet.request.roundtripper.httprt.HTTPConfig
2, // 1: v2ray.core.transport.internet.request.roundtripper.httprt.ServerConfig.http:type_name -> v2ray.core.transport.internet.request.roundtripper.httprt.HTTPConfig
2, // [2:2] is the sub-list for method output_type
2, // [2:2] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_transport_internet_request_roundtripper_httprt_config_proto_init() }
func file_transport_internet_request_roundtripper_httprt_config_proto_init() {
if File_transport_internet_request_roundtripper_httprt_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_request_roundtripper_httprt_config_proto_rawDesc), len(file_transport_internet_request_roundtripper_httprt_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 3,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_request_roundtripper_httprt_config_proto_goTypes,
DependencyIndexes: file_transport_internet_request_roundtripper_httprt_config_proto_depIdxs,
MessageInfos: file_transport_internet_request_roundtripper_httprt_config_proto_msgTypes,
}.Build()
File_transport_internet_request_roundtripper_httprt_config_proto = out.File
file_transport_internet_request_roundtripper_httprt_config_proto_goTypes = nil
file_transport_internet_request_roundtripper_httprt_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tagged/tagged.go | transport/internet/tagged/tagged.go | package tagged
import (
"context"
"github.com/v2fly/v2ray-core/v5/common/net"
)
type DialFunc func(ctx context.Context, dest net.Destination, tag string) (net.Conn, error)
var Dialer DialFunc
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tagged/taggedimpl/errors.generated.go | transport/internet/tagged/taggedimpl/errors.generated.go | package taggedimpl
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tagged/taggedimpl/impl.go | transport/internet/tagged/taggedimpl/impl.go | //go:build !confonly
// +build !confonly
package taggedimpl
import (
"context"
core "github.com/v2fly/v2ray-core/v5"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/features/routing"
"github.com/v2fly/v2ray-core/v5/transport/internet/tagged"
)
func DialTaggedOutbound(ctx context.Context, dest net.Destination, tag string) (net.Conn, error) {
var dispatcher routing.Dispatcher
if core.FromContext(ctx) == nil {
return nil, newError("Instance context variable is not in context, dial denied. ")
}
if err := core.RequireFeatures(ctx, func(dispatcherInstance routing.Dispatcher) {
dispatcher = dispatcherInstance
}); err != nil {
return nil, newError("Required Feature dispatcher not resolved").Base(err)
}
content := new(session.Content)
content.SkipDNSResolve = true
ctx = session.ContextWithContent(ctx, content)
ctx = session.SetForcedOutboundTagToContext(ctx, tag)
r, err := dispatcher.Dispatch(ctx, dest)
if err != nil {
return nil, err
}
var readerOpt net.ConnectionOption
if dest.Network == net.Network_TCP {
readerOpt = net.ConnectionOutputMulti(r.Reader)
} else {
readerOpt = net.ConnectionOutputMultiUDP(r.Reader)
}
return net.NewConnection(net.ConnectionInputMulti(r.Writer), readerOpt), nil
}
func init() {
tagged.Dialer = DialTaggedOutbound
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tagged/taggedimpl/taggedimpl.go | transport/internet/tagged/taggedimpl/taggedimpl.go | package taggedimpl
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/hub.go | transport/internet/http/hub.go | package http
import (
"context"
"io"
"net/http"
"strings"
"time"
"golang.org/x/net/http2"
"golang.org/x/net/http2/h2c"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
http_proto "github.com/v2fly/v2ray-core/v5/common/protocol/http"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/common/signal/done"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
type Listener struct {
server *http.Server
handler internet.ConnHandler
local net.Addr
config *Config
}
func (l *Listener) Addr() net.Addr {
return l.local
}
func (l *Listener) Close() error {
return l.server.Close()
}
type flushWriter struct {
w io.Writer
d *done.Instance
}
func (fw flushWriter) Write(p []byte) (n int, err error) {
if fw.d.Done() {
return 0, io.ErrClosedPipe
}
n, err = fw.w.Write(p)
if f, ok := fw.w.(http.Flusher); ok {
f.Flush()
}
return
}
func (l *Listener) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
host := request.Host
if len(l.config.Host) != 0 && !l.config.isValidHost(host) {
writer.WriteHeader(404)
return
}
path := l.config.getNormalizedPath()
if !strings.HasPrefix(request.URL.Path, path) {
writer.WriteHeader(404)
return
}
writer.Header().Set("Cache-Control", "no-store")
for _, httpHeader := range l.config.Header {
for _, httpHeaderValue := range httpHeader.Value {
writer.Header().Set(httpHeader.Name, httpHeaderValue)
}
}
writer.WriteHeader(200)
if f, ok := writer.(http.Flusher); ok {
f.Flush()
}
remoteAddr := l.Addr()
dest, err := net.ParseDestination(request.RemoteAddr)
if err != nil {
newError("failed to parse request remote addr: ", request.RemoteAddr).Base(err).WriteToLog()
} else {
remoteAddr = &net.TCPAddr{
IP: dest.Address.IP(),
Port: int(dest.Port),
}
}
forwardedAddress := http_proto.ParseXForwardedFor(request.Header)
if len(forwardedAddress) > 0 && forwardedAddress[0].Family().IsIP() {
remoteAddr = &net.TCPAddr{
IP: forwardedAddress[0].IP(),
Port: 0,
}
}
done := done.New()
conn := net.NewConnection(
net.ConnectionOutput(request.Body),
net.ConnectionInput(flushWriter{w: writer, d: done}),
net.ConnectionOnClose(common.ChainedClosable{done, request.Body}),
net.ConnectionLocalAddr(l.Addr()),
net.ConnectionRemoteAddr(remoteAddr),
)
l.handler(conn)
<-done.Wait()
}
func Listen(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, handler internet.ConnHandler) (internet.Listener, error) {
httpSettings := streamSettings.ProtocolSettings.(*Config)
var listener *Listener
if port == net.Port(0) { // unix
listener = &Listener{
handler: handler,
local: &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
},
config: httpSettings,
}
} else { // tcp
listener = &Listener{
handler: handler,
local: &net.TCPAddr{
IP: address.IP(),
Port: int(port),
},
config: httpSettings,
}
}
var server *http.Server
config := tls.ConfigFromStreamSettings(streamSettings)
if config == nil {
h2s := &http2.Server{}
server = &http.Server{
Addr: serial.Concat(address, ":", port),
Handler: h2c.NewHandler(listener, h2s),
ReadHeaderTimeout: time.Second * 4,
}
} else {
server = &http.Server{
Addr: serial.Concat(address, ":", port),
TLSConfig: config.GetTLSConfig(tls.WithNextProto("h2")),
Handler: listener,
ReadHeaderTimeout: time.Second * 4,
}
}
if streamSettings.SocketSettings != nil && streamSettings.SocketSettings.AcceptProxyProtocol {
newError("accepting PROXY protocol").AtWarning().WriteToLog(session.ExportIDToError(ctx))
}
listener.server = server
go func() {
var streamListener net.Listener
var err error
if port == net.Port(0) { // unix
streamListener, err = internet.ListenSystem(ctx, &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
}, streamSettings.SocketSettings)
if err != nil {
newError("failed to listen on ", address).Base(err).AtError().WriteToLog(session.ExportIDToError(ctx))
return
}
} else { // tcp
streamListener, err = internet.ListenSystem(ctx, &net.TCPAddr{
IP: address.IP(),
Port: int(port),
}, streamSettings.SocketSettings)
if err != nil {
newError("failed to listen on ", address, ":", port).Base(err).AtError().WriteToLog(session.ExportIDToError(ctx))
return
}
}
if config == nil {
err = server.Serve(streamListener)
if err != nil {
newError("stopping serving H2C").Base(err).WriteToLog(session.ExportIDToError(ctx))
}
} else {
err = server.ServeTLS(streamListener, "", "")
if err != nil {
newError("stopping serving TLS").Base(err).WriteToLog(session.ExportIDToError(ctx))
}
}
}()
return listener, nil
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, Listen))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/dialer.go | transport/internet/http/dialer.go | package http
import (
"context"
gotls "crypto/tls"
gonet "net"
"net/http"
"net/url"
"sync"
"golang.org/x/net/http2"
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/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
"github.com/v2fly/v2ray-core/v5/transport/pipe"
)
var (
globalDialerMap map[net.Destination]*http.Client
globalDialerAccess sync.Mutex
)
type dialerCanceller func()
func getHTTPClient(ctx context.Context, dest net.Destination, securityEngine *security.Engine, streamSettings *internet.MemoryStreamConfig) (*http.Client, dialerCanceller) {
globalDialerAccess.Lock()
defer globalDialerAccess.Unlock()
canceller := func() {
globalDialerAccess.Lock()
defer globalDialerAccess.Unlock()
delete(globalDialerMap, dest)
}
if globalDialerMap == nil {
globalDialerMap = make(map[net.Destination]*http.Client)
}
if client, found := globalDialerMap[dest]; found {
return client, canceller
}
transport := &http2.Transport{
DialTLSContext: func(_ context.Context, network, addr string, tlsConfig *gotls.Config) (gonet.Conn, error) {
rawHost, rawPort, err := net.SplitHostPort(addr)
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)
pconn, err := internet.DialSystem(detachedContext, net.TCPDestination(address, port), streamSettings.SocketSettings)
if err != nil {
return nil, err
}
cn, err := (*securityEngine).Client(pconn,
security.OptionWithDestination{Dest: dest})
if err != nil {
return nil, err
}
protocol := ""
if connAPLNGetter, ok := cn.(security.ConnectionApplicationProtocol); ok {
connectionALPN, err := connAPLNGetter.GetConnectionApplicationProtocol()
if err != nil {
return nil, newError("failed to get connection ALPN").Base(err).AtWarning()
}
protocol = connectionALPN
}
if protocol != http2.NextProtoTLS {
return nil, newError("http2: unexpected ALPN protocol " + protocol + "; want q" + http2.NextProtoTLS).AtError()
}
return cn, nil
},
}
client := &http.Client{
Transport: transport,
}
globalDialerMap[dest] = client
return client, canceller
}
// Dial dials a new TCP connection to the given destination.
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
httpSettings := streamSettings.ProtocolSettings.(*Config)
securityEngine, err := security.CreateSecurityEngineFromSettings(ctx, streamSettings)
if err != nil {
return nil, newError("unable to create security engine").Base(err)
}
if securityEngine == nil {
return nil, newError("TLS must be enabled for http transport.").AtWarning()
}
client, canceller := getHTTPClient(ctx, dest, &securityEngine, streamSettings)
opts := pipe.OptionsFromContext(ctx)
preader, pwriter := pipe.New(opts...)
breader := &buf.BufferedReader{Reader: preader}
httpMethod := "PUT"
if httpSettings.Method != "" {
httpMethod = httpSettings.Method
}
httpHeaders := make(http.Header)
for _, httpHeader := range httpSettings.Header {
for _, httpHeaderValue := range httpHeader.Value {
httpHeaders.Set(httpHeader.Name, httpHeaderValue)
}
}
request := &http.Request{
Method: httpMethod,
Host: httpSettings.getRandomHost(),
Body: breader,
URL: &url.URL{
Scheme: "https",
Host: dest.NetAddr(),
Path: httpSettings.getNormalizedPath(),
},
Proto: "HTTP/2",
ProtoMajor: 2,
ProtoMinor: 0,
Header: httpHeaders,
}
// Disable any compression method from server.
request.Header.Set("Accept-Encoding", "identity")
response, err := client.Do(request) // nolint: bodyclose
if err != nil {
canceller()
return nil, newError("failed to dial to ", dest).Base(err).AtWarning()
}
if response.StatusCode != 200 {
return nil, newError("unexpected status", response.StatusCode).AtWarning()
}
bwriter := buf.NewBufferedWriter(pwriter)
common.Must(bwriter.SetBuffered(false))
return net.NewConnection(
net.ConnectionOutput(response.Body),
net.ConnectionInput(bwriter),
net.ConnectionOnClose(common.ChainedClosable{breader, bwriter, response.Body}),
), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/errors.generated.go | transport/internet/http/errors.generated.go | package http
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/config.go | transport/internet/http/config.go | package http
import (
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/dice"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
const protocolName = "http"
func (c *Config) getHosts() []string {
if len(c.Host) == 0 {
return []string{"www.example.com"}
}
return c.Host
}
func (c *Config) isValidHost(host string) bool {
hosts := c.getHosts()
for _, h := range hosts {
if h == host {
return true
}
}
return false
}
func (c *Config) getRandomHost() string {
hosts := c.getHosts()
return hosts[dice.Roll(len(hosts))]
}
func (c *Config) getNormalizedPath() string {
if c.Path == "" {
return "/"
}
if c.Path[0] != '/' {
return "/" + c.Path
}
return c.Path
}
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/http_test.go | transport/internet/http/http_test.go | package http_test
import (
"context"
"crypto/rand"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/protocol/tls/cert"
"github.com/v2fly/v2ray-core/v5/testing/servers/tcp"
"github.com/v2fly/v2ray-core/v5/transport/internet"
. "github.com/v2fly/v2ray-core/v5/transport/internet/http"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
func TestHTTPConnection(t *testing.T) {
port := tcp.PickPort()
listener, err := Listen(context.Background(), net.LocalHostIP, port, &internet.MemoryStreamConfig{
ProtocolName: "http",
ProtocolSettings: &Config{},
SecurityType: "tls",
SecuritySettings: &tls.Config{
Certificate: []*tls.Certificate{tls.ParseCertificate(cert.MustGenerate(nil, cert.CommonName("www.v2fly.org")))},
},
}, func(conn internet.Connection) {
go func() {
defer conn.Close()
b := buf.New()
defer b.Release()
for {
if _, err := b.ReadFrom(conn); err != nil {
return
}
_, err := conn.Write(b.Bytes())
common.Must(err)
}
}()
})
common.Must(err)
defer listener.Close()
time.Sleep(time.Second)
dctx := context.Background()
conn, err := Dial(dctx, net.TCPDestination(net.LocalHostIP, port), &internet.MemoryStreamConfig{
ProtocolName: "http",
ProtocolSettings: &Config{},
SecurityType: "tls",
SecuritySettings: &tls.Config{
ServerName: "www.v2fly.org",
AllowInsecure: true,
},
})
common.Must(err)
defer conn.Close()
const N = 1024
b1 := make([]byte, N)
common.Must2(rand.Read(b1))
b2 := buf.New()
nBytes, err := conn.Write(b1)
common.Must(err)
if nBytes != N {
t.Error("write: ", nBytes)
}
b2.Clear()
common.Must2(b2.ReadFullFrom(conn, N))
if r := cmp.Diff(b2.Bytes(), b1); r != "" {
t.Error(r)
}
nBytes, err = conn.Write(b1)
common.Must(err)
if nBytes != N {
t.Error("write: ", nBytes)
}
b2.Clear()
common.Must2(b2.ReadFullFrom(conn, N))
if r := cmp.Diff(b2.Bytes(), b1); r != "" {
t.Error(r)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/http.go | transport/internet/http/http.go | package http
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/http/config.pb.go | transport/internet/http/config.pb.go | package http
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
http "github.com/v2fly/v2ray-core/v5/transport/internet/headers/http"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Host []string `protobuf:"bytes,1,rep,name=host,proto3" json:"host,omitempty"`
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"`
Header []*http.Header `protobuf:"bytes,4,rep,name=header,proto3" json:"header,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_http_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_http_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_http_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetHost() []string {
if x != nil {
return x.Host
}
return nil
}
func (x *Config) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *Config) GetMethod() string {
if x != nil {
return x.Method
}
return ""
}
func (x *Config) GetHeader() []*http.Header {
if x != nil {
return x.Header
}
return nil
}
var File_transport_internet_http_config_proto protoreflect.FileDescriptor
const file_transport_internet_http_config_proto_rawDesc = "" +
"\n" +
"$transport/internet/http/config.proto\x12\"v2ray.core.transport.internet.http\x1a common/protoext/extensions.proto\x1a,transport/internet/headers/http/config.proto\"\xb1\x01\n" +
"\x06Config\x12\x12\n" +
"\x04host\x18\x01 \x03(\tR\x04host\x12\x12\n" +
"\x04path\x18\x02 \x01(\tR\x04path\x12\x16\n" +
"\x06method\x18\x03 \x01(\tR\x06method\x12J\n" +
"\x06header\x18\x04 \x03(\v22.v2ray.core.transport.internet.headers.http.HeaderR\x06header:\x1b\x82\xb5\x18\x17\n" +
"\ttransport\x12\x02h2\x8a\xff)\x04httpB\x87\x01\n" +
"&com.v2ray.core.transport.internet.httpP\x01Z6github.com/v2fly/v2ray-core/v5/transport/internet/http\xaa\x02\"V2Ray.Core.Transport.Internet.Httpb\x06proto3"
var (
file_transport_internet_http_config_proto_rawDescOnce sync.Once
file_transport_internet_http_config_proto_rawDescData []byte
)
func file_transport_internet_http_config_proto_rawDescGZIP() []byte {
file_transport_internet_http_config_proto_rawDescOnce.Do(func() {
file_transport_internet_http_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_http_config_proto_rawDesc), len(file_transport_internet_http_config_proto_rawDesc)))
})
return file_transport_internet_http_config_proto_rawDescData
}
var file_transport_internet_http_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_http_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.http.Config
(*http.Header)(nil), // 1: v2ray.core.transport.internet.headers.http.Header
}
var file_transport_internet_http_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.http.Config.header:type_name -> v2ray.core.transport.internet.headers.http.Header
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_http_config_proto_init() }
func file_transport_internet_http_config_proto_init() {
if File_transport_internet_http_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_http_config_proto_rawDesc), len(file_transport_internet_http_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_http_config_proto_goTypes,
DependencyIndexes: file_transport_internet_http_config_proto_depIdxs,
MessageInfos: file_transport_internet_http_config_proto_msgTypes,
}.Build()
File_transport_internet_http_config_proto = out.File
file_transport_internet_http_config_proto_goTypes = nil
file_transport_internet_http_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/hub.go | transport/internet/websocket/hub.go | package websocket
import (
"bytes"
"context"
"crypto/tls"
"encoding/base64"
"io"
"net/http"
"strings"
"sync"
"time"
"github.com/gorilla/websocket"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
http_proto "github.com/v2fly/v2ray-core/v5/common/protocol/http"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
v2tls "github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
type requestHandler struct {
path string
ln *Listener
earlyDataEnabled bool
earlyDataHeaderName string
}
var upgrader = &websocket.Upgrader{
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 4,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
func (h *requestHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
responseHeader := http.Header{}
var earlyData io.Reader
if !h.earlyDataEnabled { // nolint: gocritic
if request.URL.Path != h.path {
writer.WriteHeader(http.StatusNotFound)
return
}
} else if h.earlyDataHeaderName != "" {
if request.URL.Path != h.path {
writer.WriteHeader(http.StatusNotFound)
return
}
earlyDataStr := request.Header.Get(h.earlyDataHeaderName)
earlyData = base64.NewDecoder(base64.RawURLEncoding, bytes.NewReader([]byte(earlyDataStr)))
if strings.EqualFold("Sec-WebSocket-Protocol", h.earlyDataHeaderName) {
responseHeader.Set(h.earlyDataHeaderName, earlyDataStr)
}
} else {
if strings.HasPrefix(request.URL.RequestURI(), h.path) {
earlyDataStr := request.URL.RequestURI()[len(h.path):]
earlyData = base64.NewDecoder(base64.RawURLEncoding, bytes.NewReader([]byte(earlyDataStr)))
} else {
writer.WriteHeader(http.StatusNotFound)
return
}
}
conn, err := upgrader.Upgrade(writer, request, responseHeader)
if err != nil {
newError("failed to convert to WebSocket connection").Base(err).WriteToLog()
return
}
forwardedAddrs := http_proto.ParseXForwardedFor(request.Header)
remoteAddr := conn.RemoteAddr()
if len(forwardedAddrs) > 0 && forwardedAddrs[0].Family().IsIP() {
remoteAddr = &net.TCPAddr{
IP: forwardedAddrs[0].IP(),
Port: int(0),
}
}
if earlyData == nil {
h.ln.addConn(newConnection(conn, remoteAddr))
} else {
h.ln.addConn(newConnectionWithEarlyData(conn, remoteAddr, earlyData))
}
}
type Listener struct {
sync.Mutex
server http.Server
listener net.Listener
config *Config
addConn internet.ConnHandler
}
func ListenWS(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, addConn internet.ConnHandler) (internet.Listener, error) {
l := &Listener{
addConn: addConn,
}
wsSettings := streamSettings.ProtocolSettings.(*Config)
l.config = wsSettings
if l.config != nil {
if streamSettings.SocketSettings == nil {
streamSettings.SocketSettings = &internet.SocketConfig{}
}
streamSettings.SocketSettings.AcceptProxyProtocol = l.config.AcceptProxyProtocol
}
var listener net.Listener
var err error
if port == net.Port(0) { // unix
listener, err = internet.ListenSystem(ctx, &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
}, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to listen unix domain socket(for WS) on ", address).Base(err)
}
newError("listening unix domain socket(for WS) on ", address).WriteToLog(session.ExportIDToError(ctx))
} else { // tcp
listener, err = internet.ListenSystem(ctx, &net.TCPAddr{
IP: address.IP(),
Port: int(port),
}, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to listen TCP(for WS) on ", address, ":", port).Base(err)
}
newError("listening TCP(for WS) on ", address, ":", port).WriteToLog(session.ExportIDToError(ctx))
}
if streamSettings.SocketSettings != nil && streamSettings.SocketSettings.AcceptProxyProtocol {
newError("accepting PROXY protocol").AtWarning().WriteToLog(session.ExportIDToError(ctx))
}
if config := v2tls.ConfigFromStreamSettings(streamSettings); config != nil {
if tlsConfig := config.GetTLSConfig(); tlsConfig != nil {
listener = tls.NewListener(listener, tlsConfig)
}
}
l.listener = listener
useEarlyData := false
earlyDataHeaderName := ""
if wsSettings.MaxEarlyData != 0 {
useEarlyData = true
earlyDataHeaderName = wsSettings.EarlyDataHeaderName
}
l.server = http.Server{
Handler: &requestHandler{
path: wsSettings.GetNormalizedPath(),
ln: l,
earlyDataEnabled: useEarlyData,
earlyDataHeaderName: earlyDataHeaderName,
},
ReadHeaderTimeout: time.Second * 4,
MaxHeaderBytes: http.DefaultMaxHeaderBytes,
}
go func() {
if err := l.server.Serve(l.listener); err != nil {
newError("failed to serve http for WebSocket").Base(err).AtWarning().WriteToLog(session.ExportIDToError(ctx))
}
}()
return l, err
}
// Addr implements net.Listener.Addr().
func (ln *Listener) Addr() net.Addr {
return ln.listener.Addr()
}
// Close implements net.Listener.Close().
func (ln *Listener) Close() error {
return ln.listener.Close()
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, ListenWS))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/ws.go | transport/internet/websocket/ws.go | /*
Package websocket implements Websocket transport
Websocket transport implements an HTTP(S) compliable, surveillance proof transport method with plausible deniability.
*/
package websocket
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/dialer.go | transport/internet/websocket/dialer.go | package websocket
import (
"bytes"
"context"
"encoding/base64"
"io"
gonet "net"
"net/http"
"time"
"github.com/gorilla/websocket"
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/features/extension"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
)
// Dial dials a WebSocket connection to the given destination.
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 := dialWebsocket(ctx, dest, streamSettings)
if err != nil {
return nil, newError("failed to dial WebSocket").Base(err)
}
return internet.Connection(conn), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
func dialWebsocket(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (net.Conn, error) {
wsSettings := streamSettings.ProtocolSettings.(*Config)
dialer := &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
return internet.DialSystem(ctx, dest, streamSettings.SocketSettings)
},
ReadBufferSize: 4 * 1024,
WriteBufferSize: 4 * 1024,
HandshakeTimeout: time.Second * 8,
}
protocol := "ws"
securityEngine, err := security.CreateSecurityEngineFromSettings(ctx, streamSettings)
if err != nil {
return nil, newError("unable to create security engine").Base(err)
}
if securityEngine != nil {
protocol = "wss"
dialer.NetDialTLSContext = func(ctx context.Context, network, addr string) (gonet.Conn, error) {
conn, err := dialer.NetDial(network, addr)
if err != nil {
return nil, newError("dial TLS connection failed").Base(err)
}
conn, err = securityEngine.Client(conn,
security.OptionWithDestination{Dest: dest},
security.OptionWithALPN{ALPNs: []string{"http/1.1"}})
if err != nil {
return nil, newError("unable to create security protocol client from security engine").Base(err)
}
return conn, nil
}
}
host := dest.NetAddr()
if (protocol == "ws" && dest.Port == 80) || (protocol == "wss" && dest.Port == 443) {
host = dest.Address.String()
}
uri := protocol + "://" + host + wsSettings.GetNormalizedPath()
if wsSettings.UseBrowserForwarding {
var forwarder extension.BrowserForwarder
err := core.RequireFeatures(ctx, func(Forwarder extension.BrowserForwarder) {
forwarder = Forwarder
})
if err != nil {
return nil, newError("cannot find browser forwarder service").Base(err)
}
if wsSettings.MaxEarlyData != 0 {
return newRelayedConnectionWithDelayedDial(&dialerWithEarlyDataRelayed{
forwarder: forwarder,
uriBase: uri,
config: wsSettings,
}), nil
}
conn, err := forwarder.DialWebsocket(uri, nil)
if err != nil {
return nil, newError("cannot dial with browser forwarder service").Base(err)
}
return newRelayedConnection(conn), nil
}
if wsSettings.MaxEarlyData != 0 {
return newConnectionWithDelayedDial(&dialerWithEarlyData{
dialer: dialer,
uriBase: uri,
config: wsSettings,
}), nil
}
conn, resp, err := dialer.Dial(uri, wsSettings.GetRequestHeader()) // nolint: bodyclose
if err != nil {
var reason string
if resp != nil {
reason = resp.Status
}
return nil, newError("failed to dial to (", uri, "): ", reason).Base(err)
}
return newConnection(conn, conn.RemoteAddr()), nil
}
type dialerWithEarlyData struct {
dialer *websocket.Dialer
uriBase string
config *Config
}
func (d dialerWithEarlyData) Dial(earlyData []byte) (*websocket.Conn, error) {
earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(d.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return nil, newError("websocket delayed dialer cannot encode early data").Base(encerr)
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return nil, newError("websocket delayed dialer cannot encode early data tail").Base(errc)
}
dialFunction := func() (*websocket.Conn, *http.Response, error) {
return d.dialer.Dial(d.uriBase+earlyDataBuf.String(), d.config.GetRequestHeader())
}
if d.config.EarlyDataHeaderName != "" {
dialFunction = func() (*websocket.Conn, *http.Response, error) {
earlyDataStr := earlyDataBuf.String()
currentHeader := d.config.GetRequestHeader()
currentHeader.Set(d.config.EarlyDataHeaderName, earlyDataStr)
return d.dialer.Dial(d.uriBase, currentHeader)
}
}
conn, resp, err := dialFunction() // nolint: bodyclose
if err != nil {
var reason string
if resp != nil {
reason = resp.Status
}
return nil, newError("failed to dial to (", d.uriBase, ") with early data: ", reason).Base(err)
}
if n != int64(len(earlyData)) {
if errWrite := conn.WriteMessage(websocket.BinaryMessage, earlyData[n:]); errWrite != nil {
return nil, newError("failed to dial to (", d.uriBase, ") with early data as write of remainder early data failed: ").Base(errWrite)
}
}
return conn, nil
}
type dialerWithEarlyDataRelayed struct {
forwarder extension.BrowserForwarder
uriBase string
config *Config
}
func (d dialerWithEarlyDataRelayed) Dial(earlyData []byte) (io.ReadWriteCloser, error) {
earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(d.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return nil, newError("websocket delayed dialer cannot encode early data").Base(encerr)
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return nil, newError("websocket delayed dialer cannot encode early data tail").Base(errc)
}
dialFunction := func() (io.ReadWriteCloser, error) {
return d.forwarder.DialWebsocket(d.uriBase+earlyDataBuf.String(), d.config.GetRequestHeader())
}
if d.config.EarlyDataHeaderName != "" {
earlyDataStr := earlyDataBuf.String()
currentHeader := d.config.GetRequestHeader()
currentHeader.Set(d.config.EarlyDataHeaderName, earlyDataStr)
return d.forwarder.DialWebsocket(d.uriBase, currentHeader)
}
conn, err := dialFunction()
if err != nil {
var reason string
return nil, newError("failed to dial to (", d.uriBase, ") with early data: ", reason).Base(err)
}
if n != int64(len(earlyData)) {
if _, errWrite := conn.Write(earlyData[n:]); errWrite != nil {
return nil, newError("failed to dial to (", d.uriBase, ") with early data as write of remainder early data failed: ").Base(errWrite)
}
}
return conn, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/errors.generated.go | transport/internet/websocket/errors.generated.go | package websocket
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/config.go | transport/internet/websocket/config.go | package websocket
import (
"net/http"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
const protocolName = "websocket"
func (c *Config) GetNormalizedPath() string {
path := c.Path
if path == "" {
return "/"
}
if path[0] != '/' {
return "/" + path
}
return path
}
func (c *Config) GetRequestHeader() http.Header {
header := http.Header{}
for _, h := range c.Header {
header.Add(h.Key, h.Value)
}
return header
}
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/connection.go | transport/internet/websocket/connection.go | package websocket
import (
"context"
"io"
"net"
"time"
"github.com/gorilla/websocket"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/errors"
"github.com/v2fly/v2ray-core/v5/common/serial"
)
var _ buf.Writer = (*connection)(nil)
// connection is a wrapper for net.Conn over WebSocket connection.
type connection struct {
conn *websocket.Conn
reader io.Reader
remoteAddr net.Addr
shouldWait bool
delayedDialFinish context.Context
finishedDial context.CancelFunc
dialer DelayedDialer
}
type DelayedDialer interface {
Dial(earlyData []byte) (*websocket.Conn, error)
}
func newConnection(conn *websocket.Conn, remoteAddr net.Addr) *connection {
return &connection{
conn: conn,
remoteAddr: remoteAddr,
}
}
func newConnectionWithEarlyData(conn *websocket.Conn, remoteAddr net.Addr, earlyData io.Reader) *connection {
return &connection{
conn: conn,
remoteAddr: remoteAddr,
reader: earlyData,
}
}
func newConnectionWithDelayedDial(dialer DelayedDialer) *connection {
delayedDialContext, cancelFunc := context.WithCancel(context.Background())
return &connection{
shouldWait: true,
delayedDialFinish: delayedDialContext,
finishedDial: cancelFunc,
dialer: dialer,
}
}
func newRelayedConnectionWithDelayedDial(dialer DelayedDialerForwarded) *connectionForwarder {
delayedDialContext, cancelFunc := context.WithCancel(context.Background())
return &connectionForwarder{
shouldWait: true,
delayedDialFinish: delayedDialContext,
finishedDial: cancelFunc,
dialer: dialer,
}
}
func newRelayedConnection(conn io.ReadWriteCloser) *connectionForwarder {
return &connectionForwarder{
ReadWriteCloser: conn,
shouldWait: false,
}
}
// Read implements net.Conn.Read()
func (c *connection) Read(b []byte) (int, error) {
for {
reader, err := c.getReader()
if err != nil {
return 0, err
}
nBytes, err := reader.Read(b)
if errors.Cause(err) == io.EOF {
c.reader = nil
continue
}
return nBytes, err
}
}
func (c *connection) getReader() (io.Reader, error) {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
return nil, newError("unable to read delayed dial websocket connection as it do not exist")
}
}
if c.reader != nil {
return c.reader, nil
}
_, reader, err := c.conn.NextReader()
if err != nil {
return nil, err
}
c.reader = reader
return reader, nil
}
// Write implements io.Writer.
func (c *connection) Write(b []byte) (int, error) {
if c.shouldWait {
var err error
c.conn, err = c.dialer.Dial(b)
c.finishedDial()
if err != nil {
return 0, newError("Unable to proceed with delayed write").Base(err)
}
c.remoteAddr = c.conn.RemoteAddr()
c.shouldWait = false
return len(b), nil
}
if err := c.conn.WriteMessage(websocket.BinaryMessage, b); err != nil {
return 0, err
}
return len(b), nil
}
func (c *connection) WriteMultiBuffer(mb buf.MultiBuffer) error {
mb = buf.Compact(mb)
mb, err := buf.WriteMultiBuffer(c, mb)
buf.ReleaseMulti(mb)
return err
}
func (c *connection) Close() error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
return newError("unable to close delayed dial websocket connection as it do not exist")
}
}
var errors []interface{}
if err := c.conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""), time.Now().Add(time.Second*5)); err != nil {
errors = append(errors, err)
}
if err := c.conn.Close(); err != nil {
errors = append(errors, err)
}
if len(errors) > 0 {
return newError("failed to close connection").Base(newError(serial.Concat(errors...)))
}
return nil
}
func (c *connection) LocalAddr() net.Addr {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("websocket transport is not materialized when LocalAddr() is called").AtWarning().WriteToLog()
return &net.UnixAddr{
Name: "@placeholder",
Net: "unix",
}
}
}
return c.conn.LocalAddr()
}
func (c *connection) RemoteAddr() net.Addr {
return c.remoteAddr
}
func (c *connection) SetDeadline(t time.Time) error {
if err := c.SetReadDeadline(t); err != nil {
return err
}
return c.SetWriteDeadline(t)
}
func (c *connection) SetReadDeadline(t time.Time) error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("websocket transport is not materialized when SetReadDeadline() is called").AtWarning().WriteToLog()
return nil
}
}
return c.conn.SetReadDeadline(t)
}
func (c *connection) SetWriteDeadline(t time.Time) error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("websocket transport is not materialized when SetWriteDeadline() is called").AtWarning().WriteToLog()
return nil
}
}
return c.conn.SetWriteDeadline(t)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/config.pb.go | transport/internet/websocket/config.pb.go | package websocket
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Header struct {
state protoimpl.MessageState `protogen:"open.v1"`
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Header) Reset() {
*x = Header{}
mi := &file_transport_internet_websocket_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Header) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Header) ProtoMessage() {}
func (x *Header) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_websocket_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Header.ProtoReflect.Descriptor instead.
func (*Header) Descriptor() ([]byte, []int) {
return file_transport_internet_websocket_config_proto_rawDescGZIP(), []int{0}
}
func (x *Header) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *Header) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// URL path to the WebSocket service. Empty value means root(/).
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
Header []*Header `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty"`
AcceptProxyProtocol bool `protobuf:"varint,4,opt,name=accept_proxy_protocol,json=acceptProxyProtocol,proto3" json:"accept_proxy_protocol,omitempty"`
MaxEarlyData int32 `protobuf:"varint,5,opt,name=max_early_data,json=maxEarlyData,proto3" json:"max_early_data,omitempty"`
UseBrowserForwarding bool `protobuf:"varint,6,opt,name=use_browser_forwarding,json=useBrowserForwarding,proto3" json:"use_browser_forwarding,omitempty"`
EarlyDataHeaderName string `protobuf:"bytes,7,opt,name=early_data_header_name,json=earlyDataHeaderName,proto3" json:"early_data_header_name,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_websocket_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_websocket_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_websocket_config_proto_rawDescGZIP(), []int{1}
}
func (x *Config) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *Config) GetHeader() []*Header {
if x != nil {
return x.Header
}
return nil
}
func (x *Config) GetAcceptProxyProtocol() bool {
if x != nil {
return x.AcceptProxyProtocol
}
return false
}
func (x *Config) GetMaxEarlyData() int32 {
if x != nil {
return x.MaxEarlyData
}
return 0
}
func (x *Config) GetUseBrowserForwarding() bool {
if x != nil {
return x.UseBrowserForwarding
}
return false
}
func (x *Config) GetEarlyDataHeaderName() string {
if x != nil {
return x.EarlyDataHeaderName
}
return ""
}
var File_transport_internet_websocket_config_proto protoreflect.FileDescriptor
const file_transport_internet_websocket_config_proto_rawDesc = "" +
"\n" +
")transport/internet/websocket/config.proto\x12'v2ray.core.transport.internet.websocket\x1a common/protoext/extensions.proto\"0\n" +
"\x06Header\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value\"\xd6\x02\n" +
"\x06Config\x12\x12\n" +
"\x04path\x18\x02 \x01(\tR\x04path\x12G\n" +
"\x06header\x18\x03 \x03(\v2/.v2ray.core.transport.internet.websocket.HeaderR\x06header\x122\n" +
"\x15accept_proxy_protocol\x18\x04 \x01(\bR\x13acceptProxyProtocol\x12$\n" +
"\x0emax_early_data\x18\x05 \x01(\x05R\fmaxEarlyData\x124\n" +
"\x16use_browser_forwarding\x18\x06 \x01(\bR\x14useBrowserForwarding\x123\n" +
"\x16early_data_header_name\x18\a \x01(\tR\x13earlyDataHeaderName:$\x82\xb5\x18 \n" +
"\ttransport\x12\x02ws\x8a\xff)\twebsocket\x90\xff)\x01J\x04\b\x01\x10\x02B\x96\x01\n" +
"+com.v2ray.core.transport.internet.websocketP\x01Z;github.com/v2fly/v2ray-core/v5/transport/internet/websocket\xaa\x02'V2Ray.Core.Transport.Internet.Websocketb\x06proto3"
var (
file_transport_internet_websocket_config_proto_rawDescOnce sync.Once
file_transport_internet_websocket_config_proto_rawDescData []byte
)
func file_transport_internet_websocket_config_proto_rawDescGZIP() []byte {
file_transport_internet_websocket_config_proto_rawDescOnce.Do(func() {
file_transport_internet_websocket_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_websocket_config_proto_rawDesc), len(file_transport_internet_websocket_config_proto_rawDesc)))
})
return file_transport_internet_websocket_config_proto_rawDescData
}
var file_transport_internet_websocket_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_websocket_config_proto_goTypes = []any{
(*Header)(nil), // 0: v2ray.core.transport.internet.websocket.Header
(*Config)(nil), // 1: v2ray.core.transport.internet.websocket.Config
}
var file_transport_internet_websocket_config_proto_depIdxs = []int32{
0, // 0: v2ray.core.transport.internet.websocket.Config.header:type_name -> v2ray.core.transport.internet.websocket.Header
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_websocket_config_proto_init() }
func file_transport_internet_websocket_config_proto_init() {
if File_transport_internet_websocket_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_websocket_config_proto_rawDesc), len(file_transport_internet_websocket_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_websocket_config_proto_goTypes,
DependencyIndexes: file_transport_internet_websocket_config_proto_depIdxs,
MessageInfos: file_transport_internet_websocket_config_proto_msgTypes,
}.Build()
File_transport_internet_websocket_config_proto = out.File
file_transport_internet_websocket_config_proto_goTypes = nil
file_transport_internet_websocket_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/connforwarder.go | transport/internet/websocket/connforwarder.go | package websocket
import (
"context"
"io"
"net"
"time"
)
type connectionForwarder struct {
io.ReadWriteCloser
shouldWait bool
delayedDialFinish context.Context
finishedDial context.CancelFunc
dialer DelayedDialerForwarded
}
func (c *connectionForwarder) Read(p []byte) (n int, err error) {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.ReadWriteCloser == nil {
return 0, newError("unable to read delayed dial websocket connection as it do not exist")
}
}
return c.ReadWriteCloser.Read(p)
}
func (c *connectionForwarder) Write(p []byte) (n int, err error) {
if c.shouldWait {
var err error
c.ReadWriteCloser, err = c.dialer.Dial(p)
c.finishedDial()
if err != nil {
return 0, newError("Unable to proceed with delayed write").Base(err)
}
c.shouldWait = false
return len(p), nil
}
return c.ReadWriteCloser.Write(p)
}
func (c *connectionForwarder) Close() error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.ReadWriteCloser == nil {
return newError("unable to close delayed dial websocket connection as it do not exist")
}
}
return c.ReadWriteCloser.Close()
}
func (c connectionForwarder) LocalAddr() net.Addr {
return &net.UnixAddr{
Name: "not available",
Net: "",
}
}
func (c connectionForwarder) RemoteAddr() net.Addr {
return &net.UnixAddr{
Name: "not available",
Net: "",
}
}
func (c connectionForwarder) SetDeadline(t time.Time) error {
return nil
}
func (c connectionForwarder) SetReadDeadline(t time.Time) error {
return nil
}
func (c connectionForwarder) SetWriteDeadline(t time.Time) error {
return nil
}
type DelayedDialerForwarded interface {
Dial(earlyData []byte) (io.ReadWriteCloser, error)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/websocket/ws_test.go | transport/internet/websocket/ws_test.go | package websocket_test
import (
"context"
"runtime"
"testing"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/protocol/tls/cert"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
. "github.com/v2fly/v2ray-core/v5/transport/internet/websocket"
)
func Test_listenWSAndDial(t *testing.T) {
listen, err := ListenWS(context.Background(), net.LocalHostIP, 13146, &internet.MemoryStreamConfig{
ProtocolName: "websocket",
ProtocolSettings: &Config{
Path: "ws",
},
}, func(conn internet.Connection) {
go func(c internet.Connection) {
defer c.Close()
var b [1024]byte
_, err := c.Read(b[:])
if err != nil {
return
}
common.Must2(c.Write([]byte("Response")))
}(conn)
})
common.Must(err)
ctx := context.Background()
streamSettings := &internet.MemoryStreamConfig{
ProtocolName: "websocket",
ProtocolSettings: &Config{Path: "ws"},
}
conn, err := Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146), streamSettings)
common.Must(err)
_, err = conn.Write([]byte("Test connection 1"))
common.Must(err)
var b [1024]byte
n, err := conn.Read(b[:])
common.Must(err)
if string(b[:n]) != "Response" {
t.Error("response: ", string(b[:n]))
}
common.Must(conn.Close())
<-time.After(time.Second * 5)
conn, err = Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146), streamSettings)
common.Must(err)
_, err = conn.Write([]byte("Test connection 2"))
common.Must(err)
n, err = conn.Read(b[:])
common.Must(err)
if string(b[:n]) != "Response" {
t.Error("response: ", string(b[:n]))
}
common.Must(conn.Close())
common.Must(listen.Close())
}
func TestDialWithRemoteAddr(t *testing.T) {
listen, err := ListenWS(context.Background(), net.LocalHostIP, 13148, &internet.MemoryStreamConfig{
ProtocolName: "websocket",
ProtocolSettings: &Config{
Path: "ws",
},
}, func(conn internet.Connection) {
go func(c internet.Connection) {
defer c.Close()
var b [1024]byte
_, err := c.Read(b[:])
// common.Must(err)
if err != nil {
return
}
_, err = c.Write([]byte("Response"))
common.Must(err)
}(conn)
})
common.Must(err)
conn, err := Dial(context.Background(), net.TCPDestination(net.DomainAddress("localhost"), 13148), &internet.MemoryStreamConfig{
ProtocolName: "websocket",
ProtocolSettings: &Config{Path: "ws", Header: []*Header{{Key: "X-Forwarded-For", Value: "1.1.1.1"}}},
})
common.Must(err)
_, err = conn.Write([]byte("Test connection 1"))
common.Must(err)
var b [1024]byte
n, err := conn.Read(b[:])
common.Must(err)
if string(b[:n]) != "Response" {
t.Error("response: ", string(b[:n]))
}
common.Must(listen.Close())
}
func Test_listenWSAndDial_TLS(t *testing.T) {
if runtime.GOARCH == "arm64" {
return
}
start := time.Now()
streamSettings := &internet.MemoryStreamConfig{
ProtocolName: "websocket",
ProtocolSettings: &Config{
Path: "wss",
},
SecurityType: "tls",
SecuritySettings: &tls.Config{
AllowInsecure: true,
Certificate: []*tls.Certificate{tls.ParseCertificate(cert.MustGenerate(nil, cert.CommonName("localhost")))},
},
}
listen, err := ListenWS(context.Background(), net.LocalHostIP, 13143, streamSettings, func(conn internet.Connection) {
go func() {
_ = conn.Close()
}()
})
common.Must(err)
defer listen.Close()
conn, err := Dial(context.Background(), net.TCPDestination(net.DomainAddress("localhost"), 13143), streamSettings)
common.Must(err)
_ = conn.Close()
end := time.Now()
if !end.Before(start.Add(time.Second * 5)) {
t.Error("end: ", end, " start: ", start)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/pipe/pipe_test.go | transport/pipe/pipe_test.go | package pipe_test
import (
"errors"
"io"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"golang.org/x/sync/errgroup"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
. "github.com/v2fly/v2ray-core/v5/transport/pipe"
)
func TestPipeReadWrite(t *testing.T) {
pReader, pWriter := New(WithSizeLimit(1024))
b := buf.New()
b.WriteString("abcd")
common.Must(pWriter.WriteMultiBuffer(buf.MultiBuffer{b}))
b2 := buf.New()
b2.WriteString("efg")
common.Must(pWriter.WriteMultiBuffer(buf.MultiBuffer{b2}))
rb, err := pReader.ReadMultiBuffer()
common.Must(err)
if r := cmp.Diff(rb.String(), "abcdefg"); r != "" {
t.Error(r)
}
}
func TestPipeInterrupt(t *testing.T) {
pReader, pWriter := New(WithSizeLimit(1024))
payload := []byte{'a', 'b', 'c', 'd'}
b := buf.New()
b.Write(payload)
common.Must(pWriter.WriteMultiBuffer(buf.MultiBuffer{b}))
pWriter.Interrupt()
rb, err := pReader.ReadMultiBuffer()
if err != io.ErrClosedPipe {
t.Fatal("expect io.ErrClosePipe, but got ", err)
}
if !rb.IsEmpty() {
t.Fatal("expect empty buffer, but got ", rb.Len())
}
}
func TestPipeClose(t *testing.T) {
pReader, pWriter := New(WithSizeLimit(1024))
payload := []byte{'a', 'b', 'c', 'd'}
b := buf.New()
common.Must2(b.Write(payload))
common.Must(pWriter.WriteMultiBuffer(buf.MultiBuffer{b}))
common.Must(pWriter.Close())
rb, err := pReader.ReadMultiBuffer()
common.Must(err)
if rb.String() != string(payload) {
t.Fatal("expect content ", string(payload), " but actually ", rb.String())
}
rb, err = pReader.ReadMultiBuffer()
if err != io.EOF {
t.Fatal("expected EOF, but got ", err)
}
if !rb.IsEmpty() {
t.Fatal("expect empty buffer, but got ", rb.String())
}
}
func TestPipeLimitZero(t *testing.T) {
pReader, pWriter := New(WithSizeLimit(0))
bb := buf.New()
common.Must2(bb.Write([]byte{'a', 'b'}))
common.Must(pWriter.WriteMultiBuffer(buf.MultiBuffer{bb}))
var errg errgroup.Group
errg.Go(func() error {
b := buf.New()
b.Write([]byte{'c', 'd'})
return pWriter.WriteMultiBuffer(buf.MultiBuffer{b})
})
errg.Go(func() error {
time.Sleep(time.Second)
var container buf.MultiBufferContainer
if err := buf.Copy(pReader, &container); err != nil {
return err
}
if r := cmp.Diff(container.String(), "abcd"); r != "" {
return errors.New(r)
}
return nil
})
errg.Go(func() error {
time.Sleep(time.Second * 2)
return pWriter.Close()
})
if err := errg.Wait(); err != nil {
t.Error(err)
}
}
func TestPipeWriteMultiThread(t *testing.T) {
pReader, pWriter := New(WithSizeLimit(0))
var errg errgroup.Group
for i := 0; i < 10; i++ {
errg.Go(func() error {
b := buf.New()
b.WriteString("abcd")
return pWriter.WriteMultiBuffer(buf.MultiBuffer{b})
})
}
time.Sleep(time.Millisecond * 100)
pWriter.Close()
errg.Wait()
b, err := pReader.ReadMultiBuffer()
common.Must(err)
if r := cmp.Diff(b[0].Bytes(), []byte{'a', 'b', 'c', 'd'}); r != "" {
t.Error(r)
}
}
func TestInterfaces(t *testing.T) {
_ = (buf.Reader)(new(Reader))
_ = (buf.TimeoutReader)(new(Reader))
_ = (common.Interruptible)(new(Reader))
_ = (common.Interruptible)(new(Writer))
_ = (common.Closable)(new(Writer))
}
func BenchmarkPipeReadWrite(b *testing.B) {
reader, writer := New(WithoutSizeLimit())
a := buf.New()
a.Extend(buf.Size)
c := buf.MultiBuffer{a}
b.ResetTimer()
for i := 0; i < b.N; i++ {
common.Must(writer.WriteMultiBuffer(c))
d, err := reader.ReadMultiBuffer()
common.Must(err)
c = d
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/pipe/writer.go | transport/pipe/writer.go | package pipe
import (
"github.com/v2fly/v2ray-core/v5/common/buf"
)
// Writer is a buf.Writer that writes data into a pipe.
type Writer struct {
pipe *pipe
}
// WriteMultiBuffer implements buf.Writer.
func (w *Writer) WriteMultiBuffer(mb buf.MultiBuffer) error {
return w.pipe.WriteMultiBuffer(mb)
}
// Close implements io.Closer. After the pipe is closed, writing to the pipe will return io.ErrClosedPipe, while reading will return io.EOF.
func (w *Writer) Close() error {
return w.pipe.Close()
}
// Interrupt implements common.Interruptible.
func (w *Writer) Interrupt() {
w.pipe.Interrupt()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/pipe/reader.go | transport/pipe/reader.go | package pipe
import (
"time"
"github.com/v2fly/v2ray-core/v5/common/buf"
)
// Reader is a buf.Reader that reads content from a pipe.
type Reader struct {
pipe *pipe
}
// ReadMultiBuffer implements buf.Reader.
func (r *Reader) ReadMultiBuffer() (buf.MultiBuffer, error) {
return r.pipe.ReadMultiBuffer()
}
// ReadMultiBufferTimeout reads content from a pipe within the given duration, or returns buf.ErrTimeout otherwise.
func (r *Reader) ReadMultiBufferTimeout(d time.Duration) (buf.MultiBuffer, error) {
return r.pipe.ReadMultiBufferTimeout(d)
}
// Interrupt implements common.Interruptible.
func (r *Reader) Interrupt() {
r.pipe.Interrupt()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/pipe/impl.go | transport/pipe/impl.go | package pipe
import (
"errors"
"io"
"runtime"
"sync"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/signal"
"github.com/v2fly/v2ray-core/v5/common/signal/done"
)
type state byte
const (
open state = iota
closed
errord
)
type pipeOption struct {
limit int32 // maximum buffer size in bytes
discardOverflow bool
}
func (o *pipeOption) isFull(curSize int32) bool {
return o.limit >= 0 && curSize > o.limit
}
type pipe struct {
sync.Mutex
data buf.MultiBuffer
readSignal *signal.Notifier
writeSignal *signal.Notifier
done *done.Instance
option pipeOption
state state
}
var (
errBufferFull = errors.New("buffer full")
errSlowDown = errors.New("slow down")
)
func (p *pipe) getState(forRead bool) error {
switch p.state {
case open:
if !forRead && p.option.isFull(p.data.Len()) {
return errBufferFull
}
return nil
case closed:
if !forRead {
return io.ErrClosedPipe
}
if !p.data.IsEmpty() {
return nil
}
return io.EOF
case errord:
return io.ErrClosedPipe
default:
panic("impossible case")
}
}
func (p *pipe) readMultiBufferInternal() (buf.MultiBuffer, error) {
p.Lock()
defer p.Unlock()
if err := p.getState(true); err != nil {
return nil, err
}
data := p.data
p.data = nil
return data, nil
}
func (p *pipe) ReadMultiBuffer() (buf.MultiBuffer, error) {
for {
data, err := p.readMultiBufferInternal()
if data != nil || err != nil {
p.writeSignal.Signal()
return data, err
}
select {
case <-p.readSignal.Wait():
case <-p.done.Wait():
}
}
}
func (p *pipe) ReadMultiBufferTimeout(d time.Duration) (buf.MultiBuffer, error) {
timer := time.NewTimer(d)
defer timer.Stop()
for {
data, err := p.readMultiBufferInternal()
if data != nil || err != nil {
p.writeSignal.Signal()
return data, err
}
select {
case <-p.readSignal.Wait():
case <-p.done.Wait():
case <-timer.C:
return nil, buf.ErrReadTimeout
}
}
}
func (p *pipe) writeMultiBufferInternal(mb buf.MultiBuffer) error {
p.Lock()
defer p.Unlock()
if err := p.getState(false); err != nil {
return err
}
if p.data == nil {
p.data = mb
return nil
}
p.data, _ = buf.MergeMulti(p.data, mb)
return errSlowDown
}
func (p *pipe) WriteMultiBuffer(mb buf.MultiBuffer) error {
if mb.IsEmpty() {
return nil
}
for {
err := p.writeMultiBufferInternal(mb)
if err == nil {
p.readSignal.Signal()
return nil
}
if err == errSlowDown {
p.readSignal.Signal()
// Yield current goroutine. Hopefully the reading counterpart can pick up the payload.
runtime.Gosched()
return nil
}
if err == errBufferFull && p.option.discardOverflow {
buf.ReleaseMulti(mb)
return nil
}
if err != errBufferFull {
buf.ReleaseMulti(mb)
p.readSignal.Signal()
return err
}
select {
case <-p.writeSignal.Wait():
case <-p.done.Wait():
return io.ErrClosedPipe
}
}
}
func (p *pipe) Close() error {
p.Lock()
defer p.Unlock()
if p.state == closed || p.state == errord {
return nil
}
p.state = closed
common.Must(p.done.Close())
return nil
}
// Interrupt implements common.Interruptible.
func (p *pipe) Interrupt() {
p.Lock()
defer p.Unlock()
if p.state == closed || p.state == errord {
return
}
p.state = errord
if !p.data.IsEmpty() {
buf.ReleaseMulti(p.data)
p.data = nil
}
common.Must(p.done.Close())
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/pipe/pipe.go | transport/pipe/pipe.go | package pipe
import (
"context"
"github.com/v2fly/v2ray-core/v5/common/signal"
"github.com/v2fly/v2ray-core/v5/common/signal/done"
"github.com/v2fly/v2ray-core/v5/features/policy"
)
// Option for creating new Pipes.
type Option func(*pipeOption)
// WithoutSizeLimit returns an Option for Pipe to have no size limit.
func WithoutSizeLimit() Option {
return func(opt *pipeOption) {
opt.limit = -1
}
}
// WithSizeLimit returns an Option for Pipe to have the given size limit.
func WithSizeLimit(limit int32) Option {
return func(opt *pipeOption) {
opt.limit = limit
}
}
// DiscardOverflow returns an Option for Pipe to discard writes if full.
func DiscardOverflow() Option {
return func(opt *pipeOption) {
opt.discardOverflow = true
}
}
// OptionsFromContext returns a list of Options from context.
func OptionsFromContext(ctx context.Context) []Option {
var opt []Option
bp := policy.BufferPolicyFromContext(ctx)
if bp.PerConnection >= 0 {
opt = append(opt, WithSizeLimit(bp.PerConnection))
} else {
opt = append(opt, WithoutSizeLimit())
}
return opt
}
// New creates a new Reader and Writer that connects to each other.
func New(opts ...Option) (*Reader, *Writer) {
p := &pipe{
readSignal: signal.NewNotifier(),
writeSignal: signal.NewNotifier(),
done: done.New(),
option: pipeOption{
limit: -1,
},
}
for _, opt := range opts {
opt(&(p.option))
}
return &Reader{
pipe: p,
}, &Writer{
pipe: p,
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/main.go | main.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package main
import (
"flag"
"os"
"github.com/derailed/k9s/cmd"
_ "k8s.io/client-go/plugin/pkg/client/auth"
"k8s.io/klog/v2"
)
func init() {
klog.InitFlags(nil)
var logFile string
for i, a := range os.Args {
if a == "--logFile" && i+1 < len(os.Args) {
logFile = os.Args[i+1]
break
}
}
if logFile != "" {
if err := flag.Set("log_file", logFile); err != nil {
panic(err)
}
}
if err := flag.Set("logtostderr", "false"); err != nil {
panic(err)
}
if err := flag.Set("alsologtostderr", "false"); err != nil {
panic(err)
}
if err := flag.Set("stderrthreshold", "fatal"); err != nil {
panic(err)
}
if err := flag.Set("v", "-10"); err != nil {
panic(err)
}
}
func main() {
cmd.Execute()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/cmd/root.go | cmd/root.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"errors"
"fmt"
"log/slog"
"os"
"runtime/debug"
"strings"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/color"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/view"
"github.com/lmittmann/tint"
"github.com/mattn/go-colorable"
"github.com/spf13/cobra"
"k8s.io/cli-runtime/pkg/genericclioptions"
"k8s.io/client-go/tools/clientcmd/api"
)
const (
appName = config.AppName
shortAppDesc = "A graphical CLI for your Kubernetes cluster management."
longAppDesc = "K9s is a CLI to view and manage your Kubernetes clusters."
)
var _ data.KubeSettings = (*client.Config)(nil)
var (
version, commit, date = "dev", "dev", client.NA
k9sFlags *config.Flags
k8sFlags *genericclioptions.ConfigFlags
rootCmd = &cobra.Command{
Use: appName,
Short: shortAppDesc,
Long: longAppDesc,
RunE: run,
}
out = colorable.NewColorableStdout()
)
type flagError struct{ err error }
func (e flagError) Error() string { return e.err.Error() }
func init() {
if err := config.InitLogLoc(); err != nil {
fmt.Printf("Fail to init k9s logs location %s\n", err)
}
rootCmd.SetFlagErrorFunc(func(_ *cobra.Command, err error) error {
return flagError{err: err}
})
rootCmd.AddCommand(versionCmd(), infoCmd())
initK9sFlags()
initK8sFlags()
}
// Execute root command.
func Execute() {
if err := rootCmd.Execute(); err != nil {
os.Exit(1)
}
}
func run(*cobra.Command, []string) error {
if err := config.InitLocs(); err != nil {
return err
}
logFile, err := os.OpenFile(
*k9sFlags.LogFile,
os.O_CREATE|os.O_APPEND|os.O_WRONLY,
data.DefaultFileMod,
)
if err != nil {
return fmt.Errorf("log file %q init failed: %w", *k9sFlags.LogFile, err)
}
defer func() {
if logFile != nil {
_ = logFile.Close()
}
}()
defer func() {
if err := recover(); err != nil {
slog.Error("Boom!! k9s init failed", slogs.Error, err)
slog.Error("", slogs.Stack, string(debug.Stack()))
printLogo(color.Red)
fmt.Printf("%s", color.Colorize("Boom!! ", color.Red))
fmt.Printf("%v.\n", err)
}
}()
slog.SetDefault(slog.New(tint.NewHandler(logFile, &tint.Options{
Level: parseLevel(*k9sFlags.LogLevel),
TimeFormat: time.RFC3339,
})))
cfg, err := loadConfiguration()
if err != nil {
slog.Warn("Fail to load global/context configuration", slogs.Error, err)
}
app := view.NewApp(cfg)
if app.Config.K9s.DefaultView != "" {
app.Config.SetActiveView(app.Config.K9s.DefaultView)
}
if err := app.Init(version, int(*k9sFlags.RefreshRate)); err != nil {
return err
}
if err := app.Run(); err != nil {
return err
}
if view.ExitStatus != "" {
return fmt.Errorf("view exit status %s", view.ExitStatus)
}
return nil
}
func loadConfiguration() (*config.Config, error) {
slog.Info("🐶 K9s starting up...")
k8sCfg := client.NewConfig(k8sFlags)
k9sCfg := config.NewConfig(k8sCfg)
var errs error
conn, err := client.InitConnection(k8sCfg, slog.Default())
if err != nil {
errs = errors.Join(errs, err)
}
k9sCfg.SetConnection(conn)
if err := k9sCfg.Load(config.AppConfigFile, false); err != nil {
errs = errors.Join(errs, err)
}
k9sCfg.K9s.Override(k9sFlags)
if err := k9sCfg.Refine(k8sFlags, k9sFlags, k8sCfg); err != nil {
slog.Error("Fail to refine k9s config", slogs.Error, err)
errs = errors.Join(errs, err)
}
// Try to access server version if that fail. Connectivity issue?
if !conn.CheckConnectivity() {
errs = errors.Join(errs, fmt.Errorf("cannot connect to context: %s", k9sCfg.K9s.ActiveContextName()))
}
if !conn.ConnectionOK() {
slog.Warn("💣 Kubernetes connectivity toast!")
errs = errors.Join(errs, fmt.Errorf("k8s connection failed for context: %s", k9sCfg.K9s.ActiveContextName()))
} else {
slog.Info("✅ Kubernetes connectivity OK")
}
if err := k9sCfg.Save(false); err != nil {
slog.Error("K9s config save failed", slogs.Error, err)
errs = errors.Join(errs, err)
}
return k9sCfg, errs
}
func parseLevel(level string) slog.Level {
switch level {
case "debug":
return slog.LevelDebug
case "warn":
return slog.LevelWarn
case "error":
return slog.LevelError
default:
return slog.LevelInfo
}
}
func initK9sFlags() {
k9sFlags = config.NewFlags()
rootCmd.Flags().Float32VarP(
k9sFlags.RefreshRate,
"refresh", "r",
config.DefaultRefreshRate,
"Specify the default refresh rate as a float (sec)",
)
rootCmd.Flags().StringVarP(
k9sFlags.LogLevel,
"logLevel", "l",
config.DefaultLogLevel,
"Specify a log level (error, warn, info, debug)",
)
rootCmd.Flags().StringVarP(
k9sFlags.LogFile,
"logFile", "",
config.AppLogFile,
"Specify the log file",
)
rootCmd.Flags().BoolVar(
k9sFlags.Headless,
"headless",
false,
"Turn K9s header off",
)
rootCmd.Flags().BoolVar(
k9sFlags.Logoless,
"logoless",
false,
"Turn K9s logo off",
)
rootCmd.Flags().BoolVar(
k9sFlags.Crumbsless,
"crumbsless",
false,
"Turn K9s crumbs off",
)
rootCmd.Flags().BoolVar(
k9sFlags.Splashless,
"splashless",
false,
"Turn K9s splash screen off",
)
rootCmd.Flags().BoolVarP(
k9sFlags.AllNamespaces,
"all-namespaces", "A",
false,
"Launch K9s in all namespaces",
)
rootCmd.Flags().StringVarP(
k9sFlags.Command,
"command", "c",
config.DefaultCommand,
"Overrides the default resource to load when the application launches",
)
rootCmd.Flags().BoolVar(
k9sFlags.ReadOnly,
"readonly",
false,
"Sets readOnly mode by overriding readOnly configuration setting",
)
rootCmd.Flags().BoolVar(
k9sFlags.Write,
"write",
false,
"Sets write mode by overriding the readOnly configuration setting",
)
rootCmd.Flags().StringVar(
k9sFlags.ScreenDumpDir,
"screen-dump-dir",
"",
"Sets a path to a dir for a screen dumps",
)
rootCmd.Flags()
}
func initK8sFlags() {
k8sFlags = genericclioptions.NewConfigFlags(client.UsePersistentConfig)
rootCmd.Flags().StringVar(
k8sFlags.KubeConfig,
"kubeconfig",
"",
"Path to the kubeconfig file to use for CLI requests",
)
rootCmd.Flags().StringVar(
k8sFlags.Timeout,
"request-timeout",
"",
"The length of time to wait before giving up on a single server request",
)
rootCmd.Flags().StringVar(
k8sFlags.Context,
"context",
"",
"The name of the kubeconfig context to use",
)
rootCmd.Flags().StringVar(
k8sFlags.ClusterName,
"cluster",
"",
"The name of the kubeconfig cluster to use",
)
rootCmd.Flags().StringVar(
k8sFlags.AuthInfoName,
"user",
"",
"The name of the kubeconfig user to use",
)
rootCmd.Flags().StringVarP(
k8sFlags.Namespace,
"namespace",
"n",
"",
"If present, the namespace scope for this CLI request",
)
initAsFlags()
initCertFlags()
initK8sFlagCompletion()
}
func initAsFlags() {
rootCmd.Flags().StringVar(
k8sFlags.Impersonate,
"as",
"",
"Username to impersonate for the operation",
)
rootCmd.Flags().StringArrayVar(
k8sFlags.ImpersonateGroup,
"as-group",
[]string{},
"Group to impersonate for the operation",
)
}
func initCertFlags() {
rootCmd.Flags().BoolVar(
k8sFlags.Insecure,
"insecure-skip-tls-verify",
false,
"If true, the server's caCertFile will not be checked for validity",
)
rootCmd.Flags().StringVar(
k8sFlags.CAFile,
"certificate-authority",
"",
"Path to a cert file for the certificate authority",
)
rootCmd.Flags().StringVar(
k8sFlags.KeyFile,
"client-key",
"",
"Path to a client key file for TLS",
)
rootCmd.Flags().StringVar(
k8sFlags.CertFile,
"client-certificate",
"",
"Path to a client certificate file for TLS",
)
rootCmd.Flags().StringVar(
k8sFlags.BearerToken,
"token",
"",
"Bearer token for authentication to the API server",
)
}
type (
k8sPickerFn[T any] func(cfg *api.Config) map[string]T
completeFn func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective)
)
func initK8sFlagCompletion() {
_ = rootCmd.RegisterFlagCompletionFunc("context", k8sFlagCompletion(func(cfg *api.Config) map[string]*api.Context {
return cfg.Contexts
}))
_ = rootCmd.RegisterFlagCompletionFunc("cluster", k8sFlagCompletion(func(cfg *api.Config) map[string]*api.Cluster {
return cfg.Clusters
}))
_ = rootCmd.RegisterFlagCompletionFunc("user", k8sFlagCompletion(func(cfg *api.Config) map[string]*api.AuthInfo {
return cfg.AuthInfos
}))
_ = rootCmd.RegisterFlagCompletionFunc("namespace", func(_ *cobra.Command, _ []string, s string) ([]string, cobra.ShellCompDirective) {
conn := client.NewConfig(k8sFlags)
if c, err := client.InitConnection(conn, slog.Default()); err == nil {
if nss, err := c.ValidNamespaceNames(); err == nil {
return filterFlagCompletions(nss, s)
}
}
return nil, cobra.ShellCompDirectiveError
})
}
func k8sFlagCompletion[T any](picker k8sPickerFn[T]) completeFn {
return func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
conn := client.NewConfig(k8sFlags)
cfg, err := conn.RawConfig()
if err != nil {
slog.Error("K8s raw config getter failed", slogs.Error, err)
}
return filterFlagCompletions(picker(&cfg), toComplete)
}
}
func filterFlagCompletions[T any](m map[string]T, s string) ([]string, cobra.ShellCompDirective) {
cc := make([]string, 0, len(m))
for name := range m {
if strings.HasPrefix(name, s) {
cc = append(cc, name)
}
}
return cc, cobra.ShellCompDirectiveNoFileComp
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/cmd/info_test.go | cmd/info_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"testing"
"github.com/derailed/k9s/internal/config"
"github.com/stretchr/testify/assert"
)
func Test_getScreenDumpDirForInfo(t *testing.T) {
tests := map[string]struct {
k9sConfigFile string
expectedScreenDumpDir string
}{
"withK9sConfigFile": {
k9sConfigFile: "testdata/k9s.yaml",
expectedScreenDumpDir: "/tmp",
},
"withEmptyK9sConfigFile": {
k9sConfigFile: "",
expectedScreenDumpDir: config.AppDumpsDir,
},
"withInvalidK9sConfigFilePath": {
k9sConfigFile: "invalid",
expectedScreenDumpDir: config.AppDumpsDir,
},
"withScreenDumpDirEmptyInK9sConfigFile": {
k9sConfigFile: "testdata/k9s1.yaml",
expectedScreenDumpDir: config.AppDumpsDir,
},
}
for k := range tests {
u := tests[k]
t.Run(k, func(t *testing.T) {
initK9sConfigFile := config.AppConfigFile
config.AppConfigFile = u.k9sConfigFile
assert.Equal(t, u.expectedScreenDumpDir, getScreenDumpDirForInfo())
config.AppConfigFile = initK9sConfigFile
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/cmd/version.go | cmd/version.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"fmt"
"github.com/derailed/k9s/internal/color"
"github.com/spf13/cobra"
)
func versionCmd() *cobra.Command {
var short bool
command := cobra.Command{
Use: "version",
Short: "Print version/build info",
Long: "Print version/build information",
Run: func(*cobra.Command, []string) {
printVersion(short)
},
}
command.PersistentFlags().BoolVarP(&short, "short", "s", false, "Prints K9s version info in short format")
return &command
}
func printVersion(short bool) {
const fmat = "%-20s %s\n"
var outputColor color.Paint
if short {
outputColor = -1
} else {
outputColor = color.Cyan
printLogo(outputColor)
}
printTuple(fmat, "Version", version, outputColor)
printTuple(fmat, "Commit", commit, outputColor)
printTuple(fmat, "Date", date, outputColor)
}
func printTuple(fmat, section, value string, outputColor color.Paint) {
if outputColor != -1 {
_, _ = fmt.Fprintf(out, fmat, color.Colorize(section+":", outputColor), value)
return
}
_, _ = fmt.Fprintf(out, fmat, section, value)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/cmd/info.go | cmd/info.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"fmt"
"log/slog"
"os"
"github.com/derailed/k9s/internal/color"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/spf13/cobra"
"gopkg.in/yaml.v3"
)
func infoCmd() *cobra.Command {
return &cobra.Command{
Use: "info",
Short: "List K9s configurations info",
RunE: printInfo,
}
}
func printInfo(*cobra.Command, []string) error {
if err := config.InitLocs(); err != nil {
return err
}
const fmat = "%-27s %s\n"
printLogo(color.Cyan)
printTuple(fmat, "Version", version, color.Cyan)
printTuple(fmat, "Config", config.AppConfigFile, color.Cyan)
printTuple(fmat, "Custom Views", config.AppViewsFile, color.Cyan)
printTuple(fmat, "Plugins", config.AppPluginsFile, color.Cyan)
printTuple(fmat, "Hotkeys", config.AppHotKeysFile, color.Cyan)
printTuple(fmat, "Aliases", config.AppAliasesFile, color.Cyan)
printTuple(fmat, "Skins", config.AppSkinsDir, color.Cyan)
printTuple(fmat, "Context Configs", config.AppContextsDir, color.Cyan)
printTuple(fmat, "Logs", config.AppLogFile, color.Cyan)
printTuple(fmat, "Benchmarks", config.AppBenchmarksDir, color.Cyan)
printTuple(fmat, "ScreenDumps", getScreenDumpDirForInfo(), color.Cyan)
return nil
}
func printLogo(c color.Paint) {
for _, l := range ui.LogoSmall {
_, _ = fmt.Fprintln(out, color.Colorize(l, c))
}
_, _ = fmt.Fprintln(out)
}
// getScreenDumpDirForInfo get default screen dump config dir or from config.K9sConfigFile configuration.
func getScreenDumpDirForInfo() string {
if config.AppConfigFile == "" {
return config.AppDumpsDir
}
f, err := os.ReadFile(config.AppConfigFile)
if err != nil {
slog.Error("Unable to reads k9s config file", slogs.Error, err)
return config.AppDumpsDir
}
var cfg config.Config
if err := yaml.Unmarshal(f, &cfg); err != nil {
slog.Error("Unable to unmarshal k9s config file", slogs.Error, err)
return config.AppDumpsDir
}
if cfg.K9s == nil {
return config.AppDumpsDir
}
return cfg.K9s.AppScreenDumpDir()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/pool_test.go | internal/pool_test.go | package internal_test
import (
"context"
"fmt"
"sync/atomic"
"testing"
"github.com/derailed/k9s/internal"
"github.com/stretchr/testify/assert"
)
func TestWorkerPoolPlain(t *testing.T) {
p := internal.NewWorkerPool(context.Background(), 2)
var c atomic.Int32
for range 10 {
p.Add(func(ctx context.Context) error {
select {
case <-ctx.Done():
fmt.Println("Worker canceled")
return nil
default:
c.Add(1)
return nil
}
})
}
errs := p.Drain()
assert.Equal(t, 10, int(c.Load()))
assert.Empty(t, errs)
}
func TestWorkerPoolWithError(t *testing.T) {
ctx := context.Background()
p := internal.NewWorkerPool(ctx, 2)
var c atomic.Int32
for i := range 10 {
p.Add(func(ctx context.Context) error {
select {
case <-ctx.Done():
fmt.Println("Worker canceled")
return nil
default:
if i%2 == 0 {
return fmt.Errorf("BOOM%d", i)
}
c.Add(1)
return nil
}
})
}
errs := p.Drain()
assert.Equal(t, 5, int(c.Load()))
assert.Len(t, errs, 5)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/helpers_test.go | internal/helpers_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package internal_test
import (
"testing"
"github.com/derailed/k9s/internal"
"github.com/stretchr/testify/assert"
)
func TestIsLabelSelector(t *testing.T) {
uu := map[string]struct {
s string
ok bool
}{
"empty": {s: ""},
"cool": {s: "-l app=fred,env=blee", ok: true},
"no-flag": {s: "app=fred,env=blee", ok: true},
"no-space": {s: "-lapp=fred,env=blee", ok: true},
"wrong-flag": {s: "-f app=fred,env=blee"},
"missing-key": {s: "=fred"},
"missing-val": {s: "fred="},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.ok, internal.IsLabelSelector(u.s))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/pool.go | internal/pool.go | package internal
import (
"context"
"log/slog"
"sync"
"github.com/derailed/k9s/internal/slogs"
)
const DefaultPoolSize = 10
type jobFn func(ctx context.Context) error
type WorkerPool struct {
semC chan struct{}
errC chan error
ctx context.Context
cancelFn context.CancelFunc
mx sync.RWMutex
wg sync.WaitGroup
wge sync.WaitGroup
errs []error
}
func NewWorkerPool(ctx context.Context, size int) *WorkerPool {
_, cancelFn := context.WithCancel(ctx)
p := WorkerPool{
semC: make(chan struct{}, size),
errC: make(chan error, 1),
cancelFn: cancelFn,
ctx: ctx,
}
p.wge.Add(1)
go func(wg *sync.WaitGroup) {
defer wg.Done()
for err := range p.errC {
if err != nil {
p.mx.Lock()
p.errs = append(p.errs, err)
p.mx.Unlock()
}
}
}(&p.wge)
return &p
}
func (p *WorkerPool) Add(job jobFn) {
p.semC <- struct{}{}
p.wg.Add(1)
go func(ctx context.Context, wg *sync.WaitGroup, semC <-chan struct{}, errC chan<- error) {
defer func() {
<-semC
wg.Done()
}()
if err := job(ctx); err != nil {
slog.Error("Worker error", slogs.Error, err)
errC <- err
}
}(p.ctx, &p.wg, p.semC, p.errC)
}
func (p *WorkerPool) Drain() []error {
if p.cancelFn != nil {
p.cancelFn()
p.cancelFn = nil
}
p.wg.Wait()
close(p.semC)
close(p.errC)
p.wge.Wait()
p.mx.RLock()
defer p.mx.RUnlock()
return p.errs
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/keys.go | internal/keys.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package internal
// ContextKey represents context key.
type ContextKey string
// A collection of context keys.
const (
KeyFactory ContextKey = "factory"
KeyLabels ContextKey = "labels"
KeyFields ContextKey = "fields"
KeyTable ContextKey = "table"
KeyDir ContextKey = "dir"
KeyPath ContextKey = "path"
KeySubject ContextKey = "subject"
KeyGVR ContextKey = "gvr"
KeyFQN ContextKey = "fqn"
KeyForwards ContextKey = "forwards"
KeyContainers ContextKey = "containers"
KeyBenchCfg ContextKey = "benchcfg"
KeyAliases ContextKey = "aliases"
KeyUID ContextKey = "uid"
KeySubjectKind ContextKey = "subjectKind"
KeySubjectName ContextKey = "subjectName"
KeyNamespace ContextKey = "namespace"
KeyCluster ContextKey = "cluster"
KeyApp ContextKey = "app"
KeyStyles ContextKey = "styles"
KeyMetrics ContextKey = "metrics"
KeyHasMetrics ContextKey = "has-metrics"
KeyToast ContextKey = "toast"
KeyWithMetrics ContextKey = "withMetrics"
KeyViewConfig ContextKey = "viewConfig"
KeyWait ContextKey = "wait"
KeyPodCounting ContextKey = "podCounting"
KeyEnableImgScan ContextKey = "vulScan"
)
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.