package httpcommon

Import Path
	golang.org/x/net/internal/httpcommon (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package

Involved Source Files

	    ascii.go
	    headermap.go
	    request.go
Package-Level Type Names (total 5, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type EncodeHeadersParam (struct)
		EncodeHeadersParam is parameters to EncodeHeaders.

		Fields (total 4, all are exported)
			AddGzipHeader bool
				AddGzipHeader indicates that an "accept-encoding: gzip" header should be
				added to the request.

			DefaultUserAgent string
				DefaultUserAgent is the User-Agent header to send when the request
				neither contains a User-Agent nor disables it.

			PeerMaxHeaderListSize uint64
				PeerMaxHeaderListSize, when non-zero, is the peer's MAX_HEADER_LIST_SIZE setting.

			Request Request
		As Inputs Of (at least one exported)
			func EncodeHeaders(ctx context.Context, param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error)

	 type EncodeHeadersResult (struct)
		EncodeHeadersParam is the result of EncodeHeaders.

		Fields (total 2, both are exported)
			HasBody bool
			HasTrailers bool
		As Outputs Of (at least 2, in which 1 is exported)
			func EncodeHeaders(ctx context.Context, param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error)
			/* at least one unexported ... *//* at least one unexported: */
			func golang.org/x/net/http2.encodeRequestHeaders(req *http.Request, addGzipHeader bool, peerMaxHeaderListSize uint64, headerf func(name, value string)) (EncodeHeadersResult, error)

	 type Request (struct)
		Request is a subset of http.Request.
		It'd be simpler to pass an *http.Request, of course, but we can't depend on net/http
		without creating a dependency cycle.

		Fields (total 6, all are exported)
			ActualContentLength int64
				// 0 means 0, -1 means unknown

			Header map[string][]string
			Host string
			Method string
			Trailer map[string][]string
			URL *url.URL

	 type ServerRequestParam (struct)
		ServerRequestParam is parameters to NewServerRequest.

		Fields (total 6, all are exported)
			Authority string
			Header map[string][]string
			Method string
			Path string
			Protocol string
			Scheme string
		As Inputs Of (at least one exported)
			func NewServerRequest(rp ServerRequestParam) ServerRequestResult

	 type ServerRequestResult (struct)
		ServerRequestResult is the result of NewServerRequest.

		Fields (total 5, all are exported)
			InvalidReason string
				If the request should be rejected, this is a short string suitable for passing
				to the http2 package's CountError function.
				It might be a bit odd to return errors this way rather than returing an error,
				but this ensures we don't forget to include a CountError reason.

			NeedsContinue bool
				// client provided an "Expect: 100-continue" header

			RequestURI string
			Trailer map[string][]string
			URL *url.URL
				Various http.Request fields.

		As Outputs Of (at least one exported)
			func NewServerRequest(rp ServerRequestParam) ServerRequestResult


Package-Level Functions (total 17, in which 6 are exported)

	 func CachedCanonicalHeader(v string) (string, bool)
		CachedCanonicalHeader returns the canonical form of a well-known header name.

	 func CanonicalHeader(v string) string
		CanonicalHeader canonicalizes a header name. (For example, "host" becomes "Host".)

	 func EncodeHeaders(ctx context.Context, param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error)
		EncodeHeaders constructs request headers common to HTTP/2 and HTTP/3.
		It validates a request and calls headerf with each pseudo-header and header
		for the request.
		The headerf function is called with the validated, canonicalized header name.

	 func IsRequestGzip(method string, header map[string][]string, disableCompression bool) bool
		IsRequestGzip reports whether we should add an Accept-Encoding: gzip header
		for a request.

	 func LowerHeader(v string) (lower string, ascii bool)
		LowerHeader returns the lowercase form of a header name,
		used on the wire for HTTP/2 and HTTP/3 requests.

	 func NewServerRequest(rp ServerRequestParam) ServerRequestResult
	/* 11 unexporteds ... *//* 11 unexporteds: */
	 func asciiEqualFold(s, t string) bool
		asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
		are equal, ASCII-case-insensitively.

	 func asciiToLower(s string) (lower string, ok bool)
		asciiToLower returns the lowercase version of s if s is ASCII and printable,
		and whether or not it was.

	 func buildCommonHeaderMaps()
	 func buildCommonHeaderMapsOnce()
	 func checkConnHeaders(h map[string][]string) error
		checkConnHeaders checks whether req has any invalid connection-level headers.
		
		https://www.rfc-editor.org/rfc/rfc9114.html#section-4.2-3
		https://www.rfc-editor.org/rfc/rfc9113.html#section-8.2.2-1
		
		Certain headers are special-cased as okay but not transmitted later.
		For example, we allow "Transfer-Encoding: chunked", but drop the header when encoding.

	 func commaSeparatedTrailers(trailer map[string][]string) (string, error)
	 func isASCIIPrint(s string) bool
		isASCIIPrint returns whether s is ASCII and printable according to
		https://tools.ietf.org/html/rfc20#section-4.2.

	 func lower(b byte) byte
		lower returns the ASCII lowercase version of b.

	 func shouldSendReqContentLength(method string, contentLength int64) bool
		shouldSendReqContentLength reports whether we should send
		a "content-length" request header. This logic is basically a copy of the net/http
		transferWriter.shouldSendContentLength.
		The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
		-1 means unknown.

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


Package-Level Variables (total 4, in which 1 is exported)

	  var ErrRequestHeaderListSize error
	/* 3 unexporteds ... *//* 3 unexporteds: */
	  var commonBuildOnce sync.Once
	  var commonCanonHeader map[string]string // lower-case -> Go-Canonical-Case
	  var commonLowerHeader map[string]string // Go-Canonical-Case -> lower-case

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)