kubernetes/vendor/golang.org/x/net/http2/http2.go

var VerboseLogs

var logFrameWrites

var logFrameReads

var inTests

func init() {}

const ClientPreface

const initialMaxFrameSize

const NextProtoTLS

const initialHeaderTableSize

const initialWindowSize

const defaultMaxReadFrameSize

var clientPreface

type streamState

const stateIdle

const stateOpen

const stateHalfClosedLocal

const stateHalfClosedRemote

const stateClosed

var stateName

func (st streamState) String() string {}

type Setting

func (s Setting) String() string {}

// Valid reports whether the setting is valid.
func (s Setting) Valid() error {}

type SettingID

const SettingHeaderTableSize

const SettingEnablePush

const SettingMaxConcurrentStreams

const SettingInitialWindowSize

const SettingMaxFrameSize

const SettingMaxHeaderListSize

var settingName

func (s SettingID) String() string {}

// validWireHeaderFieldName reports whether v is a valid header field
// name (key). See httpguts.ValidHeaderName for the base rules.
//
// Further, http2 says:
//
//	"Just as in HTTP/1.x, header field names are strings of ASCII
//	characters that are compared in a case-insensitive
//	fashion. However, header field names MUST be converted to
//	lowercase prior to their encoding in HTTP/2. "
func validWireHeaderFieldName(v string) bool {}

func httpCodeString(code int) string {}

type stringWriter

type closeWaiter

// Init makes a closeWaiter usable.
// It exists because so a closeWaiter value can be placed inside a
// larger struct and have the Mutex and Cond's memory in the same
// allocation.
func (cw *closeWaiter) Init() {}

// Close marks the closeWaiter as closed and unblocks any waiters.
func (cw closeWaiter) Close() {}

// Wait waits for the closeWaiter to become closed.
func (cw closeWaiter) Wait() {}

type bufferedWriter

func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter {}

const bufWriterPoolBufferSize

var bufWriterPool

func (w *bufferedWriter) Available() int {}

func (w *bufferedWriter) Write(p []byte) (n int, err error) {}

func (w *bufferedWriter) Flush() error {}

type bufferedWriterTimeoutWriter

func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) {}

// writeWithByteTimeout writes to conn.
// If more than timeout passes without any bytes being written to the connection,
// the write fails.
func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) {}

func mustUint31(v int32) uint32 {}

// bodyAllowedForStatus reports whether a given response status code
// permits a body. See RFC 7230, section 3.3.
func bodyAllowedForStatus(status int) bool {}

type httpError

func (e *httpError) Error() string   {}

func (e *httpError) Timeout() bool   {}

func (e *httpError) Temporary() bool {}

var errTimeout

type connectionStater

var sorterPool

type sorter

func (s *sorter) Len() int           {}

func (s *sorter) Swap(i, j int)      {}

func (s *sorter) Less(i, j int) bool {}

// Keys returns the sorted keys of h.
//
// The returned slice is only valid until s used again or returned to
// its pool.
func (s *sorter) Keys(h http.Header) []string {}

func (s *sorter) SortStrings(ss []string) {}

// validPseudoPath reports whether v is a valid :path pseudo-header
// value. It must be either:
//
//   - a non-empty string starting with '/'
//   - the string '*', for OPTIONS requests.
//
// For now this is only used a quick check for deciding when to clean
// up Opaque URLs before sending requests from the Transport.
// See golang.org/issue/16847
//
// We used to enforce that the path also didn't start with "//", but
// Google's GFE accepts such paths and Chrome sends them, so ignore
// that part of the spec. See golang.org/issue/19103.
func validPseudoPath(v string) bool {}

type incomparable

type synctestGroupInterface