cmd/bpa-operator/vendor/golang.org/x/net/http2/write.go

   1 // Copyright 2014 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package http2
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "log"
  11         "net/http"
  12         "net/url"
  13
  14         "golang.org/x/net/http/httpguts"
  15         "golang.org/x/net/http2/hpack"
  16 )
  17
  18 // writeFramer is implemented by any type that is used to write frames.
  19 type writeFramer interface {
  20         writeFrame(writeContext) error
  21
  22         // staysWithinBuffer reports whether this writer promises that
  23         // it will only write less than or equal to size bytes, and it
  24         // won't Flush the write context.
  25         staysWithinBuffer(size int) bool
  26 }
  27
  28 // writeContext is the interface needed by the various frame writer
  29 // types below. All the writeFrame methods below are scheduled via the
  30 // frame writing scheduler (see writeScheduler in writesched.go).
  31 //
  32 // This interface is implemented by *serverConn.
  33 //
  34 // TODO: decide whether to a) use this in the client code (which didn't
  35 // end up using this yet, because it has a simpler design, not
  36 // currently implementing priorities), or b) delete this and
  37 // make the server code a bit more concrete.
  38 type writeContext interface {
  39         Framer() *Framer
  40         Flush() error
  41         CloseConn() error
  42         // HeaderEncoder returns an HPACK encoder that writes to the
  43         // returned buffer.
  44         HeaderEncoder() (*hpack.Encoder, *bytes.Buffer)
  45 }
  46
  47 // writeEndsStream reports whether w writes a frame that will transition
  48 // the stream to a half-closed local state. This returns false for RST_STREAM,
  49 // which closes the entire stream (not just the local half).
  50 func writeEndsStream(w writeFramer) bool {
  51         switch v := w.(type) {
  52         case *writeData:
  53                 return v.endStream
  54         case *writeResHeaders:
  55                 return v.endStream
  56         case nil:
  57                 // This can only happen if the caller reuses w after it's
  58                 // been intentionally nil'ed out to prevent use. Keep this
  59                 // here to catch future refactoring breaking it.
  60                 panic("writeEndsStream called on nil writeFramer")
  61         }
  62         return false
  63 }
  64
  65 type flushFrameWriter struct{}
  66
  67 func (flushFrameWriter) writeFrame(ctx writeContext) error {
  68         return ctx.Flush()
  69 }
  70
  71 func (flushFrameWriter) staysWithinBuffer(max int) bool { return false }
  72
  73 type writeSettings []Setting
  74
  75 func (s writeSettings) staysWithinBuffer(max int) bool {
  76         const settingSize = 6 // uint16 + uint32
  77         return frameHeaderLen+settingSize*len(s) <= max
  78
  79 }
  80
  81 func (s writeSettings) writeFrame(ctx writeContext) error {
  82         return ctx.Framer().WriteSettings([]Setting(s)...)
  83 }
  84
  85 type writeGoAway struct {
  86         maxStreamID uint32
  87         code        ErrCode
  88 }
  89
  90 func (p *writeGoAway) writeFrame(ctx writeContext) error {
  91         err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil)
  92         ctx.Flush() // ignore error: we're hanging up on them anyway
  93         return err
  94 }
  95
  96 func (*writeGoAway) staysWithinBuffer(max int) bool { return false } // flushes
  97
  98 type writeData struct {
  99         streamID  uint32
 100         p         []byte
 101         endStream bool
 102 }
 103
 104 func (w *writeData) String() string {
 105         return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
 106 }
 107
 108 func (w *writeData) writeFrame(ctx writeContext) error {
 109         return ctx.Framer().WriteData(w.streamID, w.endStream, w.p)
 110 }
 111
 112 func (w *writeData) staysWithinBuffer(max int) bool {
 113         return frameHeaderLen+len(w.p) <= max
 114 }
 115
 116 // handlerPanicRST is the message sent from handler goroutines when
 117 // the handler panics.
 118 type handlerPanicRST struct {
 119         StreamID uint32
 120 }
 121
 122 func (hp handlerPanicRST) writeFrame(ctx writeContext) error {
 123         return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal)
 124 }
 125
 126 func (hp handlerPanicRST) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
 127
 128 func (se StreamError) writeFrame(ctx writeContext) error {
 129         return ctx.Framer().WriteRSTStream(se.StreamID, se.Code)
 130 }
 131
 132 func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
 133
 134 type writePingAck struct{ pf *PingFrame }
 135
 136 func (w writePingAck) writeFrame(ctx writeContext) error {
 137         return ctx.Framer().WritePing(true, w.pf.Data)
 138 }
 139
 140 func (w writePingAck) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.pf.Data) <= max }
 141
 142 type writeSettingsAck struct{}
 143
 144 func (writeSettingsAck) writeFrame(ctx writeContext) error {
 145         return ctx.Framer().WriteSettingsAck()
 146 }
 147
 148 func (writeSettingsAck) staysWithinBuffer(max int) bool { return frameHeaderLen <= max }
 149
 150 // splitHeaderBlock splits headerBlock into fragments so that each fragment fits
 151 // in a single frame, then calls fn for each fragment. firstFrag/lastFrag are true
 152 // for the first/last fragment, respectively.
 153 func splitHeaderBlock(ctx writeContext, headerBlock []byte, fn func(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error) error {
 154         // For now we're lazy and just pick the minimum MAX_FRAME_SIZE
 155         // that all peers must support (16KB). Later we could care
 156         // more and send larger frames if the peer advertised it, but
 157         // there's little point. Most headers are small anyway (so we
 158         // generally won't have CONTINUATION frames), and extra frames
 159         // only waste 9 bytes anyway.
 160         const maxFrameSize = 16384
 161
 162         first := true
 163         for len(headerBlock) > 0 {
 164                 frag := headerBlock
 165                 if len(frag) > maxFrameSize {
 166                         frag = frag[:maxFrameSize]
 167                 }
 168                 headerBlock = headerBlock[len(frag):]
 169                 if err := fn(ctx, frag, first, len(headerBlock) == 0); err != nil {
 170                         return err
 171                 }
 172                 first = false
 173         }
 174         return nil
 175 }
 176
 177 // writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames
 178 // for HTTP response headers or trailers from a server handler.
 179 type writeResHeaders struct {
 180         streamID    uint32
 181         httpResCode int         // 0 means no ":status" line
 182         h           http.Header // may be nil
 183         trailers    []string    // if non-nil, which keys of h to write. nil means all.
 184         endStream   bool
 185
 186         date          string
 187         contentType   string
 188         contentLength string
 189 }
 190
 191 func encKV(enc *hpack.Encoder, k, v string) {
 192         if VerboseLogs {
 193                 log.Printf("http2: server encoding header %q = %q", k, v)
 194         }
 195         enc.WriteField(hpack.HeaderField{Name: k, Value: v})
 196 }
 197
 198 func (w *writeResHeaders) staysWithinBuffer(max int) bool {
 199         // TODO: this is a common one. It'd be nice to return true
 200         // here and get into the fast path if we could be clever and
 201         // calculate the size fast enough, or at least a conservative
 202         // upper bound that usually fires. (Maybe if w.h and
 203         // w.trailers are nil, so we don't need to enumerate it.)
 204         // Otherwise I'm afraid that just calculating the length to
 205         // answer this question would be slower than the ~2µs benefit.
 206         return false
 207 }
 208
 209 func (w *writeResHeaders) writeFrame(ctx writeContext) error {
 210         enc, buf := ctx.HeaderEncoder()
 211         buf.Reset()
 212
 213         if w.httpResCode != 0 {
 214                 encKV(enc, ":status", httpCodeString(w.httpResCode))
 215         }
 216
 217         encodeHeaders(enc, w.h, w.trailers)
 218
 219         if w.contentType != "" {
 220                 encKV(enc, "content-type", w.contentType)
 221         }
 222         if w.contentLength != "" {
 223                 encKV(enc, "content-length", w.contentLength)
 224         }
 225         if w.date != "" {
 226                 encKV(enc, "date", w.date)
 227         }
 228
 229         headerBlock := buf.Bytes()
 230         if len(headerBlock) == 0 && w.trailers == nil {
 231                 panic("unexpected empty hpack")
 232         }
 233
 234         return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
 235 }
 236
 237 func (w *writeResHeaders) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
 238         if firstFrag {
 239                 return ctx.Framer().WriteHeaders(HeadersFrameParam{
 240                         StreamID:      w.streamID,
 241                         BlockFragment: frag,
 242                         EndStream:     w.endStream,
 243                         EndHeaders:    lastFrag,
 244                 })
 245         } else {
 246                 return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
 247         }
 248 }
 249
 250 // writePushPromise is a request to write a PUSH_PROMISE and 0+ CONTINUATION frames.
 251 type writePushPromise struct {
 252         streamID uint32   // pusher stream
 253         method   string   // for :method
 254         url      *url.URL // for :scheme, :authority, :path
 255         h        http.Header
 256
 257         // Creates an ID for a pushed stream. This runs on serveG just before
 258         // the frame is written. The returned ID is copied to promisedID.
 259         allocatePromisedID func() (uint32, error)
 260         promisedID         uint32
 261 }
 262
 263 func (w *writePushPromise) staysWithinBuffer(max int) bool {
 264         // TODO: see writeResHeaders.staysWithinBuffer
 265         return false
 266 }
 267
 268 func (w *writePushPromise) writeFrame(ctx writeContext) error {
 269         enc, buf := ctx.HeaderEncoder()
 270         buf.Reset()
 271
 272         encKV(enc, ":method", w.method)
 273         encKV(enc, ":scheme", w.url.Scheme)
 274         encKV(enc, ":authority", w.url.Host)
 275         encKV(enc, ":path", w.url.RequestURI())
 276         encodeHeaders(enc, w.h, nil)
 277
 278         headerBlock := buf.Bytes()
 279         if len(headerBlock) == 0 {
 280                 panic("unexpected empty hpack")
 281         }
 282
 283         return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
 284 }
 285
 286 func (w *writePushPromise) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
 287         if firstFrag {
 288                 return ctx.Framer().WritePushPromise(PushPromiseParam{
 289                         StreamID:      w.streamID,
 290                         PromiseID:     w.promisedID,
 291                         BlockFragment: frag,
 292                         EndHeaders:    lastFrag,
 293                 })
 294         } else {
 295                 return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
 296         }
 297 }
 298
 299 type write100ContinueHeadersFrame struct {
 300         streamID uint32
 301 }
 302
 303 func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error {
 304         enc, buf := ctx.HeaderEncoder()
 305         buf.Reset()
 306         encKV(enc, ":status", "100")
 307         return ctx.Framer().WriteHeaders(HeadersFrameParam{
 308                 StreamID:      w.streamID,
 309                 BlockFragment: buf.Bytes(),
 310                 EndStream:     false,
 311                 EndHeaders:    true,
 312         })
 313 }
 314
 315 func (w write100ContinueHeadersFrame) staysWithinBuffer(max int) bool {
 316         // Sloppy but conservative:
 317         return 9+2*(len(":status")+len("100")) <= max
 318 }
 319
 320 type writeWindowUpdate struct {
 321         streamID uint32 // or 0 for conn-level
 322         n        uint32
 323 }
 324
 325 func (wu writeWindowUpdate) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
 326
 327 func (wu writeWindowUpdate) writeFrame(ctx writeContext) error {
 328         return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n)
 329 }
 330
 331 // encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k])
 332 // is encoded only if k is in keys.
 333 func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) {
 334         if keys == nil {
 335                 sorter := sorterPool.Get().(*sorter)
 336                 // Using defer here, since the returned keys from the
 337                 // sorter.Keys method is only valid until the sorter
 338                 // is returned:
 339                 defer sorterPool.Put(sorter)
 340                 keys = sorter.Keys(h)
 341         }
 342         for _, k := range keys {
 343                 vv := h[k]
 344                 k = lowerHeader(k)
 345                 if !validWireHeaderFieldName(k) {
 346                         // Skip it as backup paranoia. Per
 347                         // golang.org/issue/14048, these should
 348                         // already be rejected at a higher level.
 349                         continue
 350                 }
 351                 isTE := k == "transfer-encoding"
 352                 for _, v := range vv {
 353                         if !httpguts.ValidHeaderFieldValue(v) {
 354                                 // TODO: return an error? golang.org/issue/14048
 355                                 // For now just omit it.
 356                                 continue
 357                         }
 358                         // TODO: more of "8.1.2.2 Connection-Specific Header Fields"
 359                         if isTE && v != "trailers" {
 360                                 continue
 361                         }
 362                         encKV(enc, k, v)
 363                 }
 364         }
 365 }