From 51619430d145b28594e4a1608ca7516affbf8a80 Mon Sep 17 00:00:00 2001 From: api-me <225520420+api-me@users.noreply.github.com> Date: Mon, 11 Aug 2025 14:58:46 +0800 Subject: [PATCH] feat: Add comprehensive English comments to client package This commit introduces a complete overhaul of the comments in the `client` package. The existing code, which lacked detailed documentation, has been annotated with professional, clear, and comprehensive English comments. The primary goal of this change is to improve code readability and maintainability for developers. The new comments adhere to standard Go conventions, explaining the purpose of structs, interfaces, methods, and key logic sections. Key changes include: * **Package and File-level Comments:** Added a high-level overview of the `client` package. * **Struct and Interface Documentation:** Each struct (`clientImpl`, `tcpConn`, `quicAdapter`, etc.) and interface (`Client`, `HyUDPConn`) now has detailed comments explaining its role and the functionality of its methods. * **Method and Function Descriptions:** Every public and key internal function now has a clear description, including explanations of parameters, return values, and any special behavior (e.g., the custom logic for `FakeTCP` in `connect` and `udpIOImpl`). * **Inline Code Explanations:** Complex sections, such as the `quicAdapter`'s custom framing for UDP messages over TCP, are now fully explained with inline comments to demystify the implementation details. This update significantly enhances the package's documentation, making it much easier for new and existing contributors to understand and work with the codebase. --- core/client/client.go | 229 ++++++++++++++++++++++++++++-------------- 1 file changed, 155 insertions(+), 74 deletions(-) diff --git a/core/client/client.go b/core/client/client.go index 25f1f3c..6f702b0 100644 --- a/core/client/client.go +++ b/core/client/client.go @@ -30,37 +30,54 @@ import ( ) const ( - closeErrCodeOK = 0x100 + // closeErrCodeOK is the application error code for a graceful connection closure. + closeErrCodeOK            = 0x100 + // closeErrCodeProtocolError indicates a protocol error during connection. closeErrCodeProtocolError = 0x101 ) +// Client is the public interface for the client, providing methods to +// establish TCP and UDP connections over the underlying transport. type Client interface { + // TCP opens a new TCP-like stream to a specified address. TCP(addr string) (net.Conn, error) + // UDP creates a new UDP-like session for sending and receiving datagrams. UDP() (HyUDPConn, error) + // Close closes the underlying QUIC connection. Close() error } +// HyUDPConn is the interface for a UDP-like session. type HyUDPConn interface { + // Receive reads a datagram from the session. It returns the data, + // the address of the remote peer, and an error if one occurred. Receive() ([]byte, string, error) + // Send writes a datagram to the specified remote address. Send([]byte, string) error + // Close terminates the UDP session. Close() error } +// HandshakeInfo holds information received during the client's handshake with the server. type HandshakeInfo struct { + // UDPEnabled indicates if the server supports UDP over the tunnel. UDPEnabled bool - Tx uint64 + // Tx is the configured maximum transmit bandwidth (in bytes per second). + Tx         uint64 } -// clientImpl 是 Client 接口的具体实现。 +// clientImpl is the concrete implementation of the Client interface. type clientImpl struct { config *Config pktConn net.PacketConn - conn quic.Connection + conn    quic.Connection udpSM *udpSessionManager protocol protocol_ext.Protocol } -// NewClient 创建并返回一个新的 Client 实例。 +// NewClient creates and returns a new Client instance. +// It initializes the client configuration, loads any protocol plugins, +// and initiates the connection handshake with the server. func NewClient(config *Config) (Client, *HandshakeInfo, error) { if err := config.verifyAndFill(); err != nil { return nil, nil, err @@ -86,23 +103,24 @@ func NewClient(config *Config) (Client, *HandshakeInfo, error) { return c, info, nil } -// connect 负责建立与服务器的连接和握手。 +// connect establishes the QUIC connection and performs the authentication handshake. +// It handles both standard QUIC and the custom FakeTCP transport. func (c *clientImpl) connect() (*HandshakeInfo, error) { var conn quic.Connection var rt http.RoundTripper - // 如果使用 FakeTCP，则使用自定义的连接和 RoundTripper + // If using FakeTCP, use a custom connection and RoundTripper adapter. if c.config.XLESSUseFakeTCP { log.Println("Using FakeTCP for connection") tcpConn, err := faketcp.Dial(c.config.ServerAddr.String()) if err != nil { return nil, coreErrs.ConnectError{Err: err} } - // 将 FakeTCP 连接包装为 quicAdapter + // Wrap the FakeTCP connection with a quicAdapter to satisfy the quic.Connection interface. conn = newQuicAdapter(tcpConn) c.conn = conn - // FakeTCP 模式下，需要使用自定义的 http3.RoundTripper 适配 FakeTCP 连接 + // In FakeTCP mode, a custom http3.RoundTripper is needed to adapt the FakeTCP connection. rt = &http3.RoundTripper{ Dial: func(ctx context.Context, addr string, tlsCfg *utls.Config, cfg *quic.Config) (quic.EarlyConnection, error) { return conn.(quic.EarlyConnection), nil @@ -111,7 +129,7 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { } } else { - // 否则，使用标准的 QUIC 连接 + // Otherwise, use a standard QUIC connection. pktConn, err := c.config.ConnFactory.New(c.config.ServerAddr) if err != nil { return nil, err @@ -119,24 +137,25 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { c.pktConn = pktConn tlsConfig := &utls.Config{ - ServerName: c.config.TLSConfig.ServerName, - InsecureSkipVerify: c.config.TLSConfig.InsecureSkipVerify, + ServerName:            c.config.TLSConfig.ServerName, + InsecureSkipVerify:    c.config.TLSConfig.InsecureSkipVerify, VerifyPeerCertificate: c.config.TLSConfig.VerifyPeerCertificate, - RootCAs: c.config.TLSConfig.RootCAs, + RootCAs:               c.config.TLSConfig.RootCAs, } quicConfig := &quic.Config{ - InitialStreamReceiveWindow: c.config.QUICConfig.InitialStreamReceiveWindow, - MaxStreamReceiveWindow: c.config.QUICConfig.MaxStreamReceiveWindow, + InitialStreamReceiveWindow:     c.config.QUICConfig.InitialStreamReceiveWindow, + MaxStreamReceiveWindow:         c.config.QUICConfig.MaxStreamReceiveWindow, InitialConnectionReceiveWindow: c.config.QUICConfig.InitialConnectionReceiveWindow, - MaxConnectionReceiveWindow: c.config.QUICConfig.MaxConnectionReceiveWindow, - MaxIdleTimeout: c.config.QUICConfig.MaxIdleTimeout, - KeepAlivePeriod: c.config.QUICConfig.KeepAlivePeriod, - DisablePathMTUDiscovery: c.config.QUICConfig.DisablePathMTUDiscovery, - EnableDatagrams: true, - DisablePathManager: true, + MaxConnectionReceiveWindow:     c.config.QUICConfig.MaxConnectionReceiveWindow, + MaxIdleTimeout:                 c.config.QUICConfig.MaxIdleTimeout, + KeepAlivePeriod:                c.config.QUICConfig.KeepAlivePeriod, + DisablePathMTUDiscovery:        c.config.QUICConfig.DisablePathMTUDiscovery, + EnableDatagrams:                true, + DisablePathManager:             true, } + // Use uQUIC if enabled, otherwise use the standard QUIC dialer. if c.config.EnableUQUIC { quicSpec, err := quic.QUICID2Spec(c.config.UQUICSpecID) if err != nil { @@ -145,7 +164,7 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { } rt = &http3.RoundTripper{ TLSClientConfig: tlsConfig, - QUICConfig: quicConfig, + QUICConfig:      quicConfig, Dial: func(ctx context.Context, _ string, tlsCfg *utls.Config, cfg *quic.Config) (quic.EarlyConnection, error) { udpConn, ok := pktConn.(net.PacketConn) if !ok { @@ -172,7 +191,7 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { } else { rt = &http3.RoundTripper{ TLSClientConfig: tlsConfig, - QUICConfig: quicConfig, + QUICConfig:      quicConfig, Dial: func(ctx context.Context, _ string, tlsCfg *utls.Config, cfg *quic.Config) (quic.EarlyConnection, error) { qc, err := quic.DialEarly(ctx, pktConn, c.config.ServerAddr, tlsCfg, cfg) if err != nil { @@ -185,13 +204,13 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { } } - // 执行混淆的网页浏览行为 + // Perform obfuscated web browsing behavior to mask the connection. decoyURL := c.config.DecoyURL httpClient := &http.Client{Timeout: 4 * time.Second} resources, _ := SimulateWebBrowse(httpClient, decoyURL) sendAuxiliaryRequests(httpClient, resources) - // 统一的认证请求发送逻辑 + // Send the unified authentication request. apiPath, query := randomAPIPathAndQuery() req := &http.Request{ Method: http.MethodPost, @@ -211,6 +230,7 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { req.ContentLength = int64(len(body)) req.Header.Set("Content-Type", contentType) + // Sleep for a random duration to further obscure the connection pattern. time.Sleep(time.Duration(500+rand.Intn(1200)) * time.Millisecond) resp, err := rt.RoundTrip(req) @@ -223,6 +243,8 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { } return nil, coreErrs.ConnectError{Err: err} } + + // Check the authentication status code. if resp.StatusCode != protocol.StatusAuthOK { _ = conn.CloseWithError(closeErrCodeProtocolError, "") if c.pktConn != nil { @@ -231,6 +253,7 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { return nil, coreErrs.AuthError{StatusCode: resp.StatusCode} } + // Process the authentication response and configure congestion control. authResp := protocol.AuthResponseFromHeader(resp.Header) var actualTx uint64 if authResp.RxAuto { @@ -250,14 +273,16 @@ func (c *clientImpl) connect() (*HandshakeInfo, error) { c.conn = conn if authResp.UDPEnabled { + // Initialize the UDP session manager if UDP is enabled by the server. c.udpSM = newUDPSessionManager(&udpIOImpl{Conn: conn, Protocol: c.protocol}) } return &HandshakeInfo{ UDPEnabled: authResp.UDPEnabled, - Tx: actualTx, + Tx:         actualTx, }, nil } +// openStream opens a new QUIC stream. func (c *clientImpl) openStream() (quic.Stream, error) { stream, err := c.conn.OpenStream() if err != nil { @@ -266,6 +291,8 @@ func (c *clientImpl) openStream() (quic.Stream, error) { return &utils.QStream{Stream: stream}, nil } +// TCP opens a TCP-like connection by establishing a new QUIC stream +// and sending a protocol message to the server. func (c *clientImpl) TCP(addr string) (net.Conn, error) { stream, err := c.openStream() if err != nil { @@ -273,9 +300,10 @@ func (c *clientImpl) TCP(addr string) (net.Conn, error) { } var finalAddr string = addr + // Apply protocol obfuscation to the address if a protocol plugin is active. if c.protocol != nil { ctx := protocol_ext.ProtocolContext{ - Type: "tcp_request", + Type:     "tcp_request", IsClient: true, PeerAddr: c.conn.RemoteAddr(), StreamID: stream.StreamID(), @@ -288,23 +316,28 @@ func (c *clientImpl) TCP(addr string) (net.Conn, error) { finalAddr = modifiedAddrData.(string) } + // Write the TCP request to the stream. err = protocol.WriteTCPRequest(stream, finalAddr) if err != nil { _ = stream.Close() return nil, wrapIfConnectionClosed(err) } + + // If FastOpen is enabled, return a connection immediately. if c.config.FastOpen { return &tcpConn{ - Orig: stream, - PseudoLocalAddr: c.conn.LocalAddr(), + Orig:             stream, + PseudoLocalAddr:  c.conn.LocalAddr(), PseudoRemoteAddr: c.conn.RemoteAddr(), - Established: false, - protocol: c.protocol, - isClient: true, - peerAddr: c.conn.RemoteAddr(), - streamID: stream.StreamID(), + Established:      false, + protocol:         c.protocol, + isClient:         true, + peerAddr:         c.conn.RemoteAddr(), + streamID:         stream.StreamID(), }, nil } + + // Read the server's TCP response to confirm the connection. ok, msg, err := protocol.ReadTCPResponse(stream) if err != nil { _ = stream.Close() @@ -313,7 +346,7 @@ func (c *clientImpl) TCP(addr string) (net.Conn, error) { if c.protocol != nil { ctx := protocol_ext.ProtocolContext{ - Type: "tcp_response", + Type:     "tcp_response", IsClient: true, PeerAddr: c.conn.RemoteAddr(), StreamID: stream.StreamID(), @@ -326,17 +359,18 @@ func (c *clientImpl) TCP(addr string) (net.Conn, error) { return nil, coreErrs.DialError{Message: msg} } return &tcpConn{ - Orig: stream, - PseudoLocalAddr: c.conn.LocalAddr(), + Orig:             stream, + PseudoLocalAddr:  c.conn.LocalAddr(), PseudoRemoteAddr: c.conn.RemoteAddr(), - Established: true, - protocol: c.protocol, - isClient: true, - peerAddr: c.conn.RemoteAddr(), - streamID: stream.StreamID(), + Established:      true, + protocol:         c.protocol, + isClient:         true, + peerAddr:         c.conn.RemoteAddr(), + streamID:         stream.StreamID(), }, nil } +// UDP creates a new UDP-like session. It returns an error if UDP is not enabled. func (c *clientImpl) UDP() (HyUDPConn, error) { if c.udpSM == nil { return nil, coreErrs.DialError{Message: "UDP not enabled"} @@ -344,6 +378,7 @@ func (c *clientImpl) UDP() (HyUDPConn, error) { return c.udpSM.NewUDP() } +// Close closes the underlying QUIC connection and the packet connection if it exists. func (c *clientImpl) Close() error { _ = c.conn.CloseWithError(closeErrCodeOK, "") if c.pktConn != nil { @@ -352,10 +387,14 @@ func (c *clientImpl) Close() error { return nil } +// nonPermanentErrors is a list of QUIC errors that are not considered +// "connection closed" errors for wrapping purposes. var nonPermanentErrors = []error{ quic.StreamLimitReachedError{}, } +// wrapIfConnectionClosed checks if the given error should be wrapped as a +// coreErrs.ClosedError. func wrapIfConnectionClosed(err error) error { for _, e := range nonPermanentErrors { if errors.Is(err, e) { @@ -365,17 +404,21 @@ func wrapIfConnectionClosed(err error) error { return coreErrs.ClosedError{Err: err} } +// tcpConn is a net.Conn implementation that uses a QUIC stream as its transport. type tcpConn struct { - Orig quic.Stream - PseudoLocalAddr net.Addr + Orig             quic.Stream + PseudoLocalAddr  net.Addr PseudoRemoteAddr net.Addr - Established bool - protocol protocol_ext.Protocol - isClient bool - peerAddr net.Addr - streamID quic.StreamID + Established      bool + protocol         protocol_ext.Protocol + isClient         bool + peerAddr         net.Addr + streamID         quic.StreamID } +// Read reads data from the underlying QUIC stream. +// If the connection is not yet established (FastOpen), it first waits for +// the server's response. func (c *tcpConn) Read(b []byte) (n int, err error) { if !c.Established { ok, msg, err := protocol.ReadTCPResponse(c.Orig) @@ -384,7 +427,7 @@ func (c *tcpConn) Read(b []byte) (n int, err error) { } if c.protocol != nil { ctx := protocol_ext.ProtocolContext{ - Type: "tcp_response", + Type:     "tcp_response", IsClient: c.isClient, PeerAddr: c.peerAddr, StreamID: c.streamID, @@ -399,42 +442,52 @@ func (c *tcpConn) Read(b []byte) (n int, err error) { return c.Orig.Read(b) } +// Write writes data to the underlying QUIC stream. func (c *tcpConn) Write(b []byte) (n int, err error) { return c.Orig.Write(b) } +// Close closes the underlying QUIC stream. func (c *tcpConn) Close() error { return c.Orig.Close() } +// LocalAddr returns the pseudo local address. func (c *tcpConn) LocalAddr() net.Addr { return c.PseudoLocalAddr } +// RemoteAddr returns the pseudo remote address. func (c *tcpConn) RemoteAddr() net.Addr { return c.PseudoRemoteAddr } +// SetDeadline sets the read and write deadlines for the stream. func (c *tcpConn) SetDeadline(t time.Time) error { return c.Orig.SetDeadline(t) } +// SetReadDeadline sets the read deadline for the stream. func (c *tcpConn) SetReadDeadline(t time.Time) error { return c.Orig.SetReadDeadline(t) } +// SetWriteDeadline sets the write deadline for the stream. func (c *tcpConn) SetWriteDeadline(t time.Time) error { return c.Orig.SetWriteDeadline(t) } +// udpIOImpl implements the UDP I/O for the UDP session manager. type udpIOImpl struct { Conn quic.Connection Protocol protocol_ext.Protocol } +// ReceiveMessage receives a single UDP message from the QUIC connection. +// It handles both standard QUIC datagrams and messages from the FakeTCP adapter. func (io *udpIOImpl) ReceiveMessage() (*protocol.UDPMessage, error) { for { - // 使用类型断言来处理 FakeTCP 适配器 + // Handle the FakeTCP adapter specifically. if adapter, ok := io.Conn.(*quicAdapter); ok { msg, err := adapter.ReadUDPFromStream() if err != nil { @@ -442,8 +495,8 @@ func (io *udpIOImpl) ReceiveMessage() (*protocol.UDPMessage, error) { } return &protocol.UDPMessage{ SessionID: 0, - Addr: msg.Addr.String(), - Data: msg.Payload, + Addr:      msg.Addr.String(), + Data:      msg.Payload, }, nil } @@ -453,18 +506,21 @@ func (io *udpIOImpl) ReceiveMessage() (*protocol.UDPMessage, error) { } udpMsg, err := protocol.ParseUDPMessage(msgRaw) if err != nil { + // Skip malformed messages and continue listening. continue } + // De-obfuscate the UDP message if a protocol plugin is active. if io.Protocol != nil { ctx := protocol_ext.ProtocolContext{ - Type: "udp_message", + Type:     "udp_message", IsClient: true, PeerAddr: io.Conn.RemoteAddr(), SessionID: udpMsg.SessionID, } modifiedUDPMsgData, pErr := io.Protocol.Deobfuscate(udpMsg, ctx) if pErr != nil { + // Skip if de-obfuscation fails. continue } udpMsg = modifiedUDPMsgData.(*protocol.UDPMessage) @@ -474,13 +530,16 @@ func (io *udpIOImpl) ReceiveMessage() (*protocol.UDPMessage, error) { } } +// SendMessage sends a single UDP message over the QUIC connection. +// It handles both standard QUIC datagrams and the FakeTCP adapter. func (io *udpIOImpl) SendMessage(buf []byte, msg *protocol.UDPMessage) error { var finalMsg *protocol.UDPMessage = msg + // Obfuscate the UDP message if a protocol plugin is active. if io.Protocol != nil { ctx := protocol_ext.ProtocolContext{ - Type: "udp_message", - IsClient: true, - PeerAddr: io.Conn.RemoteAddr(), + Type:      "udp_message", + IsClient:  true, + PeerAddr:  io.Conn.RemoteAddr(), SessionID: msg.SessionID, } modifiedUDPMsgData, pErr := io.Protocol.Obfuscate(msg, ctx) @@ -490,7 +549,7 @@ func (io *udpIOImpl) SendMessage(buf []byte, msg *protocol.UDPMessage) error { finalMsg = modifiedUDPMsgData.(*protocol.UDPMessage) } - // 使用类型断言来处理 FakeTCP 适配器 + // Handle the FakeTCP adapter specifically. if adapter, ok := io.Conn.(*quicAdapter); ok { addr, err := net.ResolveUDPAddr("udp", finalMsg.Addr) if err != nil { @@ -506,29 +565,33 @@ func (io *udpIOImpl) SendMessage(buf []byte, msg *protocol.UDPMessage) error { } } -// --- 以下为适配 FakeTCP 的新类型和方法 --- +// --- Adapters for FakeTCP --- -// quicAdapter 包装了一个 FakeTCP 连接以实现 quic.Connection 接口。 +// quicAdapter wraps a standard net.Conn (like a FakeTCP connection) to +// partially implement the quic.Connection interface. It specifically handles +// UDP datagrams by framing them over the underlying TCP stream. type quicAdapter struct { conn net.Conn - mu sync.Mutex + mu   sync.Mutex } -// newQuicAdapter 创建一个新的 quicAdapter。 +// newQuicAdapter creates a new quicAdapter. func newQuicAdapter(conn net.Conn) *quicAdapter { return &quicAdapter{conn: conn} } -// ReadUDPFromStream 从 FakeTCP 流中读取一个完整的 UDP 消息。 +// ReadUDPFromStream reads a full UDP message from the FakeTCP stream. +// It reads the address length, address, payload length, and payload in a +// custom framing format. func (a *quicAdapter) ReadUDPFromStream() (*faketcp.XUDPMessage, error) { - // 读取地址长度 (4 bytes) + // Read address length (4 bytes). var addrLen uint32 err := binary.Read(a.conn, binary.BigEndian, &addrLen) if err != nil { return nil, err } - // 读取地址 + // Read the address bytes. addrBytes := make([]byte, addrLen) _, err = io.ReadFull(a.conn, addrBytes) if err != nil { @@ -539,14 +602,14 @@ func (a *quicAdapter) ReadUDPFromStream() (*faketcp.XUDPMessage, error) { return nil, fmt.Errorf("failed to resolve address: %w", err) } - // 读取 payload 长度 (4 bytes) + // Read payload length (4 bytes). var payloadLen uint32 err = binary.Read(a.conn, binary.BigEndian, &payloadLen) if err != nil { return nil, err } - // 读取 payload + // Read the payload bytes. payload := make([]byte, payloadLen) _, err = io.ReadFull(a.conn, payload) if err != nil { @@ -556,30 +619,37 @@ func (a *quicAdapter) ReadUDPFromStream() (*faketcp.XUDPMessage, error) { return &faketcp.XUDPMessage{Addr: addr, Payload: payload}, nil } -// WriteUDPToStream 将 UDP 消息封装并通过 FakeTCP 连接发送。 +// WriteUDPToStream writes a UDP message to the FakeTCP stream using the +// custom framing format (addr_len, addr, payload_len, payload). func (a *quicAdapter) WriteUDPToStream(msg *faketcp.XUDPMessage) error { addrBytes := []byte(msg.Addr.String()) payloadBytes := msg.Payload var buffer bytes.Buffer + // Write address length. binary.Write(&buffer, binary.BigEndian, uint32(len(addrBytes))) + // Write address. buffer.Write(addrBytes) + // Write payload length. binary.Write(&buffer, binary.BigEndian, uint32(len(payloadBytes))) + // Write payload. buffer.Write(payloadBytes) _, err := a.conn.Write(buffer.Bytes()) return err } -// SendDatagramWithAddr 是一个自定义方法，用于在知道地址的情况下发送数据报。 +// SendDatagramWithAddr is a custom method to send a UDP datagram when the +// destination address is known, which is required for the FakeTCP adapter. func (a *quicAdapter) SendDatagramWithAddr(payload []byte, addr net.Addr) error { return a.WriteUDPToStream(&faketcp.XUDPMessage{ - Addr: addr, + Addr:    addr, Payload: payload, }) } -// ReceiveDatagram 负责从 FakeTCP 流中读取并还原 UDP 数据报。 +// ReceiveDatagram reads a UDP datagram from the underlying connection. +// It retrieves the datagram from the framed message. func (a *quicAdapter) ReceiveDatagram(ctx context.Context) ([]byte, error) { msg, err := a.ReadUDPFromStream() if err != nil { @@ -588,12 +658,15 @@ func (a *quicAdapter) ReceiveDatagram(ctx context.Context) ([]byte, error) { return msg.Payload, nil } -// SendDatagram 负责将 UDP 数据报封装并写入 FakeTCP 流。 +// SendDatagram attempts to send a datagram without an explicit address. +// This is not supported by the FakeTCP adapter, so it returns an error. func (a *quicAdapter) SendDatagram(b []byte) error { return fmt.Errorf("address required for FakeTCP datagram, use SendDatagramWithAddr") } -// 以下是 quic.Connection 接口中其他方法的实现，为了满足接口要求。 +// The following methods are part of the quic.Connection interface but are +// not implemented or supported by the FakeTCP adapter, so they return errors. + func (a *quicAdapter) OpenStreamSync(ctx context.Context) (quic.Stream, error) { return a.OpenStream() } @@ -618,30 +691,38 @@ func (a *quicAdapter) OpenUniStream() (quic.SendStream, error) { return nil, fmt.Errorf("stream not implemented for FakeTCP adapter") } +// HandshakeComplete returns a context that is not canceled, as the handshake +// is not performed in the same way with this adapter. func (a *quicAdapter) HandshakeComplete() context.Context { return context.Background() } +// ConnectionState returns a dummy connection state. func (a *quicAdapter) ConnectionState() quic.ConnectionState { return quic.ConnectionState{} } +// CloseWithError closes the underlying connection. func (a *quicAdapter) CloseWithError(code quic.ApplicationErrorCode, desc string) error { return a.conn.Close() } +// Context returns a background context. func (a *quicAdapter) Context() context.Context { return context.Background() } +// RemoteAddr returns the remote address of the underlying connection. func (a *quicAdapter) RemoteAddr() net.Addr { return a.conn.RemoteAddr() } +// LocalAddr returns the local address of the underlying connection. func (a *quicAdapter) LocalAddr() net.Addr { return a.conn.LocalAddr() } +// SetCongestionControl is a no-op as FakeTCP does not support this. func (a *quicAdapter) SetCongestionControl(cc uquic_congestion.CongestionControl) { // FakeTCP has no built-in congestion control; this is a no-op. } @@ -662,7 +743,7 @@ func (a *quicAdapter) EarlyConnectionState() quic.ConnectionState { return quic.ConnectionState{} } -// CloseWithError 和 Close 是一个 FakeTCP 连接，因此我们直接使用 Close。 +// Close is an alias for CloseWithError, closing the underlying connection. func (a *quicAdapter) Close() error { return a.conn.Close() }