使用QUIC-Go库时，服务端可接受连接但无法接收流的问题

核心问题 #

你遇到的异常是ALPN协议协商导致QUIC连接被自动当作HTTP/3处理，底层流被HTTP/3逻辑接管，从而无法通过AcceptStream接收自定义流。

原因详解 #

服务端和客户端的TLS配置中都包含了"h3"（HTTP/3）作为NextProtos选项，QUIC-Go库会自动识别并将协商使用h3协议的连接交给HTTP/3内部逻辑处理。此时你的代码直接调用AcceptStream无法获取客户端创建的流，导致持续阻塞；客户端发送的数据被HTTP/3层拦截，服务端无法感知，最终连接因无活动被关闭。

修复步骤 #

1. 移除服务端和客户端TLS配置中的"h3"、"http/1.1"，替换为自定义协议标识（如"my-quic-demo"），避免触发HTTP/3自动处理逻辑。
2. 简化服务端不必要的连接状态打印逻辑，聚焦流处理。

修改后的服务端代码 #

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/tls"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "fmt"
    "log"
    "math/big"
    "time"

    "github.com/quic-go/quic-go"
    "golang.org/x/net/context"
)

func main() {
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        fmt.Println("Failed to generate private key:", err)
        return
    }

    template := x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject: pkix.Name{
            Organization: []string{"Org"},
        },
        NotBefore:             time.Now(),
        NotAfter:              time.Now().AddDate(1, 0, 0), // 有效期1年
        KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
        ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
        BasicConstraintsValid: true,
    }

    derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
    if err != nil {
        fmt.Println("Failed to create certificate:", err)
        return
    }

    certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
    keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)})

    cert, err := tls.X509KeyPair(certPEM, keyPEM)
    if err != nil {
        log.Fatal("Error loading certificate:", err)
    }

    tlsConfig := &tls.Config{
        Certificates:       []tls.Certificate{cert},
        InsecureSkipVerify: true, // 仅测试环境使用
        NextProtos:         []string{"my-quic-demo"}, // 自定义协议标识，避免HTTP/3自动处理
    }

    quicConfig := &quic.Config{
        Allow0RTT:       true,
        KeepAlivePeriod: time.Minute,
    }

    listener, err := quic.ListenAddr("localhost:8080", tlsConfig, quicConfig)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    log.Println("QUIC server started on localhost:8080")

    for {
        connection, err := listener.Accept(context.Background())
        if err != nil {
            log.Fatal(err)
        }
        go handleSession(connection)
    }
}

func handleSession(connection quic.Connection) {
    log.Println("New connection established:", connection.RemoteAddr().String())
    for {
        stream, err := connection.AcceptStream(context.Background())
        if err != nil {
            log.Println("Accept stream error:", err.Error())
            return
        }
        go handleRequest(stream)
    }
}

func handleRequest(stream quic.Stream) {
    buffer := make([]byte, 1024)
    numBytes, err := stream.Read(buffer)
    if err != nil {
        log.Println("Read stream error:", err)
        return
    }
    log.Printf("Received: %s\n", buffer[:numBytes])
    // 可选：向客户端返回响应
    stream.Write([]byte("Received your data!"))
    stream.Close()
}

修改后的客户端代码 #

package main

import (
    "context"
    "crypto/tls"
    "log"

    "github.com/quic-go/quic-go"
)

func main() {
    tlsConfig := &tls.Config{
        InsecureSkipVerify: true, // 仅测试环境使用
        NextProtos:         []string{"my-quic-demo"}, // 与服务端保持一致的自定义协议
    }
    addr := "localhost:8080"

    ctx := context.Background()
    connection, err := quic.DialAddr(ctx, addr, tlsConfig, nil)
    if err != nil {
        log.Fatal("Dial error:", err)
        return
    }
    defer connection.CloseWithError(0, "client closed")

    stream, err := connection.OpenStreamSync(context.Background())
    if err != nil {
        log.Fatal("Open stream error:", err)
        return
    }

    // 发送自定义数据（无需HTTP格式）
    msg := []byte("Hello QUIC Server!")
    n, err := stream.Write(msg)
    if err != nil {
        log.Fatal("Write stream error:", err)
    }
    log.Printf("Sent %d bytes: %s\n", n, msg)

    // 关闭发送方向，等待服务端响应
    stream.Close()

    // 读取服务端响应
    buf := make([]byte, 1024)
    numBytes, err := stream.Read(buf)
    if err != nil {
        log.Println("Read response error:", err)
        return
    }
    log.Printf("Received response: %s\n", buf[:numBytes])
}

额外说明 #

• 自定义协议标识只要服务端和客户端保持一致即可，避免使用h3、http/1.1这类被QUIC-Go特殊处理的协议名。
• 如果需要使用HTTP/3，应直接使用QUIC-Go提供的HTTP/3库（github.com/quic-go/quic-go/http3），而非直接操作底层QUIC流。

内容的提问来源于stack exchange，提问作者Freddie Woodruff