http

DefaultClient var #

DefaultClient is the default [Client] and is used by [Get], [Head], and [Post].

var DefaultClient = *ast.UnaryExpr

DefaultMaxHeaderBytes const #

DefaultMaxHeaderBytes is the maximum permitted size of the headers in an HTTP request. This can be overridden by setting [Server.MaxHeaderBytes].

const DefaultMaxHeaderBytes = *ast.BinaryExpr

DefaultMaxIdleConnsPerHost const #

DefaultMaxIdleConnsPerHost is the default value of [Transport]'s MaxIdleConnsPerHost.

const DefaultMaxIdleConnsPerHost = 2

DefaultServeMux var #

DefaultServeMux is the default [ServeMux] used by [Serve].

var DefaultServeMux = *ast.UnaryExpr

DefaultTransport var #

DefaultTransport is the default implementation of [Transport] and is used by [DefaultClient]. It establishes network connections as needed and caches them for reuse by subsequent calls. It uses HTTP proxies as directed by the environment variables HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions thereof).

var DefaultTransport RoundTripper = *ast.UnaryExpr

ErrAbortHandler var #

ErrAbortHandler is a sentinel panic value to abort a handler. While any panic from ServeHTTP aborts the response to the client, panicking with ErrAbortHandler also suppresses logging of a stack trace to the server's error log.

var ErrAbortHandler = *ast.CallExpr

ErrBodyNotAllowed var #

ErrBodyNotAllowed is returned by ResponseWriter.Write calls when the HTTP method or response code does not permit a body.

var ErrBodyNotAllowed = *ast.CallExpr

ErrBodyReadAfterClose var #

ErrBodyReadAfterClose is returned when reading a [Request] or [Response] Body after the body has been closed. This typically happens when the body is read after an HTTP [Handler] calls WriteHeader or Write on its [ResponseWriter].

var ErrBodyReadAfterClose = *ast.CallExpr

ErrContentLength var #

ErrContentLength is returned by ResponseWriter.Write calls when a Handler set a Content-Length response header with a declared size and then attempted to write more bytes than declared.

var ErrContentLength = *ast.CallExpr

ErrHandlerTimeout var #

ErrHandlerTimeout is returned on [ResponseWriter] Write calls in handlers which have timed out.

var ErrHandlerTimeout = *ast.CallExpr

ErrHeaderTooLong var #

Deprecated: ErrHeaderTooLong is no longer returned by anything in the net/http package. Callers should not compare errors against this variable.

var ErrHeaderTooLong = *ast.UnaryExpr

ErrHijacked var #

ErrHijacked is returned by ResponseWriter.Write calls when the underlying connection has been hijacked using the Hijacker interface. A zero-byte write on a hijacked connection will return ErrHijacked without any other side effects.

var ErrHijacked = *ast.CallExpr

ErrLineTooLong var #

ErrLineTooLong is returned when reading request or response bodies with malformed chunked encoding.

var ErrLineTooLong = internal.ErrLineTooLong

ErrMissingBoundary var #

ErrMissingBoundary is returned by Request.MultipartReader when the request's Content-Type does not include a "boundary" parameter.

var ErrMissingBoundary = *ast.UnaryExpr

ErrMissingContentLength var #

Deprecated: ErrMissingContentLength is no longer returned by anything in the net/http package. Callers should not compare errors against this variable.

var ErrMissingContentLength = *ast.UnaryExpr

ErrMissingFile var #

ErrMissingFile is returned by FormFile when the provided file field name is either not present in the request or not a file field.

var ErrMissingFile = *ast.CallExpr

ErrNoCookie var #

ErrNoCookie is returned by Request's Cookie method when a cookie is not found.

var ErrNoCookie = *ast.CallExpr

ErrNoLocation var #

ErrNoLocation is returned by the [Response.Location] method when no Location header is present.

var ErrNoLocation = *ast.CallExpr

ErrNotMultipart var #

ErrNotMultipart is returned by Request.MultipartReader when the request's Content-Type is not multipart/form-data.

var ErrNotMultipart = *ast.UnaryExpr

ErrNotSupported var #

ErrNotSupported indicates that a feature is not supported. It is returned by ResponseController methods to indicate that the handler does not support the method, and by the Push method of Pusher implementations to indicate that HTTP/2 Push support is not available.

var ErrNotSupported = *ast.UnaryExpr

ErrSchemeMismatch var #

ErrSchemeMismatch is returned when a server returns an HTTP response to an HTTPS client.

var ErrSchemeMismatch = *ast.CallExpr

ErrServerClosed var #

ErrServerClosed is returned by the [Server.Serve], [ServeTLS], [ListenAndServe], and [ListenAndServeTLS] methods after a call to [Server.Shutdown] or [Server.Close].

var ErrServerClosed = *ast.CallExpr

ErrShortBody var #

Deprecated: ErrShortBody is no longer returned by anything in the net/http package. Callers should not compare errors against this variable.

var ErrShortBody = *ast.UnaryExpr

ErrSkipAltProtocol var #

ErrSkipAltProtocol is a sentinel error value defined by Transport.RegisterProtocol.

var ErrSkipAltProtocol = *ast.CallExpr

ErrUnexpectedTrailer var #

Deprecated: ErrUnexpectedTrailer is no longer returned by anything in the net/http package. Callers should not compare errors against this variable.

var ErrUnexpectedTrailer = *ast.UnaryExpr

ErrUseLastResponse var #

ErrUseLastResponse can be returned by Client.CheckRedirect hooks to control how redirects are processed. If returned, the next request is not sent and the most recent response is returned with its body unclosed.

var ErrUseLastResponse = *ast.CallExpr

ErrWriteAfterFlush var #

Deprecated: ErrWriteAfterFlush is no longer returned by anything in the net/http package. Callers should not compare errors against this variable.

var ErrWriteAfterFlush = *ast.CallExpr

LocalAddrContextKey var #

LocalAddrContextKey is a context key. It can be used in HTTP handlers with Context.Value to access the local address the connection arrived on. The associated value will be of type net.Addr.

var LocalAddrContextKey = *ast.UnaryExpr

MethodConnect const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodConnect = "CONNECT"

MethodDelete const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodDelete = "DELETE"

MethodGet const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodGet = "GET"

MethodHead const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodHead = "HEAD"

MethodOptions const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodOptions = "OPTIONS"

MethodPatch const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodPatch = "PATCH"

MethodPost const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodPost = "POST"

MethodPut const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodPut = "PUT"

MethodTrace const #

Common HTTP methods. Unless otherwise noted, these are defined in RFC 7231 section 4.3.

const MethodTrace = "TRACE"

NoBody var #

NoBody is an [io.ReadCloser] with no bytes. Read always returns EOF and Close always returns nil. It can be used in an outgoing client request to explicitly signal that a request has zero bytes. An alternative, however, is to simply set [Request.Body] to nil.

var NoBody = noBody{...}

SameSiteDefaultMode const #

const SameSiteDefaultMode SameSite = *ast.BinaryExpr

SameSiteLaxMode const #

const SameSiteLaxMode

SameSiteNoneMode const #

const SameSiteNoneMode

SameSiteStrictMode const #

const SameSiteStrictMode

ServerContextKey var #

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 *Server.

var ServerContextKey = *ast.UnaryExpr

StateActive const #

StateActive represents a connection that has read 1 or more bytes of a request. The Server.ConnState hook for StateActive fires before the request has entered a handler and doesn't fire again until the request has been handled. After the request is handled, the state transitions to StateClosed, StateHijacked, or StateIdle. For HTTP/2, StateActive fires on the transition from zero to one active request, and only transitions away once all active requests are complete. That means that ConnState cannot be used to do per-request work; ConnState only notes the overall state of the connection.

const StateActive

StateClosed const #

StateClosed represents a closed connection. This is a terminal state. Hijacked connections do not transition to StateClosed.

const StateClosed

StateHijacked const #

StateHijacked represents a hijacked connection. This is a terminal state. It does not transition to StateClosed.

const StateHijacked

StateIdle const #

StateIdle represents a connection that has finished handling a request and is in the keep-alive state, waiting for a new request. Connections transition from StateIdle to either StateActive or StateClosed.

const StateIdle

StateNew const #

StateNew represents a new connection that is expected to send a request immediately. Connections begin at this state and then transition to either StateActive or StateClosed.

const StateNew ConnState = iota

StatusAccepted const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusAccepted = 202

StatusAlreadyReported const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusAlreadyReported = 208

StatusBadGateway const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusBadGateway = 502

StatusBadRequest const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusBadRequest = 400

StatusConflict const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusConflict = 409

StatusContinue const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusContinue = 100

StatusCreated const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusCreated = 201

StatusEarlyHints const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusEarlyHints = 103

StatusExpectationFailed const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusExpectationFailed = 417

StatusFailedDependency const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusFailedDependency = 424

StatusForbidden const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusForbidden = 403

StatusFound const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusFound = 302

StatusGatewayTimeout const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusGatewayTimeout = 504

StatusGone const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusGone = 410

StatusHTTPVersionNotSupported const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusHTTPVersionNotSupported = 505

StatusIMUsed const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusIMUsed = 226

StatusInsufficientStorage const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusInsufficientStorage = 507

StatusInternalServerError const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusInternalServerError = 500

StatusLengthRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusLengthRequired = 411

StatusLocked const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusLocked = 423

StatusLoopDetected const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusLoopDetected = 508

StatusMethodNotAllowed const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusMethodNotAllowed = 405

StatusMisdirectedRequest const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusMisdirectedRequest = 421

StatusMovedPermanently const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusMovedPermanently = 301

StatusMultiStatus const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusMultiStatus = 207

StatusMultipleChoices const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusMultipleChoices = 300

StatusNetworkAuthenticationRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNetworkAuthenticationRequired = 511

StatusNoContent const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNoContent = 204

StatusNonAuthoritativeInfo const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNonAuthoritativeInfo = 203

StatusNotAcceptable const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNotAcceptable = 406

StatusNotExtended const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNotExtended = 510

StatusNotFound const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNotFound = 404

StatusNotImplemented const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNotImplemented = 501

StatusNotModified const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusNotModified = 304

StatusOK const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusOK = 200

StatusPartialContent const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusPartialContent = 206

StatusPaymentRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusPaymentRequired = 402

StatusPermanentRedirect const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusPermanentRedirect = 308

StatusPreconditionFailed const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusPreconditionFailed = 412

StatusPreconditionRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusPreconditionRequired = 428

StatusProcessing const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusProcessing = 102

StatusProxyAuthRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusProxyAuthRequired = 407

StatusRequestEntityTooLarge const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusRequestEntityTooLarge = 413

StatusRequestHeaderFieldsTooLarge const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusRequestHeaderFieldsTooLarge = 431

StatusRequestTimeout const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusRequestTimeout = 408

StatusRequestURITooLong const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusRequestURITooLong = 414

StatusRequestedRangeNotSatisfiable const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusRequestedRangeNotSatisfiable = 416

StatusResetContent const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusResetContent = 205

StatusSeeOther const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusSeeOther = 303

StatusServiceUnavailable const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusServiceUnavailable = 503

StatusSwitchingProtocols const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusSwitchingProtocols = 101

StatusTeapot const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusTeapot = 418

StatusTemporaryRedirect const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusTemporaryRedirect = 307

StatusTooEarly const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusTooEarly = 425

StatusTooManyRequests const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusTooManyRequests = 429

StatusUnauthorized const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUnauthorized = 401

StatusUnavailableForLegalReasons const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUnavailableForLegalReasons = 451

StatusUnprocessableEntity const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUnprocessableEntity = 422

StatusUnsupportedMediaType const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUnsupportedMediaType = 415

StatusUpgradeRequired const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUpgradeRequired = 426

StatusUseProxy const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusUseProxy = 305

StatusVariantAlsoNegotiates const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const StatusVariantAlsoNegotiates = 506

TimeFormat const #

TimeFormat is the time format to use when generating times in HTTP headers. It is like [time.RFC1123] but hard-codes GMT as the time zone. The time being formatted must be in UTC for Format to generate the correct format. For parsing this time format, see [ParseTime].

const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

TrailerPrefix const #

TrailerPrefix is a magic prefix for [ResponseWriter.Header] map keys that, if present, signals that the map entry is actually for the response trailers, and not the response headers. The prefix is stripped after the ServeHTTP call finishes and the values are sent in the trailers. This mechanism is intended only for trailers that are not known prior to the headers being written. If the set of trailers is fixed or known before the header is written, the normal Go trailers mechanism is preferred: https://pkg.go.dev/net/http#ResponseWriter https://pkg.go.dev/net/http#example-ResponseWriter-Trailers

const TrailerPrefix = "Trailer:"

_ var #

var _ Pusher = *ast.CallExpr

_ var #

var _ Pusher = *ast.CallExpr

_ var #

var _ http2clientConnPoolIdleCloser = http2noDialClientConnPool{...}

_ var #

Optional http.ResponseWriter interfaces implemented.

var _ Flusher = *ast.CallExpr

_ var #

Optional http.ResponseWriter interfaces implemented.

var _ CloseNotifier = *ast.CallExpr

_ var #

var _ io.ReaderFrom = *ast.CallExpr

_ var #

verify that an io.Copy from NoBody won't require a buffer:

var _ io.WriterTo = NoBody

_ var #

Optional http.ResponseWriter interfaces implemented.

var _ http2stringWriter = *ast.CallExpr

_ const #

HTTP status codes as registered with IANA. See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const _ = 306

_ var #

var _ http2clientConnPoolIdleCloser = *ast.CallExpr

_ var #

var _ closeWriter = *ast.CallExpr

_ var #

var _ io.ReadCloser = NoBody

aLongTimeAgo var #

aLongTimeAgo is a non-zero time, far in the past, used for immediate cancellation of network operations.

var aLongTimeAgo = *ast.CallExpr

bufferBeforeChunkingSize const #

This should be >= 512 bytes for DetectContentType, but otherwise it's somewhat arbitrary.

const bufferBeforeChunkingSize = 2048

bufioReaderPool var #

var bufioReaderPool sync.Pool

bufioWriter2kPool var #

var bufioWriter2kPool sync.Pool

bufioWriter4kPool var #

var bufioWriter4kPool sync.Pool

colonSpace var #

var colonSpace = *ast.CallExpr

condFalse const #

const condFalse

condNone const #

const condNone condResult = iota

condTrue const #

const condTrue

cookieNameSanitizer var #

var cookieNameSanitizer = *ast.CallExpr

copyBufPool var #

var copyBufPool = sync.Pool{...}

copyBufPoolSize const #

const copyBufPoolSize = *ast.BinaryExpr

crlf var #

var crlf = *ast.CallExpr

debugServerConnections const #

debugServerConnections controls whether all server connections are wrapped with a verbose logging wrapper.

const debugServerConnections = false

defaultMaxMemory const #

const defaultMaxMemory = *ast.BinaryExpr

defaultServeMux var #

var defaultServeMux ServeMux

defaultUserAgent const #

NOTE: This is not intended to reflect the actual Go version being used. It was changed at the time of Go 1.1 release because the former User-Agent had ended up blocked by some intrusion detection systems. See https://codereview.appspot.com/7532043.

const defaultUserAgent = "Go-http-client/1.1"

disjoint const #

const disjoint relationship = "disjoint"

doubleCRLF var #

var doubleCRLF = *ast.CallExpr

envProxyFuncValue var #

var envProxyFuncValue func(*url.URL) (*url.URL, error)

envProxyOnce var #

var envProxyOnce sync.Once

equivalent const #

const equivalent relationship = "equivalent"

errBlankCookie var #

var errBlankCookie = *ast.CallExpr

errCallerOwnsConn var #

errCallerOwnsConn is an internal sentinel error used when we hand off a writable response.Body to the caller. We use this to prevent closing a net.Conn that is now owned by the caller.

var errCallerOwnsConn = *ast.CallExpr

errCannotRewind var #

var errCannotRewind = *ast.CallExpr

errCloseIdle var #

error values for debugging and testing, not seen by users.

var errCloseIdle = *ast.CallExpr

errCloseIdleConns var #

error values for debugging and testing, not seen by users.

var errCloseIdleConns = *ast.CallExpr

errClosed var #

var errClosed = *ast.CallExpr

errConnBroken var #

error values for debugging and testing, not seen by users.

var errConnBroken = *ast.CallExpr

errEqualNotFoundInCookie var #

var errEqualNotFoundInCookie = *ast.CallExpr

errIdleConnTimeout var #

error values for debugging and testing, not seen by users.

var errIdleConnTimeout = *ast.CallExpr

errInvalidCookieName var #

var errInvalidCookieName = *ast.CallExpr

errInvalidCookieValue var #

var errInvalidCookieValue = *ast.CallExpr

errKeepAlivesDisabled var #

error values for debugging and testing, not seen by users.

var errKeepAlivesDisabled = *ast.CallExpr

errMissingHost var #

errMissingHost is returned by Write when there is no Host or URL present in the Request.

var errMissingHost = *ast.CallExpr

errMissingReadDir var #

var errMissingReadDir = *ast.CallExpr

errMissingSeek var #

var errMissingSeek = *ast.CallExpr

errNoOverlap var #

errNoOverlap is returned by serveContent's parseRange if first-byte-pos of all of the byte-range-spec values is greater than the content size.

var errNoOverlap = *ast.CallExpr

errReadLoopExiting var #

error values for debugging and testing, not seen by users.

var errReadLoopExiting = *ast.CallExpr

errReadOnClosedResBody var #

var errReadOnClosedResBody = *ast.CallExpr

errRequestCanceled var #

errRequestCanceled is set to be identical to the one from h2 to facilitate testing.

var errRequestCanceled = http2errRequestCanceled

errRequestCanceledConn var #

var errRequestCanceledConn = *ast.CallExpr

errRequestDone var #

errRequestDone is used to cancel the round trip Context after a request is successfully done. It should not be seen by the user.

var errRequestDone = *ast.CallExpr

errSeeker var #

errSeeker is returned by ServeContent's sizeFunc when the content doesn't seek properly. The underlying Seeker's error text isn't included in the sizeFunc reply so it's not sent over HTTP to end users.

var errSeeker = *ast.CallExpr

errServerClosedIdle var #

errServerClosedIdle is not seen by users for idempotent requests, but may be seen by a user if the server shuts down an idle connection and sends its FIN in flight with already-written POST body bytes from the client. See https://github.com/golang/go/issues/19943#issuecomment-355607646

var errServerClosedIdle = *ast.CallExpr

errTimeout var #

var errTimeout error = *ast.UnaryExpr

errTooLarge var #

var errTooLarge = *ast.CallExpr

errTooManyIdle var #

error values for debugging and testing, not seen by users.

var errTooManyIdle = *ast.CallExpr

errTooManyIdleHost var #

error values for debugging and testing, not seen by users.

var errTooManyIdleHost = *ast.CallExpr

errTrailerEOF var #

var errTrailerEOF = *ast.CallExpr

excludedHeadersNoBody var #

var excludedHeadersNoBody = map[string]bool{...}

extraHeaderKeys var #

Sorted the same as extraHeader.Write's loop.

var extraHeaderKeys = [][]byte{...}

headerContentLength var #

var headerContentLength = *ast.CallExpr

headerDate var #

var headerDate = *ast.CallExpr

headerNewlineToSpace var #

var headerNewlineToSpace = *ast.CallExpr

headerSorterPool var #

var headerSorterPool = sync.Pool{...}

htmlReplacer var #

var htmlReplacer = *ast.CallExpr

http2ClientPreface const #

ClientPreface is the string that must be sent by new connections from clients.

const http2ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"

http2DebugGoroutines var #

var http2DebugGoroutines = *ast.BinaryExpr

http2ErrCodeCancel const #

const http2ErrCodeCancel http2ErrCode = 0x8

http2ErrCodeCompression const #

const http2ErrCodeCompression http2ErrCode = 0x9

http2ErrCodeConnect const #

const http2ErrCodeConnect http2ErrCode = 0xa

http2ErrCodeEnhanceYourCalm const #

const http2ErrCodeEnhanceYourCalm http2ErrCode = 0xb

http2ErrCodeFlowControl const #

const http2ErrCodeFlowControl http2ErrCode = 0x3

http2ErrCodeFrameSize const #

const http2ErrCodeFrameSize http2ErrCode = 0x6

http2ErrCodeHTTP11Required const #

const http2ErrCodeHTTP11Required http2ErrCode = 0xd

http2ErrCodeInadequateSecurity const #

const http2ErrCodeInadequateSecurity http2ErrCode = 0xc

http2ErrCodeInternal const #

const http2ErrCodeInternal http2ErrCode = 0x2

http2ErrCodeNo const #

const http2ErrCodeNo http2ErrCode = 0x0

http2ErrCodeProtocol const #

const http2ErrCodeProtocol http2ErrCode = 0x1

http2ErrCodeRefusedStream const #

const http2ErrCodeRefusedStream http2ErrCode = 0x7

http2ErrCodeSettingsTimeout const #

const http2ErrCodeSettingsTimeout http2ErrCode = 0x4

http2ErrCodeStreamClosed const #

const http2ErrCodeStreamClosed http2ErrCode = 0x5

http2ErrFrameTooLarge var #

ErrFrameTooLarge is returned from Framer.ReadFrame when the peer sends a frame that is larger than declared with SetMaxReadFrameSize.

var http2ErrFrameTooLarge = *ast.CallExpr

http2ErrNoCachedConn var #

var http2ErrNoCachedConn error = http2noCachedConnError{...}

http2ErrNoCachedConn var #

var http2ErrNoCachedConn = http2noCachedConnError{...}

http2ErrPushLimitReached var #

Push errors.

var http2ErrPushLimitReached = *ast.CallExpr

http2ErrRecursivePush var #

Push errors.

var http2ErrRecursivePush = *ast.CallExpr

http2FlagContinuationEndHeaders const #

Continuation Frame

const http2FlagContinuationEndHeaders http2Flags = 0x4

http2FlagDataEndStream const #

Data Frame

const http2FlagDataEndStream http2Flags = 0x1

http2FlagDataPadded const #

Frame-specific FrameHeader flag bits.

const http2FlagDataPadded http2Flags = 0x8

http2FlagHeadersEndHeaders const #

Frame-specific FrameHeader flag bits.

const http2FlagHeadersEndHeaders http2Flags = 0x4

http2FlagHeadersEndStream const #

Headers Frame

const http2FlagHeadersEndStream http2Flags = 0x1

http2FlagHeadersPadded const #

Frame-specific FrameHeader flag bits.

const http2FlagHeadersPadded http2Flags = 0x8

http2FlagHeadersPriority const #

Frame-specific FrameHeader flag bits.

const http2FlagHeadersPriority http2Flags = 0x20

http2FlagPingAck const #

Ping Frame

const http2FlagPingAck http2Flags = 0x1

http2FlagPushPromiseEndHeaders const #

Frame-specific FrameHeader flag bits.

const http2FlagPushPromiseEndHeaders http2Flags = 0x4

http2FlagPushPromisePadded const #

Frame-specific FrameHeader flag bits.

const http2FlagPushPromisePadded http2Flags = 0x8

http2FlagSettingsAck const #

Settings Frame

const http2FlagSettingsAck http2Flags = 0x1

http2FrameContinuation const #

const http2FrameContinuation http2FrameType = 0x9

http2FrameData const #

const http2FrameData http2FrameType = 0x0

http2FrameGoAway const #

const http2FrameGoAway http2FrameType = 0x7

http2FrameHeaders const #

const http2FrameHeaders http2FrameType = 0x1

http2FramePing const #

const http2FramePing http2FrameType = 0x6

http2FramePriority const #

const http2FramePriority http2FrameType = 0x2

http2FramePushPromise const #

const http2FramePushPromise http2FrameType = 0x5

http2FrameRSTStream const #

const http2FrameRSTStream http2FrameType = 0x3

http2FrameSettings const #

const http2FrameSettings http2FrameType = 0x4

http2FrameWindowUpdate const #

const http2FrameWindowUpdate http2FrameType = 0x8

http2NextProtoTLS const #

const http2NextProtoTLS = "h2"

http2NextProtoTLS const #

NextProtoTLS is the NPN/ALPN protocol negotiated during HTTP/2's TLS setup.

const http2NextProtoTLS = "h2"

http2SettingEnableConnectProtocol const #

const http2SettingEnableConnectProtocol http2SettingID = 0x8

http2SettingEnablePush const #

const http2SettingEnablePush http2SettingID = 0x2

http2SettingHeaderTableSize const #

const http2SettingHeaderTableSize http2SettingID = 0x1

http2SettingInitialWindowSize const #

const http2SettingInitialWindowSize http2SettingID = 0x4

http2SettingMaxConcurrentStreams const #

const http2SettingMaxConcurrentStreams http2SettingID = 0x3

http2SettingMaxFrameSize const #

const http2SettingMaxFrameSize http2SettingID = 0x5

http2SettingMaxHeaderListSize const #

const http2SettingMaxHeaderListSize http2SettingID = 0x6

http2TrailerPrefix const #

TrailerPrefix is a magic prefix for ResponseWriter.Header map keys that, if present, signals that the map entry is actually for the response trailers, and not the response headers. The prefix is stripped after the ServeHTTP call finishes and the values are sent in the trailers. This mechanism is intended only for trailers that are not known prior to the headers being written. If the set of trailers is fixed or known before the header is written, the normal Go trailers mechanism is preferred: https://golang.org/pkg/net/http/#ResponseWriter https://golang.org/pkg/net/http/#example_ResponseWriter_trailers

const http2TrailerPrefix = "Trailer:"

http2VerboseLogs var #

var http2VerboseLogs bool

http2bufPools var #

Seven bufPools manage different frame sizes. This helps to avoid scenarios where long-running streaming requests using small frame sizes occupy large buffers initially allocated for prior requests needing big buffers. The size ranges are as follows: {0 KB, 16 KB], {16 KB, 32 KB], {32 KB, 64 KB], {64 KB, 128 KB], {128 KB, 256 KB], {256 KB, 512 KB], {512 KB, infinity} In practice, the maximum scratch buffer size should not exceed 512 KB due to frameScratchBufferLen(maxFrameSize), thus the "infinity pool" should never be used. It exists mainly as a safety measure, for potential future increases in max buffer size.

var http2bufPools [7]sync.Pool

http2bufWriterPool var #

var http2bufWriterPool = sync.Pool{...}

http2bufWriterPoolBufferSize const #

bufWriterPoolBufferSize is the size of bufio.Writer's buffers created using bufWriterPool. TODO: pick a less arbitrary value? this is a bit under (3 x typical 1500 byte MTU) at least. Other than that, not much thought went into it.

const http2bufWriterPoolBufferSize = *ast.BinaryExpr

http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0011

http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x0013

http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0032

http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x0040

http2cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A2

http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0038

http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x006A

http2cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A3

http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC042

http2cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC056

http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC043

http2cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC057

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0044

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BD

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC080

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0087

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C3

http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC081

http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA uint16 = 0x0012

http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA uint16 = 0x0099

http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008F

http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0090

http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B2

http2cipher_TLS_DHE_PSK_WITH_AES_128_CCM const #

const http2cipher_TLS_DHE_PSK_WITH_AES_128_CCM uint16 = 0xC0A6

http2cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AA

http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0091

http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B3

http2cipher_TLS_DHE_PSK_WITH_AES_256_CCM const #

const http2cipher_TLS_DHE_PSK_WITH_AES_256_CCM uint16 = 0xC0A7

http2cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AB

http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC066

http2cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06C

http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC067

http2cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06D

http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC096

http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC090

http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC097

http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC091

http2cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAD

http2cipher_TLS_DHE_PSK_WITH_NULL_SHA const #

const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA uint16 = 0x002D

http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256 const #

const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256 uint16 = 0x00B4

http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384 const #

const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384 uint16 = 0x00B5

http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA const #

const http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA uint16 = 0x008E

http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0014

http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0016

http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0033

http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 const #

Reserved uint16 = 0x0047-4F Reserved uint16 = 0x0050-58 Reserved uint16 = 0x0059-5C Unassigned uint16 = 0x005D-5F Reserved uint16 = 0x0060-66

const http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x0067

http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM const #

const http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM uint16 = 0xC09E

http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8 const #

const http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A2

http2cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009E

http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0039

http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x006B

http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM const #

const http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM uint16 = 0xC09F

http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8 const #

const http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A3

http2cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009F

http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC044

http2cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC052

http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC045

http2cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC053

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0045

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BE

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07C

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0088

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C4

http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07D

http2cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAA

http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA uint16 = 0x0015

http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA uint16 = 0x009A

http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000B

http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x000D

http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0030

http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x003E

http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A4

http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0036

http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x0068

http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A5

http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03E

http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC058

http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03F

http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC059

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0042

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BB

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC082

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0085

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C1

http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC083

http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA uint16 = 0x000C

http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA uint16 = 0x0097

http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000E

http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0010

http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0031

http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003F

http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x00A0

http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0037

http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x0069

http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x00A1

http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC040

http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC054

http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC041

http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC055

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0043

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BC

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07E

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0086

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C2

http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07F

http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA uint16 = 0x000F

http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA uint16 = 0x0098

http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0019

http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 const #

const http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0017

http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0x001B

http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA uint16 = 0x0034

http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 uint16 = 0x006C

http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256 uint16 = 0x00A6

http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA uint16 = 0x003A

http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 uint16 = 0x006D

http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384 uint16 = 0x00A7

http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC046

http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05A

http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC047

http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05B

http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0046

http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BF

http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC084

http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0089

http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C5

http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC085

http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA uint16 = 0x001A

http2cipher_TLS_DH_anon_WITH_RC4_128_MD5 const #

const http2cipher_TLS_DH_anon_WITH_RC4_128_MD5 uint16 = 0x0018

http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA uint16 = 0x009B

http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC008

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC009

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC023

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM uint16 = 0xC0AC

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 uint16 = 0xC0AE

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02B

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC00A

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC024

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM uint16 = 0xC0AD

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 uint16 = 0xC0AF

http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02C

http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC048

http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05C

http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC049

http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05D

http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC072

http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC086

http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC073

http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC087

http2cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA9

http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA uint16 = 0xC006

http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA uint16 = 0xC007

http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0xC034

http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0xC035

http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0xC037

http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0xC036

http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0xC038

http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC070

http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC071

http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC09A

http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC09B

http2cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAC

http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA const #

const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA uint16 = 0xC039

http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256 const #

const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256 uint16 = 0xC03A

http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384 const #

const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384 uint16 = 0xC03B

http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA uint16 = 0xC033

http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC012

http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC013

http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC027

http2cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02F

http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC014

http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC028

http2cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC030

http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04C

http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC060

http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04D

http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC061

http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC076

http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08A

http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC077

http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08B

http2cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 const #

Unassigned uint16 = 0xC0B0-FF Unassigned uint16 = 0xC1-CB,* Unassigned uint16 = 0xCC00-A7

const http2cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA8

http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA const #

const http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA uint16 = 0xC010

http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA uint16 = 0xC011

http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC003

http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC004

http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC025

http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02D

http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC005

http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC026

http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02E

http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04A

http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05E

http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04B

http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05F

http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC074

http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC088

http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC075

http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC089

http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA const #

Unassigned uint16 = 0x5601 - 0xC000

const http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA uint16 = 0xC001

http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA uint16 = 0xC002

http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC00D

http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC00E

http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC029

http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC031

http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC00F

http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC02A

http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC032

http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04E

http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC062

http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04F

http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC063

http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC078

http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08C

http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC079

http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08D

http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA const #

const http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA uint16 = 0xC00B

http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA uint16 = 0xC00C

http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0xC017

http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA uint16 = 0xC018

http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA uint16 = 0xC019

http2cipher_TLS_ECDH_anon_WITH_NULL_SHA const #

const http2cipher_TLS_ECDH_anon_WITH_NULL_SHA uint16 = 0xC015

http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA const #

const http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA uint16 = 0xC016

http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV const #

Unassigned uint16 = 0x00C6-FE

const http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV uint16 = 0x00FF

http2cipher_TLS_FALLBACK_SCSV const #

Unassigned uint16 = 0x01-55,*

const http2cipher_TLS_FALLBACK_SCSV uint16 = 0x5600

http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 const #

const http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 uint16 = 0x0029

http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA const #

const http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA uint16 = 0x0026

http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 const #

const http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x002A

http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA const #

const http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA uint16 = 0x0027

http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 const #

const http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 uint16 = 0x002B

http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA const #

const http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA uint16 = 0x0028

http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 const #

const http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 uint16 = 0x0023

http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA uint16 = 0x001F

http2cipher_TLS_KRB5_WITH_DES_CBC_MD5 const #

const http2cipher_TLS_KRB5_WITH_DES_CBC_MD5 uint16 = 0x0022

http2cipher_TLS_KRB5_WITH_DES_CBC_SHA const #

Reserved uint16 = 0x001C-1D

const http2cipher_TLS_KRB5_WITH_DES_CBC_SHA uint16 = 0x001E

http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5 const #

const http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5 uint16 = 0x0025

http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA const #

const http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA uint16 = 0x0021

http2cipher_TLS_KRB5_WITH_RC4_128_MD5 const #

const http2cipher_TLS_KRB5_WITH_RC4_128_MD5 uint16 = 0x0024

http2cipher_TLS_KRB5_WITH_RC4_128_SHA const #

const http2cipher_TLS_KRB5_WITH_RC4_128_SHA uint16 = 0x0020

http2cipher_TLS_NULL_WITH_NULL_NULL const #

const http2cipher_TLS_NULL_WITH_NULL_NULL uint16 = 0x0000

http2cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8 const #

const http2cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8 uint16 = 0xC0AA

http2cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8 const #

const http2cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8 uint16 = 0xC0AB

http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008B

http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA uint16 = 0x008C

http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00AE

http2cipher_TLS_PSK_WITH_AES_128_CCM const #

const http2cipher_TLS_PSK_WITH_AES_128_CCM uint16 = 0xC0A4

http2cipher_TLS_PSK_WITH_AES_128_CCM_8 const #

const http2cipher_TLS_PSK_WITH_AES_128_CCM_8 uint16 = 0xC0A8

http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00A8

http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA uint16 = 0x008D

http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00AF

http2cipher_TLS_PSK_WITH_AES_256_CCM const #

const http2cipher_TLS_PSK_WITH_AES_256_CCM uint16 = 0xC0A5

http2cipher_TLS_PSK_WITH_AES_256_CCM_8 const #

const http2cipher_TLS_PSK_WITH_AES_256_CCM_8 uint16 = 0xC0A9

http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00A9

http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC064

http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06A

http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC065

http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06B

http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC094

http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08E

http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC095

http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08F

http2cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAB

http2cipher_TLS_PSK_WITH_NULL_SHA const #

const http2cipher_TLS_PSK_WITH_NULL_SHA uint16 = 0x002C

http2cipher_TLS_PSK_WITH_NULL_SHA256 const #

const http2cipher_TLS_PSK_WITH_NULL_SHA256 uint16 = 0x00B0

http2cipher_TLS_PSK_WITH_NULL_SHA384 const #

const http2cipher_TLS_PSK_WITH_NULL_SHA384 uint16 = 0x00B1

http2cipher_TLS_PSK_WITH_RC4_128_SHA const #

const http2cipher_TLS_PSK_WITH_RC4_128_SHA uint16 = 0x008A

http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA const #

const http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0008

http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 const #

const http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x0006

http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5 const #

const http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0003

http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x0093

http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0094

http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B6

http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AC

http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0095

http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B7

http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AD

http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC068

http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06E

http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC069

http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06F

http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC098

http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC092

http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC099

http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC093

http2cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAE

http2cipher_TLS_RSA_PSK_WITH_NULL_SHA const #

const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA uint16 = 0x002E

http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256 const #

const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256 uint16 = 0x00B8

http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384 const #

const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384 uint16 = 0x00B9

http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA const #

const http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA uint16 = 0x0092

http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x000A

http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA uint16 = 0x002F

http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003C

http2cipher_TLS_RSA_WITH_AES_128_CCM const #

const http2cipher_TLS_RSA_WITH_AES_128_CCM uint16 = 0xC09C

http2cipher_TLS_RSA_WITH_AES_128_CCM_8 const #

const http2cipher_TLS_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A0

http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009C

http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0035

http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256 const #

const http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x003D

http2cipher_TLS_RSA_WITH_AES_256_CCM const #

const http2cipher_TLS_RSA_WITH_AES_256_CCM uint16 = 0xC09D

http2cipher_TLS_RSA_WITH_AES_256_CCM_8 const #

const http2cipher_TLS_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A1

http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009D

http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03C

http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC050

http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384 const #

const http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03D

http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC051

http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0041

http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 const #

const http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BA

http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 const #

const http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07A

http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA const #

Unassigned uint16 = 0x006E-83

const http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0084

http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 const #

const http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C0

http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 const #

const http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07B

http2cipher_TLS_RSA_WITH_DES_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_DES_CBC_SHA uint16 = 0x0009

http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA uint16 = 0x0007

http2cipher_TLS_RSA_WITH_NULL_MD5 const #

const http2cipher_TLS_RSA_WITH_NULL_MD5 uint16 = 0x0001

http2cipher_TLS_RSA_WITH_NULL_SHA const #

const http2cipher_TLS_RSA_WITH_NULL_SHA uint16 = 0x0002

http2cipher_TLS_RSA_WITH_NULL_SHA256 const #

const http2cipher_TLS_RSA_WITH_NULL_SHA256 uint16 = 0x003B

http2cipher_TLS_RSA_WITH_RC4_128_MD5 const #

const http2cipher_TLS_RSA_WITH_RC4_128_MD5 uint16 = 0x0004

http2cipher_TLS_RSA_WITH_RC4_128_SHA const #

const http2cipher_TLS_RSA_WITH_RC4_128_SHA uint16 = 0x0005

http2cipher_TLS_RSA_WITH_SEED_CBC_SHA const #

const http2cipher_TLS_RSA_WITH_SEED_CBC_SHA uint16 = 0x0096

http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01C

http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA uint16 = 0xC01F

http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA uint16 = 0xC022

http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01B

http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC01E

http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC021

http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01A

http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA uint16 = 0xC01D

http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA const #

const http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA uint16 = 0xC020

http2client var #

var http2client = *ast.CallExpr

http2clientPreface var #

var http2clientPreface = *ast.CallExpr

http2commonBuildOnce var #

var http2commonBuildOnce sync.Once

http2commonCanonHeader var #

var http2commonCanonHeader map[string]string

http2commonLowerHeader var #

var http2commonLowerHeader map[string]string

http2connHeaders var #

From http://httpwg.org/specs/rfc7540.html#rfc.section.8.1.2.2

var http2connHeaders = []string{...}

http2dataChunkPools var #

Buffer chunks are allocated from a pool to reduce pressure on GC. The maximum wasted space per dataBuffer is 2x the largest size class, which happens when the dataBuffer has multiple chunks and there is one unread byte in both the first and last chunks. We use a few size classes to minimize overheads for servers that typically receive very small request bodies. TODO: Benchmark to determine if the pools are necessary. The GC may have improved enough that we can instead allocate chunks like this: make([]byte, max(16<<10, expectedBytesRemaining))

var http2dataChunkPools = [...]sync.Pool{...}

http2defaultMaxConcurrentStreams const #

defaultMaxConcurrentStreams is a connections default maxConcurrentStreams if the server doesn't include one in its initial SETTINGS frame.

const http2defaultMaxConcurrentStreams = 1000

http2defaultMaxReadFrameSize const #

const http2defaultMaxReadFrameSize = *ast.BinaryExpr

http2defaultMaxStreams const #

const http2defaultMaxStreams = 250

http2defaultUserAgent const #

const http2defaultUserAgent = "Go-http-client/2.0"

http2dialOnMiss const #

const http2dialOnMiss = true

http2disableExtendedConnectProtocol var #

Enabling extended CONNECT by causes browsers to attempt to use WebSockets-over-HTTP/2. This results in problems when the server's websocket package doesn't support extended CONNECT. Disable extended CONNECT by default for now. Issue #71128.

var http2disableExtendedConnectProtocol = true

http2errChanPool var #

var http2errChanPool = sync.Pool{...}

http2errClientConnClosed var #

var http2errClientConnClosed = *ast.CallExpr

http2errClientConnGotGoAway var #

var http2errClientConnGotGoAway = *ast.CallExpr

http2errClientConnNotEstablished var #

var http2errClientConnNotEstablished = *ast.CallExpr

http2errClientConnUnusable var #

var http2errClientConnUnusable = *ast.CallExpr

http2errClientDisconnected var #

var http2errClientDisconnected = *ast.CallExpr

http2errClosedBody var #

var http2errClosedBody = *ast.CallExpr

http2errClosedPipeWrite var #

var http2errClosedPipeWrite = *ast.CallExpr

http2errClosedResponseBody var #

var http2errClosedResponseBody = *ast.CallExpr

http2errCodeName var #

var http2errCodeName = map[http2ErrCode]string{...}

http2errDepStreamID var #

var http2errDepStreamID = *ast.CallExpr

http2errExtendedConnectNotSupported var #

var http2errExtendedConnectNotSupported = *ast.CallExpr

http2errFromPeer var #

errFromPeer is a sentinel error value for StreamError.Cause to indicate that the StreamError was sent from the peer over the wire and wasn't locally generated in the Transport.

var http2errFromPeer = *ast.CallExpr

http2errHandlerComplete var #

var http2errHandlerComplete = *ast.CallExpr

http2errHandlerPanicked var #

errHandlerPanicked is the error given to any callers blocked in a read from Request.Body when the main goroutine panics. Since most handlers read in the main ServeHTTP goroutine, this will show up rarely.

var http2errHandlerPanicked = *ast.CallExpr

http2errMixPseudoHeaderTypes var #

var http2errMixPseudoHeaderTypes = *ast.CallExpr

http2errNilRequestURL var #

var http2errNilRequestURL = *ast.CallExpr

http2errPadBytes var #

var http2errPadBytes = *ast.CallExpr

http2errPadLength var #

var http2errPadLength = *ast.CallExpr

http2errPrefaceTimeout var #

var http2errPrefaceTimeout = *ast.CallExpr

http2errPseudoAfterRegular var #

var http2errPseudoAfterRegular = *ast.CallExpr

http2errReadEmpty var #

var http2errReadEmpty = *ast.CallExpr

http2errReqBodyTooLong var #

internal error values; they don't escape to callers

var http2errReqBodyTooLong = *ast.CallExpr

http2errRequestCanceled var #

errRequestCanceled is a copy of net/http's errRequestCanceled because it's not exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests.

var http2errRequestCanceled = *ast.CallExpr

http2errRequestCanceled var #

var http2errRequestCanceled = *ast.CallExpr

http2errRequestHeaderListSize var #

var http2errRequestHeaderListSize = *ast.CallExpr

http2errResponseHeaderListSize var #

var http2errResponseHeaderListSize = *ast.CallExpr

http2errStopReqBodyWrite var #

abort request body write; don't send cancel

var http2errStopReqBodyWrite = *ast.CallExpr

http2errStopReqBodyWriteAndCancel var #

abort request body write, but send stream reset of cancel.

var http2errStopReqBodyWriteAndCancel = *ast.CallExpr

http2errStreamClosed var #

var http2errStreamClosed = *ast.CallExpr

http2errStreamID var #

var http2errStreamID = *ast.CallExpr

http2errTimeout var #

var http2errTimeout error = *ast.UnaryExpr

http2errUninitializedPipeWrite var #

var http2errUninitializedPipeWrite = *ast.CallExpr

http2fhBytes var #

frame header bytes. Used only by ReadFrameHeader.

var http2fhBytes = sync.Pool{...}

http2firstSettingsTimeout const #

const http2firstSettingsTimeout = *ast.BinaryExpr

http2flagName var #

var http2flagName = map[http2FrameType]map[http2Flags]string{...}

http2frameHeaderLen const #

const http2frameHeaderLen = 9

http2frameName var #

var http2frameName = map[http2FrameType]string{...}

http2frameParsers var #

var http2frameParsers = map[http2FrameType]http2frameParser{...}

http2goAwayTimeout var #

After sending GOAWAY with an error code (non-graceful shutdown), the connection will close after goAwayTimeout. If we close the connection immediately after sending GOAWAY, there may be unsent data in our kernel receive buffer, which will cause the kernel to send a TCP RST on close() instead of a FIN. This RST will abort the connection immediately, whether or not the client had received the GOAWAY. Ideally we should delay for at least 1 RTT + epsilon so the client has a chance to read the GOAWAY and stop sending messages. Measuring RTT is hard, so we approximate with 1 second. See golang.org/issue/18701. This is a var so it can be shorter in tests, where all requests uses the loopback interface making the expected RTT very small. TODO: configurable?

var http2goAwayTimeout = *ast.BinaryExpr

http2goAwayTimeout var #

var http2goAwayTimeout = *ast.BinaryExpr

http2goroutineSpace var #

var http2goroutineSpace = *ast.CallExpr

http2got1xxFuncForTests var #

var http2got1xxFuncForTests func(int, textproto.MIMEHeader) error

http2gracefulShutdownMsg var #

Message values sent to serveMsgCh.

var http2gracefulShutdownMsg = *ast.CallExpr

http2handlerChunkWriteSize const #

const http2handlerChunkWriteSize = *ast.BinaryExpr

http2handlerDoneMsg var #

Message values sent to serveMsgCh.

var http2handlerDoneMsg = *ast.CallExpr

http2headerOrDataFrame const #

Constants passed to streamByID for documentation purposes.

const http2headerOrDataFrame = true

http2idleTimerMsg var #

Message values sent to serveMsgCh.

var http2idleTimerMsg = *ast.CallExpr

http2inTests var #

var http2inTests bool

http2inflowMinRefresh const #

inflowMinRefresh is the minimum number of bytes we'll send for a flow control window update.

const http2inflowMinRefresh = *ast.BinaryExpr

http2initialHeaderTableSize const #

https://httpwg.org/specs/rfc7540.html#SettingValues

const http2initialHeaderTableSize = 4096

http2initialMaxConcurrentStreams const #

initialMaxConcurrentStreams is a connections maxConcurrentStreams until it's received servers initial SETTINGS frame, which corresponds with the spec's minimum recommended value.

const http2initialMaxConcurrentStreams = 100

http2initialMaxFrameSize const #

SETTINGS_MAX_FRAME_SIZE default https://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2

const http2initialMaxFrameSize = 16384

http2initialWindowSize const #

const http2initialWindowSize = 65535

http2littleBuf var #

var http2littleBuf = sync.Pool{...}

http2logFrameReads var #

var http2logFrameReads bool

http2logFrameWrites var #

var http2logFrameWrites bool

http2maxCachedCanonicalHeadersKeysSize const #

maxCachedCanonicalHeadersKeysSize is an arbitrarily-chosen limit on the size of the entries in the canonHeader cache. This should be larger than the size of unique, uncommon header keys likely to be sent by the peer, while not so high as to permit unreasonable memory usage if the peer sends an unbounded number of unique header keys.

const http2maxCachedCanonicalHeadersKeysSize = 2048

http2maxFrameSize const #

const http2maxFrameSize = *ast.BinaryExpr

http2maxQueuedControlFrames const #

maxQueuedControlFrames is the maximum number of control frames like SETTINGS, PING and RST_STREAM that will be queued for writing before the connection is closed to prevent memory exhaustion attacks.

const http2maxQueuedControlFrames = 10000

http2minMaxFrameSize const #

const http2minMaxFrameSize = *ast.BinaryExpr

http2nextProtoUnencryptedHTTP2 const #

const http2nextProtoUnencryptedHTTP2 = "unencrypted_http2"

http2noBody var #

var http2noBody io.ReadCloser = http2noBodyReader{...}

http2noDialOnMiss const #

const http2noDialOnMiss = false

http2notHeaderOrDataFrame const #

Constants passed to streamByID for documentation purposes.

const http2notHeaderOrDataFrame = false

http2padZeros var #

var http2padZeros = *ast.CallExpr

http2prefaceTimeout const #

const http2prefaceTimeout = *ast.BinaryExpr

http2priorityDefaultWeight const #

RFC 7540, Section 5.3.5: the default weight is 16.

const http2priorityDefaultWeight = 15

http2priorityNodeClosed const #

const http2priorityNodeClosed

http2priorityNodeIdle const #

const http2priorityNodeIdle

http2priorityNodeOpen const #

const http2priorityNodeOpen http2priorityNodeState = iota

http2readIdleTimerMsg var #

Message values sent to serveMsgCh.

var http2readIdleTimerMsg = *ast.CallExpr

http2responseWriterStatePool var #

var http2responseWriterStatePool = sync.Pool{...}

http2server var #

var http2server = *ast.CallExpr

http2settingName var #

var http2settingName = map[http2SettingID]string{...}

http2settingsTimerMsg var #

Message values sent to serveMsgCh.

var http2settingsTimerMsg = *ast.CallExpr

http2shutdownEnterWaitStateHook var #

var http2shutdownEnterWaitStateHook = *ast.FuncLit

http2shutdownTimerMsg var #

Message values sent to serveMsgCh.

var http2shutdownTimerMsg = *ast.CallExpr

http2sorterPool var #

var http2sorterPool = sync.Pool{...}

http2stateClosed const #

HTTP/2 stream states. See http://tools.ietf.org/html/rfc7540#section-5.1. For simplicity, the server code merges "reserved (local)" into "half-closed (remote)". This is one less state transition to track. The only downside is that we send PUSH_PROMISEs slightly less liberally than allowable. More discussion here: https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html "reserved (remote)" is omitted since the client code does not support server push.

const http2stateClosed

http2stateHalfClosedLocal const #

HTTP/2 stream states. See http://tools.ietf.org/html/rfc7540#section-5.1. For simplicity, the server code merges "reserved (local)" into "half-closed (remote)". This is one less state transition to track. The only downside is that we send PUSH_PROMISEs slightly less liberally than allowable. More discussion here: https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html "reserved (remote)" is omitted since the client code does not support server push.

const http2stateHalfClosedLocal

http2stateHalfClosedRemote const #

HTTP/2 stream states. See http://tools.ietf.org/html/rfc7540#section-5.1. For simplicity, the server code merges "reserved (local)" into "half-closed (remote)". This is one less state transition to track. The only downside is that we send PUSH_PROMISEs slightly less liberally than allowable. More discussion here: https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html "reserved (remote)" is omitted since the client code does not support server push.

const http2stateHalfClosedRemote

http2stateIdle const #

HTTP/2 stream states. See http://tools.ietf.org/html/rfc7540#section-5.1. For simplicity, the server code merges "reserved (local)" into "half-closed (remote)". This is one less state transition to track. The only downside is that we send PUSH_PROMISEs slightly less liberally than allowable. More discussion here: https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html "reserved (remote)" is omitted since the client code does not support server push.

const http2stateIdle http2streamState = iota

http2stateName var #

var http2stateName = [...]string{...}

http2stateOpen const #

HTTP/2 stream states. See http://tools.ietf.org/html/rfc7540#section-5.1. For simplicity, the server code merges "reserved (local)" into "half-closed (remote)". This is one less state transition to track. The only downside is that we send PUSH_PROMISEs slightly less liberally than allowable. More discussion here: https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html "reserved (remote)" is omitted since the client code does not support server push.

const http2stateOpen

http2testHookGetServerConn var #

Test hooks.

var http2testHookGetServerConn func(*http2serverConn)

http2testHookOnConn var #

Test hooks.

var http2testHookOnConn func()

http2testHookOnPanic var #

Test hooks.

var http2testHookOnPanic func(sc *http2serverConn, panicVal interface{}) rePanic bool

http2testHookOnPanicMu var #

Test hooks.

var http2testHookOnPanicMu *sync.Mutex

http2transportDefaultConnFlow const #

transportDefaultConnFlow is how many connection-level flow control tokens we give the server at start-up, past the default 64k.

const http2transportDefaultConnFlow = *ast.BinaryExpr

http2transportDefaultStreamFlow const #

transportDefaultStreamFlow is how many stream-level flow control tokens we announce to the peer, and how many bytes we buffer per stream.

const http2transportDefaultStreamFlow = *ast.BinaryExpr

http2writeDataPool var #

var http2writeDataPool = sync.Pool{...}

httplaxcontentlength var #

var httplaxcontentlength = *ast.CallExpr

httpmuxgo121 var #

var httpmuxgo121 = *ast.CallExpr

httpservecontentkeepheaders var #

GODEBUG=httpservecontentkeepheaders=1 restores the pre-1.23 behavior of not deleting Cache-Control, Content-Encoding, Etag, or Last-Modified headers on ServeContent errors.

var httpservecontentkeepheaders = *ast.CallExpr

jsFetchCreds const #

jsFetchCreds is a Request.Header map key that, if present, signals that the map entry is actually an option to the Fetch API credentials setting. Valid values are: "omit", "same-origin", "include" The default is "same-origin". Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters

const jsFetchCreds = "js.fetch:credentials"

jsFetchDisabled var #

jsFetchDisabled controls whether the use of Fetch API is disabled. It's set to true when we detect we're running in Node.js, so that RoundTrip ends up talking over the same fake network the HTTP servers currently use in various tests and examples. See go.dev/issue/57613. TODO(go.dev/issue/60810): See if it's viable to test the Fetch API code path.

var jsFetchDisabled = *ast.BinaryExpr

jsFetchMissing var #

jsFetchMissing will be true if the Fetch API is not present in the browser globals.

var jsFetchMissing = *ast.CallExpr

jsFetchMode const #

jsFetchMode is a Request.Header map key that, if present, signals that the map entry is actually an option to the Fetch API mode setting. Valid values are: "cors", "no-cors", "same-origin", "navigate" The default is "same-origin". Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters

const jsFetchMode = "js.fetch:mode"

jsFetchRedirect const #

jsFetchRedirect is a Request.Header map key that, if present, signals that the map entry is actually an option to the Fetch API redirect setting. Valid values are: "follow", "error", "manual" The default is "follow". Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters

const jsFetchRedirect = "js.fetch:redirect"

maxInt64 const #

maxInt64 is the effective "infinite" value for the Server and Transport's byte-limiting readers.

const maxInt64 = *ast.BinaryExpr

maxPostHandlerReadBytes const #

maxPostHandlerReadBytes is the max number of Request.Body bytes not consumed by a handler that the server will read from the client in order to keep a connection alive. If there are more bytes than this, the server, to be paranoid, instead sends a "Connection close" response. This number is approximately what a typical machine's TCP buffer size is anyway. (if we have the bytes on the machine, we might as well read them)

const maxPostHandlerReadBytes = *ast.BinaryExpr

maxSlice var #

maxSlice is the maximum number of pairs for which a slice is used. It is a variable for benchmarking.

var maxSlice int = 8

maxWriteWaitBeforeConnReuse var #

maxWriteWaitBeforeConnReuse is how long the a Transport RoundTrip will wait to see the Request's Body.Write result after getting a response from the server. See comments in (*persistConn).wroteRequest. In tests, we set this to a large value to avoid flakiness from inconsistent recycling of connections.

var maxWriteWaitBeforeConnReuse = *ast.BinaryExpr

moreGeneral const #

const moreGeneral relationship = "moreGeneral"

moreSpecific const #

const moreSpecific relationship = "moreSpecific"

mp4 var #

var mp4 = *ast.CallExpr

mp4ftype var #

var mp4ftype = *ast.CallExpr

multipartByReader var #

multipartByReader is a sentinel value. Its presence in Request.MultipartForm indicates that parsing of the request body has been handed off to a MultipartReader instead of ParseMultipartForm.

var multipartByReader = *ast.UnaryExpr

nextProtoUnencryptedHTTP2 const #

TLSNextProto key to use for unencrypted HTTP/2 connections. Not actually a TLS-negotiated protocol.

const nextProtoUnencryptedHTTP2 = "unencrypted_http2"

noHTTP2 const #

const noHTTP2 = "no bundled HTTP/2"

nopCloserType var #

var nopCloserType = *ast.CallExpr

nopCloserWriterToType var #

var nopCloserWriterToType = *ast.CallExpr

omitBundledHTTP2 var #

omitBundledHTTP2 is set by omithttp2.go when the nethttpomithttp2 build tag is set. That means h2_bundle.go isn't compiled in and we shouldn't try to use it.

var omitBundledHTTP2 bool

overlaps const #

const overlaps relationship = "overlaps"

portMap var #

var portMap = map[string]string{...}

protoHTTP1 const #

const protoHTTP1 = *ast.BinaryExpr

protoHTTP2 const #

const protoHTTP2

protoUnencryptedHTTP2 const #

const protoUnencryptedHTTP2

reqWriteExcludeHeader var #

Headers that Request.Write handles itself and should be skipped.

var reqWriteExcludeHeader = map[string]bool{...}

respExcludeHeader var #

var respExcludeHeader = map[string]bool{...}

rstAvoidanceDelay var #

rstAvoidanceDelay is the amount of time we sleep after closing the write side of a TCP connection before closing the entire socket. By sleeping, we increase the chances that the client sees our FIN and processes its final data before they process the subsequent RST from closing a connection with known unread data. This RST seems to occur mostly on BSD systems. (And Windows?) This timeout is somewhat arbitrary (~latency around the planet), and may be modified by tests. TODO(bcmills): This should arguably be a server configuration parameter, not a hard-coded value.

var rstAvoidanceDelay = *ast.BinaryExpr

runHooks const #

const runHooks = true

shutdownPollIntervalMax const #

shutdownPollIntervalMax is the max polling interval when checking quiescence during Server.Shutdown. Polling starts with a small interval and backs off to the max. Ideally we could find a solution that doesn't involve polling, but which also doesn't have a high runtime cost (and doesn't involve any contentious mutexes), but that is left as an exercise for the reader.

const shutdownPollIntervalMax = *ast.BinaryExpr

singleCRLF var #

var singleCRLF = *ast.CallExpr

skipHooks const #

const skipHooks = false

sniffLen const #

The algorithm uses at most sniffLen bytes to make its decision.

const sniffLen = 512

sniffSignatures var #

Data matching the table in section 6.

var sniffSignatures = []sniffSig{...}

socksAddrTypeFQDN const #

Wire protocol constants.

const socksAddrTypeFQDN = 0x03

socksAddrTypeIPv4 const #

Wire protocol constants.

const socksAddrTypeIPv4 = 0x01

socksAddrTypeIPv6 const #

Wire protocol constants.

const socksAddrTypeIPv6 = 0x04

socksAuthMethodNoAcceptableMethods const #

Wire protocol constants.

const socksAuthMethodNoAcceptableMethods socksAuthMethod = 0xff

socksAuthMethodNotRequired const #

Wire protocol constants.

const socksAuthMethodNotRequired socksAuthMethod = 0x00

socksAuthMethodUsernamePassword const #

Wire protocol constants.

const socksAuthMethodUsernamePassword socksAuthMethod = 0x02

socksCmdConnect const #

Wire protocol constants.

const socksCmdConnect socksCommand = 0x01

socksStatusSucceeded const #

Wire protocol constants.

const socksStatusSucceeded socksReply = 0x00

socksVersion5 const #

Wire protocol constants.

const socksVersion5 = 0x05

socksaLongTimeAgo var #

var socksaLongTimeAgo = *ast.CallExpr

socksauthStatusSucceeded const #

const socksauthStatusSucceeded = 0x00

socksauthUsernamePasswordVersion const #

const socksauthUsernamePasswordVersion = 0x01

sockscmdBind const #

Wire protocol constants.

const sockscmdBind socksCommand = 0x02

socksnoDeadline var #

var socksnoDeadline = time.Time{...}

stateName var #

var stateName = map[ConnState]string{...}

suppressedHeaders304 var #

var suppressedHeaders304 = []string{...}

suppressedHeadersNoBody var #

var suppressedHeadersNoBody = []string{...}

testHookClientDoResult var #

var testHookClientDoResult func(retres *Response, reterr error)

testHookEnterRoundTrip var #

testHooks. Always non-nil.

var testHookEnterRoundTrip = nop

testHookMu var #

testHooks. Always non-nil.

var testHookMu sync.Locker = fakeLocker{...}

testHookPostPendingDial var #

testHooks. Always non-nil.

var testHookPostPendingDial = nop

testHookPrePendingDial var #

testHooks. Always non-nil.

var testHookPrePendingDial = nop

testHookProxyConnectTimeout var #

var testHookProxyConnectTimeout = context.WithTimeout

testHookReadLoopBeforeNextRead var #

testHooks. Always non-nil.

var testHookReadLoopBeforeNextRead = nop

testHookRoundTripRetried var #

testHooks. Always non-nil.

var testHookRoundTripRetried = nop

testHookServerServe var #

var testHookServerServe func(*Server, net.Listener)

testHookWaitResLoop var #

testHooks. Always non-nil.

var testHookWaitResLoop = nop

textprotoReaderPool var #

var textprotoReaderPool sync.Pool

timeFormats var #

var timeFormats = []string{...}

uint8Array var #

var uint8Array = *ast.CallExpr

uniqNameMu var #

var uniqNameMu sync.Mutex

uniqNameNext var #

var uniqNameNext = *ast.CallExpr

unixEpochTime var #

var unixEpochTime = *ast.CallExpr

use121 var #

var use121 bool

zeroDialer var #

var zeroDialer net.Dialer