Source file src/pkg/net/http/fcgi/fcgi.go
1
2
3
4
5
6
7
8
9
10
11 package fcgi
12
13
14
15
16 import (
17 "bufio"
18 "bytes"
19 "encoding/binary"
20 "errors"
21 "io"
22 "sync"
23 )
24
25
26
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
44 const flagKeepConn = 1
45
46 const (
47 maxWrite = 65535
48 maxPad = 255
49 )
50
51 const (
52 roleResponder = iota + 1
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
89
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
101 type conn struct {
102 mutex sync.Mutex
103 rwc io.ReadWriteCloser
104
105
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
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
223
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
244
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
269 return w.c.writeRecord(w.recType, w.reqId, nil)
270 }
271
View as plain text