Source file src/net/http/fcgi/child.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package fcgi
     6	
     7	// This file implements FastCGI from the perspective of a child process.
     8	
     9	import (
    10		"context"
    11		"errors"
    12		"fmt"
    13		"io"
    14		"io/ioutil"
    15		"net"
    16		"net/http"
    17		"net/http/cgi"
    18		"os"
    19		"strings"
    20		"sync"
    21		"time"
    22	)
    23	
    24	// request holds the state for an in-progress request. As soon as it's complete,
    25	// it's converted to an http.Request.
    26	type request struct {
    27		pw        *io.PipeWriter
    28		reqId     uint16
    29		params    map[string]string
    30		buf       [1024]byte
    31		rawParams []byte
    32		keepConn  bool
    33	}
    34	
    35	// envVarsContextKey uniquely identifies a mapping of CGI
    36	// environment variables to their values in a request context
    37	type envVarsContextKey struct{}
    38	
    39	func newRequest(reqId uint16, flags uint8) *request {
    40		r := &request{
    41			reqId:    reqId,
    42			params:   map[string]string{},
    43			keepConn: flags&flagKeepConn != 0,
    44		}
    45		r.rawParams = r.buf[:0]
    46		return r
    47	}
    48	
    49	// parseParams reads an encoded []byte into Params.
    50	func (r *request) parseParams() {
    51		text := r.rawParams
    52		r.rawParams = nil
    53		for len(text) > 0 {
    54			keyLen, n := readSize(text)
    55			if n == 0 {
    56				return
    57			}
    58			text = text[n:]
    59			valLen, n := readSize(text)
    60			if n == 0 {
    61				return
    62			}
    63			text = text[n:]
    64			if int(keyLen)+int(valLen) > len(text) {
    65				return
    66			}
    67			key := readString(text, keyLen)
    68			text = text[keyLen:]
    69			val := readString(text, valLen)
    70			text = text[valLen:]
    71			r.params[key] = val
    72		}
    73	}
    74	
    75	// response implements http.ResponseWriter.
    76	type response struct {
    77		req         *request
    78		header      http.Header
    79		w           *bufWriter
    80		wroteHeader bool
    81	}
    82	
    83	func newResponse(c *child, req *request) *response {
    84		return &response{
    85			req:    req,
    86			header: http.Header{},
    87			w:      newWriter(c.conn, typeStdout, req.reqId),
    88		}
    89	}
    90	
    91	func (r *response) Header() http.Header {
    92		return r.header
    93	}
    94	
    95	func (r *response) Write(data []byte) (int, error) {
    96		if !r.wroteHeader {
    97			r.WriteHeader(http.StatusOK)
    98		}
    99		return r.w.Write(data)
   100	}
   101	
   102	func (r *response) WriteHeader(code int) {
   103		if r.wroteHeader {
   104			return
   105		}
   106		r.wroteHeader = true
   107		if code == http.StatusNotModified {
   108			// Must not have body.
   109			r.header.Del("Content-Type")
   110			r.header.Del("Content-Length")
   111			r.header.Del("Transfer-Encoding")
   112		} else if r.header.Get("Content-Type") == "" {
   113			r.header.Set("Content-Type", "text/html; charset=utf-8")
   114		}
   115	
   116		if r.header.Get("Date") == "" {
   117			r.header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
   118		}
   119	
   120		fmt.Fprintf(r.w, "Status: %d %s\r\n", code, http.StatusText(code))
   121		r.header.Write(r.w)
   122		r.w.WriteString("\r\n")
   123	}
   124	
   125	func (r *response) Flush() {
   126		if !r.wroteHeader {
   127			r.WriteHeader(http.StatusOK)
   128		}
   129		r.w.Flush()
   130	}
   131	
   132	func (r *response) Close() error {
   133		r.Flush()
   134		return r.w.Close()
   135	}
   136	
   137	type child struct {
   138		conn    *conn
   139		handler http.Handler
   140	
   141		mu       sync.Mutex          // protects requests:
   142		requests map[uint16]*request // keyed by request ID
   143	}
   144	
   145	func newChild(rwc io.ReadWriteCloser, handler http.Handler) *child {
   146		return &child{
   147			conn:     newConn(rwc),
   148			handler:  handler,
   149			requests: make(map[uint16]*request),
   150		}
   151	}
   152	
   153	func (c *child) serve() {
   154		defer c.conn.Close()
   155		defer c.cleanUp()
   156		var rec record
   157		for {
   158			if err := rec.read(c.conn.rwc); err != nil {
   159				return
   160			}
   161			if err := c.handleRecord(&rec); err != nil {
   162				return
   163			}
   164		}
   165	}
   166	
   167	var errCloseConn = errors.New("fcgi: connection should be closed")
   168	
   169	var emptyBody = ioutil.NopCloser(strings.NewReader(""))
   170	
   171	// ErrRequestAborted is returned by Read when a handler attempts to read the
   172	// body of a request that has been aborted by the web server.
   173	var ErrRequestAborted = errors.New("fcgi: request aborted by web server")
   174	
   175	// ErrConnClosed is returned by Read when a handler attempts to read the body of
   176	// a request after the connection to the web server has been closed.
   177	var ErrConnClosed = errors.New("fcgi: connection to web server closed")
   178	
   179	func (c *child) handleRecord(rec *record) error {
   180		c.mu.Lock()
   181		req, ok := c.requests[rec.h.Id]
   182		c.mu.Unlock()
   183		if !ok && rec.h.Type != typeBeginRequest && rec.h.Type != typeGetValues {
   184			// The spec says to ignore unknown request IDs.
   185			return nil
   186		}
   187	
   188		switch rec.h.Type {
   189		case typeBeginRequest:
   190			if req != nil {
   191				// The server is trying to begin a request with the same ID
   192				// as an in-progress request. This is an error.
   193				return errors.New("fcgi: received ID that is already in-flight")
   194			}
   195	
   196			var br beginRequest
   197			if err := br.read(rec.content()); err != nil {
   198				return err
   199			}
   200			if br.role != roleResponder {
   201				c.conn.writeEndRequest(rec.h.Id, 0, statusUnknownRole)
   202				return nil
   203			}
   204			req = newRequest(rec.h.Id, br.flags)
   205			c.mu.Lock()
   206			c.requests[rec.h.Id] = req
   207			c.mu.Unlock()
   208			return nil
   209		case typeParams:
   210			// NOTE(eds): Technically a key-value pair can straddle the boundary
   211			// between two packets. We buffer until we've received all parameters.
   212			if len(rec.content()) > 0 {
   213				req.rawParams = append(req.rawParams, rec.content()...)
   214				return nil
   215			}
   216			req.parseParams()
   217			return nil
   218		case typeStdin:
   219			content := rec.content()
   220			if req.pw == nil {
   221				var body io.ReadCloser
   222				if len(content) > 0 {
   223					// body could be an io.LimitReader, but it shouldn't matter
   224					// as long as both sides are behaving.
   225					body, req.pw = io.Pipe()
   226				} else {
   227					body = emptyBody
   228				}
   229				go c.serveRequest(req, body)
   230			}
   231			if len(content) > 0 {
   232				// TODO(eds): This blocks until the handler reads from the pipe.
   233				// If the handler takes a long time, it might be a problem.
   234				req.pw.Write(content)
   235			} else if req.pw != nil {
   236				req.pw.Close()
   237			}
   238			return nil
   239		case typeGetValues:
   240			values := map[string]string{"FCGI_MPXS_CONNS": "1"}
   241			c.conn.writePairs(typeGetValuesResult, 0, values)
   242			return nil
   243		case typeData:
   244			// If the filter role is implemented, read the data stream here.
   245			return nil
   246		case typeAbortRequest:
   247			c.mu.Lock()
   248			delete(c.requests, rec.h.Id)
   249			c.mu.Unlock()
   250			c.conn.writeEndRequest(rec.h.Id, 0, statusRequestComplete)
   251			if req.pw != nil {
   252				req.pw.CloseWithError(ErrRequestAborted)
   253			}
   254			if !req.keepConn {
   255				// connection will close upon return
   256				return errCloseConn
   257			}
   258			return nil
   259		default:
   260			b := make([]byte, 8)
   261			b[0] = byte(rec.h.Type)
   262			c.conn.writeRecord(typeUnknownType, 0, b)
   263			return nil
   264		}
   265	}
   266	
   267	// filterOutUsedEnvVars returns a new map of env vars without the
   268	// variables in the given envVars map that are read for creating each http.Request
   269	func filterOutUsedEnvVars(envVars map[string]string) map[string]string {
   270		withoutUsedEnvVars := make(map[string]string)
   271		for k, v := range envVars {
   272			if addFastCGIEnvToContext(k) {
   273				withoutUsedEnvVars[k] = v
   274			}
   275		}
   276		return withoutUsedEnvVars
   277	}
   278	
   279	func (c *child) serveRequest(req *request, body io.ReadCloser) {
   280		r := newResponse(c, req)
   281		httpReq, err := cgi.RequestFromMap(req.params)
   282		if err != nil {
   283			// there was an error reading the request
   284			r.WriteHeader(http.StatusInternalServerError)
   285			c.conn.writeRecord(typeStderr, req.reqId, []byte(err.Error()))
   286		} else {
   287			httpReq.Body = body
   288			withoutUsedEnvVars := filterOutUsedEnvVars(req.params)
   289			envVarCtx := context.WithValue(httpReq.Context(), envVarsContextKey{}, withoutUsedEnvVars)
   290			httpReq = httpReq.WithContext(envVarCtx)
   291			c.handler.ServeHTTP(r, httpReq)
   292		}
   293		r.Close()
   294		c.mu.Lock()
   295		delete(c.requests, req.reqId)
   296		c.mu.Unlock()
   297		c.conn.writeEndRequest(req.reqId, 0, statusRequestComplete)
   298	
   299		// Consume the entire body, so the host isn't still writing to
   300		// us when we close the socket below in the !keepConn case,
   301		// otherwise we'd send a RST. (golang.org/issue/4183)
   302		// TODO(bradfitz): also bound this copy in time. Or send
   303		// some sort of abort request to the host, so the host
   304		// can properly cut off the client sending all the data.
   305		// For now just bound it a little and
   306		io.CopyN(ioutil.Discard, body, 100<<20)
   307		body.Close()
   308	
   309		if !req.keepConn {
   310			c.conn.Close()
   311		}
   312	}
   313	
   314	func (c *child) cleanUp() {
   315		c.mu.Lock()
   316		defer c.mu.Unlock()
   317		for _, req := range c.requests {
   318			if req.pw != nil {
   319				// race with call to Close in c.serveRequest doesn't matter because
   320				// Pipe(Reader|Writer).Close are idempotent
   321				req.pw.CloseWithError(ErrConnClosed)
   322			}
   323		}
   324	}
   325	
   326	// Serve accepts incoming FastCGI connections on the listener l, creating a new
   327	// goroutine for each. The goroutine reads requests and then calls handler
   328	// to reply to them.
   329	// If l is nil, Serve accepts connections from os.Stdin.
   330	// If handler is nil, http.DefaultServeMux is used.
   331	func Serve(l net.Listener, handler http.Handler) error {
   332		if l == nil {
   333			var err error
   334			l, err = net.FileListener(os.Stdin)
   335			if err != nil {
   336				return err
   337			}
   338			defer l.Close()
   339		}
   340		if handler == nil {
   341			handler = http.DefaultServeMux
   342		}
   343		for {
   344			rw, err := l.Accept()
   345			if err != nil {
   346				return err
   347			}
   348			c := newChild(rw, handler)
   349			go c.serve()
   350		}
   351	}
   352	
   353	// ProcessEnv returns FastCGI environment variables associated with the request r
   354	// for which no effort was made to be included in the request itself - the data
   355	// is hidden in the request's context. As an example, if REMOTE_USER is set for a
   356	// request, it will not be found anywhere in r, but it will be included in
   357	// ProcessEnv's response (via r's context).
   358	func ProcessEnv(r *http.Request) map[string]string {
   359		env, _ := r.Context().Value(envVarsContextKey{}).(map[string]string)
   360		return env
   361	}
   362	
   363	// addFastCGIEnvToContext reports whether to include the FastCGI environment variable s
   364	// in the http.Request.Context, accessible via ProcessEnv.
   365	func addFastCGIEnvToContext(s string) bool {
   366		// Exclude things supported by net/http natively:
   367		switch s {
   368		case "CONTENT_LENGTH", "CONTENT_TYPE", "HTTPS",
   369			"PATH_INFO", "QUERY_STRING", "REMOTE_ADDR",
   370			"REMOTE_HOST", "REMOTE_PORT", "REQUEST_METHOD",
   371			"REQUEST_URI", "SCRIPT_NAME", "SERVER_PROTOCOL":
   372			return false
   373		}
   374		if strings.HasPrefix(s, "HTTP_") {
   375			return false
   376		}
   377		// Explicitly include FastCGI-specific things.
   378		// This list is redundant with the default "return true" below.
   379		// Consider this documentation of the sorts of things we expect
   380		// to maybe see.
   381		switch s {
   382		case "REMOTE_USER":
   383			return true
   384		}
   385		// Unknown, so include it to be safe.
   386		return true
   387	}
   388	

View as plain text