我们可以通过QUIC/HTTP3将请求从服务器发送到客户端，并获取响应。

huangapple
go评论107阅读模式
英文:

Can we send request form server to client and get response through quic/http3?

问题

我正在使用quic-go来实现我的想法，我需要服务器主动向客户端发送请求并获取响应，就像客户端通常发送请求到Web服务器一样。但是使用quic-go，在建立连接之后，服务器可以初始化流以向客户端发送请求并获取响应吗？我尝试过，但还没有成功。下面的代码是来自示例目录中的echo.go，两个注释行之间的部分是我添加的。

  1. package main
  3. import (
  4. 	"context"
  5. 	"crypto/rand"
  6. 	"crypto/rsa"
  7. 	"crypto/tls"
  8. 	"crypto/x509"
  9. 	"encoding/pem"
  10. 	"fmt"
  11. 	"io"
  12. 	"log"
  13. 	"math/big"
  15. 	"github.com/lucas-clemente/quic-go"
  16. )
  18. const addr = "localhost:4242"
  20. const message = "foobar"
  22. // 我们启动一个服务器，在客户端打开的第一个流上回显数据，
  23. // 然后与客户端建立连接，发送消息，并等待接收。
  24. func main() {
  25. 	go func() { log.Fatal(echoServer()) }()
  27. 	err := clientMain()
  28. 	if err != nil {
  29. 		panic(err)
  30. 	}
  31. }
  33. // 启动一个服务器，在客户端打开的第一个流上回显所有数据
  34. func echoServer() error {
  35. 	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
  36. 	if err != nil {
  37. 		return err
  38. 	}
  39. 	conn, err := listener.Accept(context.Background())
  40. 	if err != nil {
  41. 		return err
  42. 	}
  43. 	stream, err := conn.AcceptStream(context.Background())
  44. 	if err != nil {
  45. 		panic(err)
  46. 	}
  47. 	// 通过loggingWriter回显
  48. 	_, err = io.Copy(loggingWriter{stream}, stream)
  49. 	if err != nil {
  50. 		panic(err)
  51. 	}
  53. 	//------------------------------
  54. 	stream1, err := conn.OpenStream()
  55. 	if err != nil {
  56. 		panic(err)
  57. 	}
  59. 	message := "aaaaa"
  61. 	fmt.Printf("2-Server: Sending '%s'\n", message)
  63. 	_, err = stream1.Write([]byte(message))
  64. 	//------------------------------
  65. 	return err
  66. }
  68. func clientMain() error {
  69. 	tlsConf := &tls.Config{
  70. 		InsecureSkipVerify: true,
  71. 		NextProtos:         []string{"quic-echo-example"},
  72. 	}
  73. 	conn, err := quic.DialAddr(addr, tlsConf, nil)
  74. 	if err != nil {
  75. 		return err
  76. 	}
  78. 	stream, err := conn.OpenStreamSync(context.Background())
  79. 	if err != nil {
  80. 		return err
  81. 	}
  83. 	fmt.Printf("Client: Sending '%s'\n", message)
  84. 	_, err = stream.Write([]byte(message))
  85. 	if err != nil {
  86. 		return err
  87. 	}
  89. 	buf := make([]byte, len(message))
  90. 	_, err = io.ReadFull(stream, buf)
  91. 	if err != nil {
  92. 		return err
  93. 	}
  94. 	fmt.Printf("Client: Got '%s'\n", buf)
  95. 	err = stream.Close()
  96. 	if err != nil {
  97. 		return err
  98. 	}
  100. 	//-------------------------------
  101. 	for {
  102. 		stream1, err := conn.AcceptStream(context.Background())
  103. 		if err != nil {
  104. 			panic(err)
  105. 		}
  107. 		buf1 := make([]byte, len(message))
  108. 		_, err = io.ReadFull(stream1, buf1)
  109. 		if err != nil {
  110. 			panic(err)
  111. 		}
  112. 		fmt.Printf("2-Client: Got '%s'\n", buf1)
  114. 		err = stream1.Close()
  115. 		if err != nil {
  116. 			panic(err)
  117. 		}
  118. 	}
  119. 	//-------------------------------
  121. 	return nil
  122. }
  124. // 一个同时记录消息的io.Writer包装器。
  125. type loggingWriter struct{ io.Writer }
  127. func (w loggingWriter) Write(b []byte) (int, error) {
  128. 	fmt.Printf("Server: Got '%s'\n", string(b))
  129. 	return w.Writer.Write(b)
  130. }
  132. // 为服务器设置一个简单的TLS配置
  133. func generateTLSConfig() *tls.Config {
  134. 	key, err := rsa.GenerateKey(rand.Reader, 1024)
  135. 	if err != nil {
  136. 		panic(err)
  137. 	}
  138. 	template := x509.Certificate{SerialNumber: big.NewInt(1)}
  139. 	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
  140. 	if err != nil {
  141. 		panic(err)
  142. 	}
  143. 	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
  144. 	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
  146. 	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
  147. 	if err != nil {
  148. 		panic(err)
  149. 	}
  150. 	return &tls.Config{
  151. 		Certificates: []tls.Certificate{tlsCert},
  152. 		NextProtos:   []string{"quic-echo-example"},
  153. 	}
  154. }
英文:

I'm using quic-go to implement my thought, I need the server to forwardly send request to client to get response, just like we do that client sends request to web server commonly. But with quic-go, after connection is setup, can server initialize streams to send request to client and get responses? I did a trying but haven't made it work. The code below is from the echo.go of example dir, the two parts between comment lines are added by me.

  1. package main
  3. import (
  4. 	"context"
  5. 	"crypto/rand"
  6. 	"crypto/rsa"
  7. 	"crypto/tls"
  8. 	"crypto/x509"
  9. 	"encoding/pem"
  10. 	"fmt"
  11. 	"io"
  12. 	"log"
  13. 	"math/big"
  15. 	"github.com/lucas-clemente/quic-go"
  16. )
  18. const addr = "localhost:4242"
  20. const message = "foobar"
  22. // We start a server echoing data on the first stream the client opens,
  23. // then connect with a client, send the message, and wait for its receipt.
  24. func main() {
  25. 	go func() { log.Fatal(echoServer()) }()
  27. 	err := clientMain()
  28. 	if err != nil {
  29. 		panic(err)
  30. 	}
  31. }
  33. // Start a server that echos all data on the first stream opened by the client
  34. func echoServer() error {
  35. 	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
  36. 	if err != nil {
  37. 		return err
  38. 	}
  39. 	conn, err := listener.Accept(context.Background())
  40. 	if err != nil {
  41. 		return err
  42. 	}
  43. 	stream, err := conn.AcceptStream(context.Background())
  44. 	if err != nil {
  45. 		panic(err)
  46. 	}
  47. 	// Echo through the loggingWriter
  48. 	_, err = io.Copy(loggingWriter{stream}, stream)
  49. 	if err != nil {
  50. 		panic(err)
  51. 	}
  53. 	//------------------------------
  54. 	stream1, err := conn.OpenStream()
  55. 	if err != nil {
  56. 		panic(err)
  57. 	}
  59. 	message := "aaaaa"
  61. 	fmt.Printf("2-Server: Sending '%s'\n", message)
  63. 	_, err = stream1.Write([]byte(message))
  64. 	//------------------------------
  65. 	return err
  66. }
  68. func clientMain() error {
  69. 	tlsConf := &tls.Config{
  70. 		InsecureSkipVerify: true,
  71. 		NextProtos:         []string{"quic-echo-example"},
  72. 	}
  73. 	conn, err := quic.DialAddr(addr, tlsConf, nil)
  74. 	if err != nil {
  75. 		return err
  76. 	}
  78. 	stream, err := conn.OpenStreamSync(context.Background())
  79. 	if err != nil {
  80. 		return err
  81. 	}
  83. 	fmt.Printf("Client: Sending '%s'\n", message)
  84. 	_, err = stream.Write([]byte(message))
  85. 	if err != nil {
  86. 		return err
  87. 	}
  89. 	buf := make([]byte, len(message))
  90. 	_, err = io.ReadFull(stream, buf)
  91. 	if err != nil {
  92. 		return err
  93. 	}
  94. 	fmt.Printf("Client: Got '%s'\n", buf)
  95. 	err = stream.Close()
  96. 	if err != nil {
  97. 		return err
  98. 	}
  100. 	//-------------------------------
  101. 	for {
  102. 		stream1, err := conn.AcceptStream(context.Background())
  103. 		if err != nil {
  104. 			panic(err)
  105. 		}
  107. 		buf1 := make([]byte, len(message))
  108. 		_, err = io.ReadFull(stream1, buf1)
  109. 		if err != nil {
  110. 			panic(err)
  111. 		}
  112. 		fmt.Printf("2-Client: Got '%s'\n", buf1)
  114. 		err = stream1.Close()
  115. 		if err != nil {
  116. 			panic(err)
  117. 		}
  118. 	}
  119. 	//-------------------------------
  121. 	return nil
  122. }
  124. // A wrapper for io.Writer that also logs the message.
  125. type loggingWriter struct{ io.Writer }
  127. func (w loggingWriter) Write(b []byte) (int, error) {
  128. 	fmt.Printf("Server: Got '%s'\n", string(b))
  129. 	return w.Writer.Write(b)
  130. }
  132. // Setup a bare-bones TLS config for the server
  133. func generateTLSConfig() *tls.Config {
  134. 	key, err := rsa.GenerateKey(rand.Reader, 1024)
  135. 	if err != nil {
  136. 		panic(err)
  137. 	}
  138. 	template := x509.Certificate{SerialNumber: big.NewInt(1)}
  139. 	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
  140. 	if err != nil {
  141. 		panic(err)
  142. 	}
  143. 	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
  144. 	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
  146. 	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
  147. 	if err != nil {
  148. 		panic(err)
  149. 	}
  150. 	return &tls.Config{
  151. 		Certificates: []tls.Certificate{tlsCert},
  152. 		NextProtos:   []string{"quic-echo-example"},
  153. 	}
  154. }

答案1

得分: 2

你离答案很近。

注意服务器在写入并返回数据之后，会在客户端有机会读取和处理数据之前调用log.Fatal。

请注意message变量，一个长度为6，另一个长度只有5。

请正确关闭流，服务器在交接之前没有结束它。

  1. package main
  3. import (
  4. 	"context"
  5. 	"crypto/rand"
  6. 	"crypto/rsa"
  7. 	"crypto/tls"
  8. 	"crypto/x509"
  9. 	"encoding/pem"
  10. 	"fmt"
  11. 	"io"
  12. 	"log"
  13. 	"math/big"
  15. 	"github.com/lucas-clemente/quic-go"
  16. )
  18. const addr = "localhost:4242"
  20. const message = "foobar"
  22. // 我们启动一个服务器，在客户端打开的第一个流上回显数据，
  23. // 然后与客户端建立连接，发送消息，并等待接收。
  24. func main() {
  25. 	go func() {
  26. 		err := echoServer()
  27. 		if err != nil {
  28. 			log.Println(err)
  29. 		}
  30. 	}()
  32. 	err := clientMain()
  33. 	if err != nil {
  34. 		panic(err)
  35. 	}
  36. }
  38. // 启动一个服务器，在客户端打开的第一个流上回显所有数据
  39. func echoServer() error {
  40. 	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
  41. 	if err != nil {
  42. 		return err
  43. 	}
  44. 	conn, err := listener.Accept(context.Background())
  45. 	if err != nil {
  46. 		return err
  47. 	}
  48. 	stream, err := conn.AcceptStream(context.Background())
  49. 	if err != nil {
  50. 		panic(err)
  51. 	}
  52. 	// 通过loggingWriter回显
  53. 	_, err = io.Copy(loggingWriter{stream}, stream)
  54. 	if err != nil {
  55. 		log.Println(err)
  56. 		return err
  57. 	}
  59. 	//------------------------------
  60. 	fmt.Printf("Server: 打开流\n")
  61. 	stream1, err := conn.OpenStream()
  62. 	if err != nil {
  63. 		return err
  64. 	}
  66. 	fmt.Printf("2-Server: 发送 '%s'\n", message)
  68. 	var n int
  69. 	n, err = stream1.Write([]byte(message))
  70. 	fmt.Printf("Server: 写入 %v %v\n", n, err)
  71. 	stream1.Close()
  72. 	//------------------------------
  73. 	return err
  74. }
  76. func clientMain() error {
  77. 	tlsConf := &tls.Config{
  78. 		InsecureSkipVerify: true,
  79. 		NextProtos:         []string{"quic-echo-example"},
  80. 	}
  81. 	conn, err := quic.DialAddr(addr, tlsConf, nil)
  82. 	if err != nil {
  83. 		return err
  84. 	}
  86. 	stream, err := conn.OpenStreamSync(context.Background())
  87. 	if err != nil {
  88. 		return err
  89. 	}
  91. 	fmt.Printf("Client: 发送 '%s'\n", message)
  92. 	_, err = stream.Write([]byte(message))
  93. 	if err != nil {
  94. 		return err
  95. 	}
  97. 	buf := make([]byte, len(message))
  98. 	_, err = io.ReadFull(stream, buf)
  99. 	if err != nil {
  100. 		return err
  101. 	}
  102. 	fmt.Printf("Client: 收到 '%s'\n", buf)
  103. 	err = stream.Close()
  104. 	if err != nil {
  105. 		return err
  106. 	}
  108. 	//-------------------------------
  109. 	for {
  110. 		fmt.Printf("Client: 接受流\n")
  111. 		stream1, err := conn.AcceptStream(context.Background())
  112. 		if err != nil {
  113. 			return err
  114. 		}
  116. 		fmt.Printf("Client: 收到流 %v\n", err)
  117. 		buf1 := make([]byte, len(message))
  118. 		_, err = io.ReadFull(stream1, buf1)
  119. 		if err != nil {
  120. 			return err
  121. 		}
  122. 		fmt.Printf("2-Client: 收到 '%s'\n", buf1)
  124. 		err = stream1.Close()
  125. 		if err != nil {
  126. 			return err
  127. 		}
  128. 		break
  129. 	}
  130. 	//-------------------------------
  132. 	return nil
  133. }
  135. // 一个同时记录消息的io.Writer包装器。
  136. type loggingWriter struct{ io.Writer }
  138. func (w loggingWriter) Write(b []byte) (int, error) {
  139. 	fmt.Printf("Server: 收到 '%s'\n", string(b))
  140. 	return w.Writer.Write(b)
  141. }
  143. // 为服务器设置一个基本的TLS配置
  144. func generateTLSConfig() *tls.Config {
  145. 	key, err := rsa.GenerateKey(rand.Reader, 1024)
  146. 	if err != nil {
  147. 		panic(err)
  148. 	}
  149. 	template := x509.Certificate{SerialNumber: big.NewInt(1)}
  150. 	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
  151. 	if err != nil {
  152. 		panic(err)
  153. 	}
  154. 	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
  155. 	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
  157. 	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
  158. 	if err != nil {
  159. 		panic(err)
  160. 	}
  161. 	return &tls.Config{
  162. 		Certificates: []tls.Certificate{tlsCert},
  163. 		NextProtos:   []string{"quic-echo-example"},
  164. 	}
  165. }
英文:

You are close.

Notice how the server writes, then returns, it reaches out to log.Fatal before the client had a chance to read and handle the data.

Take care to the message variable, one is 6 length long, the other one is only 5 length long.

Properly close your stream, the server was not ending it ending before handing over;

  1. package main
  3. import (
  4. 	"context"
  5. 	"crypto/rand"
  6. 	"crypto/rsa"
  7. 	"crypto/tls"
  8. 	"crypto/x509"
  9. 	"encoding/pem"
  10. 	"fmt"
  11. 	"io"
  12. 	"log"
  13. 	"math/big"
  15. 	"github.com/lucas-clemente/quic-go"
  16. )
  18. const addr = "localhost:4242"
  20. const message = "foobar"
  22. // We start a server echoing data on the first stream the client opens,
  23. // then connect with a client, send the message, and wait for its receipt.
  24. func main() {
  25. 	go func() {
  26. 		err := echoServer()
  27. 		if err != nil {
  28. 			log.Println(err)
  29. 		}
  30. 	}()
  32. 	err := clientMain()
  33. 	if err != nil {
  34. 		panic(err)
  35. 	}
  36. }
  38. // Start a server that echos all data on the first stream opened by the client
  39. func echoServer() error {
  40. 	listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
  41. 	if err != nil {
  42. 		return err
  43. 	}
  44. 	conn, err := listener.Accept(context.Background())
  45. 	if err != nil {
  46. 		return err
  47. 	}
  48. 	stream, err := conn.AcceptStream(context.Background())
  49. 	if err != nil {
  50. 		panic(err)
  51. 	}
  52. 	// Echo through the loggingWriter
  53. 	_, err = io.Copy(loggingWriter{stream}, stream)
  54. 	if err != nil {
  55. 		log.Println(err)
  56. 		return err
  57. 	}
  59. 	//------------------------------
  60. 	fmt.Printf("Server: open stream\n")
  61. 	stream1, err := conn.OpenStream()
  62. 	if err != nil {
  63. 		return err
  64. 	}
  66. 	fmt.Printf("2-Server: Sending '%s'\n", message)
  68. 	var n int
  69. 	n, err = stream1.Write([]byte(message))
  70. 	fmt.Printf("Server: write %v %v\n", n, err)
  71. 	stream1.Close()
  72. 	//------------------------------
  73. 	return err
  74. }
  76. func clientMain() error {
  77. 	tlsConf := &tls.Config{
  78. 		InsecureSkipVerify: true,
  79. 		NextProtos:         []string{"quic-echo-example"},
  80. 	}
  81. 	conn, err := quic.DialAddr(addr, tlsConf, nil)
  82. 	if err != nil {
  83. 		return err
  84. 	}
  86. 	stream, err := conn.OpenStreamSync(context.Background())
  87. 	if err != nil {
  88. 		return err
  89. 	}
  91. 	fmt.Printf("Client: Sending '%s'\n", message)
  92. 	_, err = stream.Write([]byte(message))
  93. 	if err != nil {
  94. 		return err
  95. 	}
  97. 	buf := make([]byte, len(message))
  98. 	_, err = io.ReadFull(stream, buf)
  99. 	if err != nil {
  100. 		return err
  101. 	}
  102. 	fmt.Printf("Client: Got '%s'\n", buf)
  103. 	err = stream.Close()
  104. 	if err != nil {
  105. 		return err
  106. 	}
  108. 	//-------------------------------
  109. 	for {
  110. 		fmt.Printf("Client: accept stream\n")
  111. 		stream1, err := conn.AcceptStream(context.Background())
  112. 		if err != nil {
  113. 			return err
  114. 		}
  116. 		fmt.Printf("Client: got stream %v\n", err)
  117. 		buf1 := make([]byte, len(message))
  118. 		_, err = io.ReadFull(stream1, buf1)
  119. 		if err != nil {
  120. 			return err
  121. 		}
  122. 		fmt.Printf("2-Client: Got '%s'\n", buf1)
  124. 		err = stream1.Close()
  125. 		if err != nil {
  126. 			return err
  127. 		}
  128. 		break
  129. 	}
  130. 	//-------------------------------
  132. 	return nil
  133. }
  135. // A wrapper for io.Writer that also logs the message.
  136. type loggingWriter struct{ io.Writer }
  138. func (w loggingWriter) Write(b []byte) (int, error) {
  139. 	fmt.Printf("Server: Got '%s'\n", string(b))
  140. 	return w.Writer.Write(b)
  141. }
  143. // Setup a bare-bones TLS config for the server
  144. func generateTLSConfig() *tls.Config {
  145. 	key, err := rsa.GenerateKey(rand.Reader, 1024)
  146. 	if err != nil {
  147. 		panic(err)
  148. 	}
  149. 	template := x509.Certificate{SerialNumber: big.NewInt(1)}
  150. 	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
  151. 	if err != nil {
  152. 		panic(err)
  153. 	}
  154. 	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
  155. 	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
  157. 	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
  158. 	if err != nil {
  159. 		panic(err)
  160. 	}
  161. 	return &tls.Config{
  162. 		Certificates: []tls.Certificate{tlsCert},
  163. 		NextProtos:   []string{"quic-echo-example"},
  164. 	}
  165. }

huangapple
  • 本文由 发表于 2022年5月26日 20:24:01
  • 转载请务必保留本文链接：https://go.coder-hub.com/72391766.html
  • go
  • http3
  • quic
  • quic-go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定