123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401 |
- package runtime
- import (
- "context"
- "encoding/base64"
- "fmt"
- "net"
- "net/http"
- "net/textproto"
- "strconv"
- "strings"
- "sync"
- "time"
- "google.golang.org/grpc/codes"
- "google.golang.org/grpc/grpclog"
- "google.golang.org/grpc/metadata"
- "google.golang.org/grpc/status"
- )
- // MetadataHeaderPrefix is the http prefix that represents custom metadata
- // parameters to or from a gRPC call.
- const MetadataHeaderPrefix = "Grpc-Metadata-"
- // MetadataPrefix is prepended to permanent HTTP header keys (as specified
- // by the IANA) when added to the gRPC context.
- const MetadataPrefix = "grpcgateway-"
- // MetadataTrailerPrefix is prepended to gRPC metadata as it is converted to
- // HTTP headers in a response handled by grpc-gateway
- const MetadataTrailerPrefix = "Grpc-Trailer-"
- const metadataGrpcTimeout = "Grpc-Timeout"
- const metadataHeaderBinarySuffix = "-Bin"
- const xForwardedFor = "X-Forwarded-For"
- const xForwardedHost = "X-Forwarded-Host"
- // DefaultContextTimeout is used for gRPC call context.WithTimeout whenever a Grpc-Timeout inbound
- // header isn't present. If the value is 0 the sent `context` will not have a timeout.
- var DefaultContextTimeout = 0 * time.Second
- // malformedHTTPHeaders lists the headers that the gRPC server may reject outright as malformed.
- // See https://github.com/grpc/grpc-go/pull/4803#issuecomment-986093310 for more context.
- var malformedHTTPHeaders = map[string]struct{}{
- "connection": {},
- }
- type (
- rpcMethodKey struct{}
- httpPathPatternKey struct{}
- AnnotateContextOption func(ctx context.Context) context.Context
- )
- func WithHTTPPathPattern(pattern string) AnnotateContextOption {
- return func(ctx context.Context) context.Context {
- return withHTTPPathPattern(ctx, pattern)
- }
- }
- func decodeBinHeader(v string) ([]byte, error) {
- if len(v)%4 == 0 {
- // Input was padded, or padding was not necessary.
- return base64.StdEncoding.DecodeString(v)
- }
- return base64.RawStdEncoding.DecodeString(v)
- }
- /*
- AnnotateContext adds context information such as metadata from the request.
- At a minimum, the RemoteAddr is included in the fashion of "X-Forwarded-For",
- except that the forwarded destination is not another HTTP service but rather
- a gRPC service.
- */
- func AnnotateContext(ctx context.Context, mux *ServeMux, req *http.Request, rpcMethodName string, options ...AnnotateContextOption) (context.Context, error) {
- ctx, md, err := annotateContext(ctx, mux, req, rpcMethodName, options...)
- if err != nil {
- return nil, err
- }
- if md == nil {
- return ctx, nil
- }
- return metadata.NewOutgoingContext(ctx, md), nil
- }
- // AnnotateIncomingContext adds context information such as metadata from the request.
- // Attach metadata as incoming context.
- func AnnotateIncomingContext(ctx context.Context, mux *ServeMux, req *http.Request, rpcMethodName string, options ...AnnotateContextOption) (context.Context, error) {
- ctx, md, err := annotateContext(ctx, mux, req, rpcMethodName, options...)
- if err != nil {
- return nil, err
- }
- if md == nil {
- return ctx, nil
- }
- return metadata.NewIncomingContext(ctx, md), nil
- }
- func isValidGRPCMetadataKey(key string) bool {
- // Must be a valid gRPC "Header-Name" as defined here:
- // https://github.com/grpc/grpc/blob/4b05dc88b724214d0c725c8e7442cbc7a61b1374/doc/PROTOCOL-HTTP2.md
- // This means 0-9 a-z _ - .
- // Only lowercase letters are valid in the wire protocol, but the client library will normalize
- // uppercase ASCII to lowercase, so uppercase ASCII is also acceptable.
- bytes := []byte(key) // gRPC validates strings on the byte level, not Unicode.
- for _, ch := range bytes {
- validLowercaseLetter := ch >= 'a' && ch <= 'z'
- validUppercaseLetter := ch >= 'A' && ch <= 'Z'
- validDigit := ch >= '0' && ch <= '9'
- validOther := ch == '.' || ch == '-' || ch == '_'
- if !validLowercaseLetter && !validUppercaseLetter && !validDigit && !validOther {
- return false
- }
- }
- return true
- }
- func isValidGRPCMetadataTextValue(textValue string) bool {
- // Must be a valid gRPC "ASCII-Value" as defined here:
- // https://github.com/grpc/grpc/blob/4b05dc88b724214d0c725c8e7442cbc7a61b1374/doc/PROTOCOL-HTTP2.md
- // This means printable ASCII (including/plus spaces); 0x20 to 0x7E inclusive.
- bytes := []byte(textValue) // gRPC validates strings on the byte level, not Unicode.
- for _, ch := range bytes {
- if ch < 0x20 || ch > 0x7E {
- return false
- }
- }
- return true
- }
- func annotateContext(ctx context.Context, mux *ServeMux, req *http.Request, rpcMethodName string, options ...AnnotateContextOption) (context.Context, metadata.MD, error) {
- ctx = withRPCMethod(ctx, rpcMethodName)
- for _, o := range options {
- ctx = o(ctx)
- }
- timeout := DefaultContextTimeout
- if tm := req.Header.Get(metadataGrpcTimeout); tm != "" {
- var err error
- timeout, err = timeoutDecode(tm)
- if err != nil {
- return nil, nil, status.Errorf(codes.InvalidArgument, "invalid grpc-timeout: %s", tm)
- }
- }
- var pairs []string
- for key, vals := range req.Header {
- key = textproto.CanonicalMIMEHeaderKey(key)
- for _, val := range vals {
- // For backwards-compatibility, pass through 'authorization' header with no prefix.
- if key == "Authorization" {
- pairs = append(pairs, "authorization", val)
- }
- if h, ok := mux.incomingHeaderMatcher(key); ok {
- if !isValidGRPCMetadataKey(h) {
- grpclog.Errorf("HTTP header name %q is not valid as gRPC metadata key; skipping", h)
- continue
- }
- // Handles "-bin" metadata in grpc, since grpc will do another base64
- // encode before sending to server, we need to decode it first.
- if strings.HasSuffix(key, metadataHeaderBinarySuffix) {
- b, err := decodeBinHeader(val)
- if err != nil {
- return nil, nil, status.Errorf(codes.InvalidArgument, "invalid binary header %s: %s", key, err)
- }
- val = string(b)
- } else if !isValidGRPCMetadataTextValue(val) {
- grpclog.Errorf("Value of HTTP header %q contains non-ASCII value (not valid as gRPC metadata): skipping", h)
- continue
- }
- pairs = append(pairs, h, val)
- }
- }
- }
- if host := req.Header.Get(xForwardedHost); host != "" {
- pairs = append(pairs, strings.ToLower(xForwardedHost), host)
- } else if req.Host != "" {
- pairs = append(pairs, strings.ToLower(xForwardedHost), req.Host)
- }
- if addr := req.RemoteAddr; addr != "" {
- if remoteIP, _, err := net.SplitHostPort(addr); err == nil {
- if fwd := req.Header.Get(xForwardedFor); fwd == "" {
- pairs = append(pairs, strings.ToLower(xForwardedFor), remoteIP)
- } else {
- pairs = append(pairs, strings.ToLower(xForwardedFor), fmt.Sprintf("%s, %s", fwd, remoteIP))
- }
- }
- }
- if timeout != 0 {
- //nolint:govet // The context outlives this function
- ctx, _ = context.WithTimeout(ctx, timeout)
- }
- if len(pairs) == 0 {
- return ctx, nil, nil
- }
- md := metadata.Pairs(pairs...)
- for _, mda := range mux.metadataAnnotators {
- md = metadata.Join(md, mda(ctx, req))
- }
- return ctx, md, nil
- }
- // ServerMetadata consists of metadata sent from gRPC server.
- type ServerMetadata struct {
- HeaderMD metadata.MD
- TrailerMD metadata.MD
- }
- type serverMetadataKey struct{}
- // NewServerMetadataContext creates a new context with ServerMetadata
- func NewServerMetadataContext(ctx context.Context, md ServerMetadata) context.Context {
- if ctx == nil {
- ctx = context.Background()
- }
- return context.WithValue(ctx, serverMetadataKey{}, md)
- }
- // ServerMetadataFromContext returns the ServerMetadata in ctx
- func ServerMetadataFromContext(ctx context.Context) (md ServerMetadata, ok bool) {
- if ctx == nil {
- return md, false
- }
- md, ok = ctx.Value(serverMetadataKey{}).(ServerMetadata)
- return
- }
- // ServerTransportStream implements grpc.ServerTransportStream.
- // It should only be used by the generated files to support grpc.SendHeader
- // outside of gRPC server use.
- type ServerTransportStream struct {
- mu sync.Mutex
- header metadata.MD
- trailer metadata.MD
- }
- // Method returns the method for the stream.
- func (s *ServerTransportStream) Method() string {
- return ""
- }
- // Header returns the header metadata of the stream.
- func (s *ServerTransportStream) Header() metadata.MD {
- s.mu.Lock()
- defer s.mu.Unlock()
- return s.header.Copy()
- }
- // SetHeader sets the header metadata.
- func (s *ServerTransportStream) SetHeader(md metadata.MD) error {
- if md.Len() == 0 {
- return nil
- }
- s.mu.Lock()
- s.header = metadata.Join(s.header, md)
- s.mu.Unlock()
- return nil
- }
- // SendHeader sets the header metadata.
- func (s *ServerTransportStream) SendHeader(md metadata.MD) error {
- return s.SetHeader(md)
- }
- // Trailer returns the cached trailer metadata.
- func (s *ServerTransportStream) Trailer() metadata.MD {
- s.mu.Lock()
- defer s.mu.Unlock()
- return s.trailer.Copy()
- }
- // SetTrailer sets the trailer metadata.
- func (s *ServerTransportStream) SetTrailer(md metadata.MD) error {
- if md.Len() == 0 {
- return nil
- }
- s.mu.Lock()
- s.trailer = metadata.Join(s.trailer, md)
- s.mu.Unlock()
- return nil
- }
- func timeoutDecode(s string) (time.Duration, error) {
- size := len(s)
- if size < 2 {
- return 0, fmt.Errorf("timeout string is too short: %q", s)
- }
- d, ok := timeoutUnitToDuration(s[size-1])
- if !ok {
- return 0, fmt.Errorf("timeout unit is not recognized: %q", s)
- }
- t, err := strconv.ParseInt(s[:size-1], 10, 64)
- if err != nil {
- return 0, err
- }
- return d * time.Duration(t), nil
- }
- func timeoutUnitToDuration(u uint8) (d time.Duration, ok bool) {
- switch u {
- case 'H':
- return time.Hour, true
- case 'M':
- return time.Minute, true
- case 'S':
- return time.Second, true
- case 'm':
- return time.Millisecond, true
- case 'u':
- return time.Microsecond, true
- case 'n':
- return time.Nanosecond, true
- default:
- return
- }
- }
- // isPermanentHTTPHeader checks whether hdr belongs to the list of
- // permanent request headers maintained by IANA.
- // http://www.iana.org/assignments/message-headers/message-headers.xml
- func isPermanentHTTPHeader(hdr string) bool {
- switch hdr {
- case
- "Accept",
- "Accept-Charset",
- "Accept-Language",
- "Accept-Ranges",
- "Authorization",
- "Cache-Control",
- "Content-Type",
- "Cookie",
- "Date",
- "Expect",
- "From",
- "Host",
- "If-Match",
- "If-Modified-Since",
- "If-None-Match",
- "If-Schedule-Tag-Match",
- "If-Unmodified-Since",
- "Max-Forwards",
- "Origin",
- "Pragma",
- "Referer",
- "User-Agent",
- "Via",
- "Warning":
- return true
- }
- return false
- }
- // isMalformedHTTPHeader checks whether header belongs to the list of
- // "malformed headers" and would be rejected by the gRPC server.
- func isMalformedHTTPHeader(header string) bool {
- _, isMalformed := malformedHTTPHeaders[strings.ToLower(header)]
- return isMalformed
- }
- // RPCMethod returns the method string for the server context. The returned
- // string is in the format of "/package.service/method".
- func RPCMethod(ctx context.Context) (string, bool) {
- m := ctx.Value(rpcMethodKey{})
- if m == nil {
- return "", false
- }
- ms, ok := m.(string)
- if !ok {
- return "", false
- }
- return ms, true
- }
- func withRPCMethod(ctx context.Context, rpcMethodName string) context.Context {
- return context.WithValue(ctx, rpcMethodKey{}, rpcMethodName)
- }
- // HTTPPathPattern returns the HTTP path pattern string relating to the HTTP handler, if one exists.
- // The format of the returned string is defined by the google.api.http path template type.
- func HTTPPathPattern(ctx context.Context) (string, bool) {
- m := ctx.Value(httpPathPatternKey{})
- if m == nil {
- return "", false
- }
- ms, ok := m.(string)
- if !ok {
- return "", false
- }
- return ms, true
- }
- func withHTTPPathPattern(ctx context.Context, httpPathPattern string) context.Context {
- return context.WithValue(ctx, httpPathPatternKey{}, httpPathPattern)
- }
|