Documentation
¶
Index ¶
- Constants
- Variables
- func ListenAndServe(addr, certFile, keyFile string, handler http.Handler) error
- func ListenAndServeQUIC(addr, certFile, keyFile string, handler http.Handler) error
- type DataStreamer
- type RoundTripOpt
- type RoundTripper
- type Server
- func (s *Server) Close() error
- func (s *Server) CloseGracefully(timeout time.Duration) error
- func (s *Server) ListenAndServe() error
- func (s *Server) ListenAndServeTLS(certFile, keyFile string) error
- func (s *Server) Serve(conn net.PacketConn) error
- func (s *Server) SetQuicHeaders(hdr http.Header) error
Constants ¶
const MethodGet0RTT = "GET_0RTT"
MethodGet0RTT allows a GET request to be sent using 0-RTT. Note that 0-RTT data doesn't provide replay protection.
Variables ¶
var ErrNoCachedConn = errors.New("http3: no cached connection was available")
ErrNoCachedConn is returned when RoundTripper.OnlyCachedConn is set
var ServerContextKey = &contextKey{"http3-server"}
ServerContextKey is a context key. It can be used in HTTP handlers with Context.Value to access the server that started the handler. The associated value will be of type *http3.Server.
Functions ¶
func ListenAndServe ¶
ListenAndServe listens on the given network address for both, TLS and QUIC connetions in parallel. It returns if one of the two returns an error. http.DefaultServeMux is used when handler is nil. The correct Alt-Svc headers for QUIC are set.
Types ¶
type DataStreamer ¶ added in v0.20.0
type DataStreamer interface {
DataStream() quic.Stream
}
DataStreamer lets the caller take over the stream. After a call to DataStream the HTTP server library will not do anything else with the connection.
It becomes the caller's responsibility to manage and close the stream.
After a call to DataStream, the original Request.Body must not be used.
type RoundTripOpt ¶
type RoundTripOpt struct {
// OnlyCachedConn controls whether the RoundTripper may create a new QUIC connection.
// If set true and no cached connection is available, RoundTrip will return ErrNoCachedConn.
OnlyCachedConn bool
// SkipSchemeCheck controls whether we check if the scheme is https.
// This allows the use of different schemes, e.g. masque://target.example.com:443/.
SkipSchemeCheck bool
}
RoundTripOpt are options for the Transport.RoundTripOpt method.
type RoundTripper ¶
type RoundTripper struct {
// DisableCompression, if true, prevents the Transport from
// requesting compression with an "Accept-Encoding: gzip"
// request header when the Request contains no existing
// Accept-Encoding value. If the Transport requests gzip on
// its own and gets a gzipped response, it's transparently
// decoded in the Response.Body. However, if the user
// explicitly requested gzip it is not automatically
// uncompressed.
DisableCompression bool
// TLSClientConfig specifies the TLS configuration to use with
// tls.Client. If nil, the default configuration is used.
TLSClientConfig *tls.Config
// QuicConfig is the quic.Config used for dialing new connections.
// If nil, reasonable default values will be used.
QuicConfig *quic.Config
// Enable support for HTTP/3 datagrams.
// If set to true, QuicConfig.EnableDatagram will be set.
// See https://www.ietf.org/archive/id/draft-schinazi-masque-h3-datagram-02.html.
EnableDatagrams bool
// Dial specifies an optional dial function for creating QUIC
// connections for requests.
// If Dial is nil, quic.DialAddr will be used.
Dial func(network, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error)
// MaxResponseHeaderBytes specifies a limit on how many response bytes are
// allowed in the server's response header.
// Zero means to use a default limit.
MaxResponseHeaderBytes int64
// contains filtered or unexported fields
}
RoundTripper implements the http.RoundTripper interface
func (*RoundTripper) Close ¶
func (r *RoundTripper) Close() error
Close closes the QUIC connections that this RoundTripper has used
func (*RoundTripper) RoundTripOpt ¶
func (r *RoundTripper) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error)
RoundTripOpt is like RoundTrip, but takes options.
type Server ¶
type Server struct {
*http.Server
// By providing a quic.Config, it is possible to set parameters of the QUIC connection.
// If nil, it uses reasonable default values.
QuicConfig *quic.Config
// Enable support for HTTP/3 datagrams.
// If set to true, QuicConfig.EnableDatagram will be set.
// See https://www.ietf.org/archive/id/draft-schinazi-masque-h3-datagram-02.html.
EnableDatagrams bool
// contains filtered or unexported fields
}
Server is a HTTP/3 server.
func (*Server) Close ¶
Close the server immediately, aborting requests and sending CONNECTION_CLOSE frames to connected clients. Close in combination with ListenAndServe() (instead of Serve()) may race if it is called before a UDP socket is established.
func (*Server) CloseGracefully ¶
CloseGracefully shuts down the server gracefully. The server sends a GOAWAY frame first, then waits for either timeout to trigger, or for all running requests to complete. CloseGracefully in combination with ListenAndServe() (instead of Serve()) may race if it is called before a UDP socket is established.
func (*Server) ListenAndServe ¶
ListenAndServe listens on the UDP address s.Addr and calls s.Handler to handle HTTP/3 requests on incoming connections.
func (*Server) ListenAndServeTLS ¶
ListenAndServeTLS listens on the UDP address s.Addr and calls s.Handler to handle HTTP/3 requests on incoming connections.
func (*Server) Serve ¶
func (s *Server) Serve(conn net.PacketConn) error
Serve an existing UDP connection. It is possible to reuse the same connection for outgoing connections. Closing the server does not close the packet conn.
func (*Server) SetQuicHeaders ¶
SetQuicHeaders can be used to set the proper headers that announce that this server supports QUIC. The values that are set depend on the port information from s.Server.Addr, and currently look like this (if Addr has port 443):
Alt-Svc: quic=":443"; ma=2592000; v="33,32,31,30"
Source Files