quic-go源码一---server启动

前言：

走马观花地看了RFC 9000UIC: A UDP-Based Multiplexed and Secure Transport，
感受不是那么直观，以是再来看看这个协议的golang语言实现：quic-go,增强学习。
https://quic-go.net/docs/quic/quic-go文档

本篇准备的代码片断如下：

1. const addr = "127.0.0.1:9000"
3. func main() {
4.         quicConf := &quic.Config{
5.                 InitialStreamReceiveWindow:     1 << 20,  // 1 MB
6.                 MaxStreamReceiveWindow:         6 << 20,  // 6 MB
7.                 InitialConnectionReceiveWindow: 2 << 20,  // 2 MB
8.                 MaxConnectionReceiveWindow:     12 << 20, // 12 MB
9.         }
10.         // 学习点1
11.         listener, err := quic.ListenAddr(addr, generateTLSConfig(), quicConf)
13.         if err != nil {
14.                 log.Fatalf("Error listening on address: %v", err)
15.         }
16.         defer listener.Close()
18.         for {
19.                 // 学习点2
20.                 conn, err := listener.Accept(context.Background())
21.                 if err != nil {
22.                         log.Printf("Error accepting connection: %v", err)
23.                         continue
24.                 }
26.                 go handleConnection(conn)
27.                 fmt.Println("New client connected")
28.         }
29. }
31. func handleConnection(conn quic.Connection) {
32.         for {
33.                 // 接收数据流
34.                 stream, err := conn.AcceptStream(context.Background())
35.                 // 。。。。。。
36.         }
37. }
39. func generateTLSConfig() *tls.Config {
40.         key, err := rsa.GenerateKey(rand.Reader, 1024)
41.         if err != nil {
42.                 panic(err)
43.         }
44.         template := x509.Certificate{SerialNumber: big.NewInt(1)}
45.         certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
46.         if err != nil {
47.                 panic(err)
48.         }
49.         keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
50.         certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
52.         tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
53.         if err != nil {
54.                 panic(err)
55.         }
56.         return &tls.Config{
57.                 Certificates: []tls.Certificate{tlsCert},
58.                 NextProtos:   []string{"TEST"},
59.         }
60. }

复制代码

看点1

1. listener, err := quic.ListenAddr(addr, generateTLSConfig(), quicConf)

复制代码

先记住参数

1. createdConn: true,
2. isSingleUse: true,

复制代码

其中conn, err := listenUDP(addr)是net udp常规操纵，略过不提。
以是核心是调用了Transport.Listener(tlsConf, quicConf)方法。但是注意其中的参数，呃，我们先看官网文档：

使用简写方式：我们demo正是如此：

看看官方的实现：恰好印证了文档的正确性：

接着看 Transport.Listen(…)

上述allow0RTT为true/false的区别在于，以是当使用ListenEarly(。。。)（allow0RTT为true）时，服务端会开辟一个map：

官网文档如下：To allow clients to use 0-RTT resumption, the Allow0RTT flag needs to be set on the quic.Config.（为了能够使用0-RTT, 需要在 quic.Config设置Allow0RTT标识）
固然也得用ListenEarly() 而不是Listen()

allow0RTT在本篇只是带过，知道有个概念，后续有机会学习分析。。。
接着看 Transport.createServer(…)

validateConfig(…)：

populateConfig(config *Config)

t.init(false)

wrapConn(..)核心如下：

1. setReceiveBuffer(pc net.PacketConn)
2. setSendBuffer(pc)
4. supportsDF, err = setDF(rawConn)
6. // 优化点在这里！
7. c, ok := pc.(OOBCapablePacketConn)
8. if !ok {
9.         return &basicConn{PacketConn: pc, supportsDF: supportsDF}, nil
10. }
11. return newConn(c, supportsDF)

复制代码

其中前2项性质都一样:

1. _ = conn.SetReadBuffer(protocol.DesiredReceiveBufferSize) // 7 MB
3. err := fd.pfd.SetsockoptInt(syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes)
4. size, serr = unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_SNDBUF)

复制代码

其中setDF(rawConn syscall.RawConn)实现紧张逻辑如下：

1. errDFIPv4 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_DONTFRAG, 1)
2. errDFIPv6 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_DONTFRAG, 1)

复制代码

再看看newConn(...)

只激活了读取ipv4的ECN：

末了返回的conn如下：

说完了wrapConn(...)后再回到init(...)

1. // is closed when listen returns
2. t.listening = make(chan struct{})

复制代码

DefaultConnectionIDGenerator初始化：

getMultiplexer().AddConn(t.Conn)：

1. func getMultiplexer() multiplexer {
2.         connMuxerOnce.Do(func() {
3.                 connMuxer = &connMultiplexer{
4.                         conns:  make(map[string]indexableConn),
5.                         logger: utils.DefaultLogger.WithPrefix("muxer"),
6.                 }
7.         })
8.         return connMuxer
9. }
11. func (m *connMultiplexer) AddConn(c indexableConn) {
12.         m.mutex.Lock()
13.         defer m.mutex.Unlock()
15.         connIndex := m.index(c.LocalAddr())
16.         p, ok := m.conns[connIndex]
17.         if ok {
18.                 // 后续会去掉panic(...)
19.                 panic("connection already exists") // TODO: write a nice message
20.         }
21.         m.conns[connIndex] = p
22. }

复制代码

尚有末了2行代码：协程启动的：

1. go t.listen(conn)
2. go t.runSendQueue()

复制代码

这里先不展开怎样处理数据包的逻辑，先把整体流程熟悉起来。

init方法终于结束了！还差末了一个newServer(...):

1. go s.run()
2. go s.runSendQueue()

复制代码

正是transport.handlePacket(p receivedPacket)调用server.handlePacket(p receivedPacket)

1. func (s *baseServer) handlePacket(p receivedPacket) {
2.         select {
3.         case s.receivedPackets <- p: // 【看这里看这里看这里看这里】
4.         default:
5.                 s.logger.Debugf("Dropping packet from %s (%d bytes). Server receive queue full.", p.remoteAddr, p.Size())
6.                 if s.tracer != nil && s.tracer.DroppedPacket != nil {
7.                         s.tracer.DroppedPacket(p.remoteAddr, logging.PacketTypeNotDetermined, p.Size(), logging.PacketDropDOSPrevention)
8.                 }
9.         }
10. }

复制代码

但是上面第299行的s.handlePacketImpl(p)很紧张，后续篇再分析。

1. func (s *baseServer) sendRetry(p rejectedPacket) {
2.         if err := s.sendRetryPacket(p); err != nil {
3.                 s.logger.Debugf("Error sending Retry packet: %s", err)
4.         }
5. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。