fcgi.go

Documentation: net/http/fcgi

		 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 implements the FastCGI protocol.
		 6  //
		 7  // See https://fast-cgi.github.io/ for an unofficial mirror of the
		 8  // original documentation.
		 9  //
		10  // Currently only the responder role is supported.
		11  package fcgi
		12  
		13  // This file defines the raw protocol and some utilities used by the child and
		14  // the host.
		15  
		16  import (
		17  	"bufio"
		18  	"bytes"
		19  	"encoding/binary"
		20  	"errors"
		21  	"io"
		22  	"sync"
		23  )
		24  
		25  // recType is a record type, as defined by
		26  // https://web.archive.org/web/20150420080736/http://www.fastcgi.com/drupal/node/6?q=node/22#S8
		27  type recType uint8
		28  
		29  const (
		30  	typeBeginRequest		recType = 1
		31  	typeAbortRequest		recType = 2
		32  	typeEndRequest			recType = 3
		33  	typeParams					recType = 4
		34  	typeStdin					 recType = 5
		35  	typeStdout					recType = 6
		36  	typeStderr					recType = 7
		37  	typeData						recType = 8
		38  	typeGetValues			 recType = 9
		39  	typeGetValuesResult recType = 10
		40  	typeUnknownType		 recType = 11
		41  )
		42  
		43  // keep the connection between web-server and responder open after request
		44  const flagKeepConn = 1
		45  
		46  const (
		47  	maxWrite = 65535 // maximum record body
		48  	maxPad	 = 255
		49  )
		50  
		51  const (
		52  	roleResponder = iota + 1 // only Responders are implemented.
		53  	roleAuthorizer
		54  	roleFilter
		55  )
		56  
		57  const (
		58  	statusRequestComplete = iota
		59  	statusCantMultiplex
		60  	statusOverloaded
		61  	statusUnknownRole
		62  )
		63  
		64  type header struct {
		65  	Version			 uint8
		66  	Type					recType
		67  	Id						uint16
		68  	ContentLength uint16
		69  	PaddingLength uint8
		70  	Reserved			uint8
		71  }
		72  
		73  type beginRequest struct {
		74  	role		 uint16
		75  	flags		uint8
		76  	reserved [5]uint8
		77  }
		78  
		79  func (br *beginRequest) read(content []byte) error {
		80  	if len(content) != 8 {
		81  		return errors.New("fcgi: invalid begin request record")
		82  	}
		83  	br.role = binary.BigEndian.Uint16(content)
		84  	br.flags = content[2]
		85  	return nil
		86  }
		87  
		88  // for padding so we don't have to allocate all the time
		89  // not synchronized because we don't care what the contents are
		90  var pad [maxPad]byte
		91  
		92  func (h *header) init(recType recType, reqId uint16, contentLength int) {
		93  	h.Version = 1
		94  	h.Type = recType
		95  	h.Id = reqId
		96  	h.ContentLength = uint16(contentLength)
		97  	h.PaddingLength = uint8(-contentLength & 7)
		98  }
		99  
	 100  // conn sends records over rwc
	 101  type conn struct {
	 102  	mutex sync.Mutex
	 103  	rwc	 io.ReadWriteCloser
	 104  
	 105  	// to avoid allocations
	 106  	buf bytes.Buffer
	 107  	h	 header
	 108  }
	 109  
	 110  func newConn(rwc io.ReadWriteCloser) *conn {
	 111  	return &conn{rwc: rwc}
	 112  }
	 113  
	 114  func (c *conn) Close() error {
	 115  	c.mutex.Lock()
	 116  	defer c.mutex.Unlock()
	 117  	return c.rwc.Close()
	 118  }
	 119  
	 120  type record struct {
	 121  	h	 header
	 122  	buf [maxWrite + maxPad]byte
	 123  }
	 124  
	 125  func (rec *record) read(r io.Reader) (err error) {
	 126  	if err = binary.Read(r, binary.BigEndian, &rec.h); err != nil {
	 127  		return err
	 128  	}
	 129  	if rec.h.Version != 1 {
	 130  		return errors.New("fcgi: invalid header version")
	 131  	}
	 132  	n := int(rec.h.ContentLength) + int(rec.h.PaddingLength)
	 133  	if _, err = io.ReadFull(r, rec.buf[:n]); err != nil {
	 134  		return err
	 135  	}
	 136  	return nil
	 137  }
	 138  
	 139  func (r *record) content() []byte {
	 140  	return r.buf[:r.h.ContentLength]
	 141  }
	 142  
	 143  // writeRecord writes and sends a single record.
	 144  func (c *conn) writeRecord(recType recType, reqId uint16, b []byte) error {
	 145  	c.mutex.Lock()
	 146  	defer c.mutex.Unlock()
	 147  	c.buf.Reset()
	 148  	c.h.init(recType, reqId, len(b))
	 149  	if err := binary.Write(&c.buf, binary.BigEndian, c.h); err != nil {
	 150  		return err
	 151  	}
	 152  	if _, err := c.buf.Write(b); err != nil {
	 153  		return err
	 154  	}
	 155  	if _, err := c.buf.Write(pad[:c.h.PaddingLength]); err != nil {
	 156  		return err
	 157  	}
	 158  	_, err := c.rwc.Write(c.buf.Bytes())
	 159  	return err
	 160  }
	 161  
	 162  func (c *conn) writeEndRequest(reqId uint16, appStatus int, protocolStatus uint8) error {
	 163  	b := make([]byte, 8)
	 164  	binary.BigEndian.PutUint32(b, uint32(appStatus))
	 165  	b[4] = protocolStatus
	 166  	return c.writeRecord(typeEndRequest, reqId, b)
	 167  }
	 168  
	 169  func (c *conn) writePairs(recType recType, reqId uint16, pairs map[string]string) error {
	 170  	w := newWriter(c, recType, reqId)
	 171  	b := make([]byte, 8)
	 172  	for k, v := range pairs {
	 173  		n := encodeSize(b, uint32(len(k)))
	 174  		n += encodeSize(b[n:], uint32(len(v)))
	 175  		if _, err := w.Write(b[:n]); err != nil {
	 176  			return err
	 177  		}
	 178  		if _, err := w.WriteString(k); err != nil {
	 179  			return err
	 180  		}
	 181  		if _, err := w.WriteString(v); err != nil {
	 182  			return err
	 183  		}
	 184  	}
	 185  	w.Close()
	 186  	return nil
	 187  }
	 188  
	 189  func readSize(s []byte) (uint32, int) {
	 190  	if len(s) == 0 {
	 191  		return 0, 0
	 192  	}
	 193  	size, n := uint32(s[0]), 1
	 194  	if size&(1<<7) != 0 {
	 195  		if len(s) < 4 {
	 196  			return 0, 0
	 197  		}
	 198  		n = 4
	 199  		size = binary.BigEndian.Uint32(s)
	 200  		size &^= 1 << 31
	 201  	}
	 202  	return size, n
	 203  }
	 204  
	 205  func readString(s []byte, size uint32) string {
	 206  	if size > uint32(len(s)) {
	 207  		return ""
	 208  	}
	 209  	return string(s[:size])
	 210  }
	 211  
	 212  func encodeSize(b []byte, size uint32) int {
	 213  	if size > 127 {
	 214  		size |= 1 << 31
	 215  		binary.BigEndian.PutUint32(b, size)
	 216  		return 4
	 217  	}
	 218  	b[0] = byte(size)
	 219  	return 1
	 220  }
	 221  
	 222  // bufWriter encapsulates bufio.Writer but also closes the underlying stream when
	 223  // Closed.
	 224  type bufWriter struct {
	 225  	closer io.Closer
	 226  	*bufio.Writer
	 227  }
	 228  
	 229  func (w *bufWriter) Close() error {
	 230  	if err := w.Writer.Flush(); err != nil {
	 231  		w.closer.Close()
	 232  		return err
	 233  	}
	 234  	return w.closer.Close()
	 235  }
	 236  
	 237  func newWriter(c *conn, recType recType, reqId uint16) *bufWriter {
	 238  	s := &streamWriter{c: c, recType: recType, reqId: reqId}
	 239  	w := bufio.NewWriterSize(s, maxWrite)
	 240  	return &bufWriter{s, w}
	 241  }
	 242  
	 243  // streamWriter abstracts out the separation of a stream into discrete records.
	 244  // It only writes maxWrite bytes at a time.
	 245  type streamWriter struct {
	 246  	c			 *conn
	 247  	recType recType
	 248  	reqId	 uint16
	 249  }
	 250  
	 251  func (w *streamWriter) Write(p []byte) (int, error) {
	 252  	nn := 0
	 253  	for len(p) > 0 {
	 254  		n := len(p)
	 255  		if n > maxWrite {
	 256  			n = maxWrite
	 257  		}
	 258  		if err := w.c.writeRecord(w.recType, w.reqId, p[:n]); err != nil {
	 259  			return nn, err
	 260  		}
	 261  		nn += n
	 262  		p = p[n:]
	 263  	}
	 264  	return nn, nil
	 265  }
	 266  
	 267  func (w *streamWriter) Close() error {
	 268  	// send empty record to close the stream
	 269  	return w.c.writeRecord(w.recType, w.reqId, nil)
	 270  }
	 271
View as plain text