Source file
src/net/http/server.go
1
2
3
4
5
6
7 package http
8
9 import (
10 "bufio"
11 "bytes"
12 "context"
13 "crypto/tls"
14 "errors"
15 "fmt"
16 "io"
17 "io/ioutil"
18 "log"
19 "net"
20 "net/textproto"
21 "net/url"
22 urlpkg "net/url"
23 "os"
24 "path"
25 "runtime"
26 "sort"
27 "strconv"
28 "strings"
29 "sync"
30 "sync/atomic"
31 "time"
32
33 "golang.org/x/net/http/httpguts"
34 )
35
36
37 var (
38
39
40
41 ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")
42
43
44
45
46
47
48 ErrHijacked = errors.New("http: connection has been hijacked")
49
50
51
52
53
54 ErrContentLength = errors.New("http: wrote more than the declared Content-Length")
55
56
57
58
59 ErrWriteAfterFlush = errors.New("unused")
60 )
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86 type Handler interface {
87 ServeHTTP(ResponseWriter, *Request)
88 }
89
90
91
92
93
94
95 type ResponseWriter interface {
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116 Header() Header
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 Write([]byte) (int, error)
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154 WriteHeader(statusCode int)
155 }
156
157
158
159
160
161
162
163
164
165
166
167
168 type Flusher interface {
169
170 Flush()
171 }
172
173
174
175
176
177
178
179
180 type Hijacker interface {
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200 Hijack() (net.Conn, *bufio.ReadWriter, error)
201 }
202
203
204
205
206
207
208
209
210
211 type CloseNotifier interface {
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230 CloseNotify() <-chan bool
231 }
232
233 var (
234
235
236
237
238 ServerContextKey = &contextKey{"http-server"}
239
240
241
242
243
244 LocalAddrContextKey = &contextKey{"local-addr"}
245 )
246
247
248 type conn struct {
249
250
251 server *Server
252
253
254 cancelCtx context.CancelFunc
255
256
257
258
259
260 rwc net.Conn
261
262
263
264
265
266 remoteAddr string
267
268
269
270 tlsState *tls.ConnectionState
271
272
273
274 werr error
275
276
277
278
279 r *connReader
280
281
282 bufr *bufio.Reader
283
284
285 bufw *bufio.Writer
286
287
288
289 lastMethod string
290
291 curReq atomic.Value
292
293 curState struct{ atomic uint64 }
294
295
296 mu sync.Mutex
297
298
299
300
301 hijackedv bool
302 }
303
304 func (c *conn) hijacked() bool {
305 c.mu.Lock()
306 defer c.mu.Unlock()
307 return c.hijackedv
308 }
309
310
311 func (c *conn) hijackLocked() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
312 if c.hijackedv {
313 return nil, nil, ErrHijacked
314 }
315 c.r.abortPendingRead()
316
317 c.hijackedv = true
318 rwc = c.rwc
319 rwc.SetDeadline(time.Time{})
320
321 buf = bufio.NewReadWriter(c.bufr, bufio.NewWriter(rwc))
322 if c.r.hasByte {
323 if _, err := c.bufr.Peek(c.bufr.Buffered() + 1); err != nil {
324 return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
325 }
326 }
327 c.setState(rwc, StateHijacked)
328 return
329 }
330
331
332
333 const bufferBeforeChunkingSize = 2048
334
335
336
337
338
339
340
341
342
343
344 type chunkWriter struct {
345 res *response
346
347
348
349
350
351 header Header
352
353
354
355
356
357 wroteHeader bool
358
359
360 chunking bool
361 }
362
363 var (
364 crlf = []byte("\r\n")
365 colonSpace = []byte(": ")
366 )
367
368 func (cw *chunkWriter) Write(p []byte) (n int, err error) {
369 if !cw.wroteHeader {
370 cw.writeHeader(p)
371 }
372 if cw.res.req.Method == "HEAD" {
373
374 return len(p), nil
375 }
376 if cw.chunking {
377 _, err = fmt.Fprintf(cw.res.conn.bufw, "%x\r\n", len(p))
378 if err != nil {
379 cw.res.conn.rwc.Close()
380 return
381 }
382 }
383 n, err = cw.res.conn.bufw.Write(p)
384 if cw.chunking && err == nil {
385 _, err = cw.res.conn.bufw.Write(crlf)
386 }
387 if err != nil {
388 cw.res.conn.rwc.Close()
389 }
390 return
391 }
392
393 func (cw *chunkWriter) flush() {
394 if !cw.wroteHeader {
395 cw.writeHeader(nil)
396 }
397 cw.res.conn.bufw.Flush()
398 }
399
400 func (cw *chunkWriter) close() {
401 if !cw.wroteHeader {
402 cw.writeHeader(nil)
403 }
404 if cw.chunking {
405 bw := cw.res.conn.bufw
406
407 bw.WriteString("0\r\n")
408 if trailers := cw.res.finalTrailers(); trailers != nil {
409 trailers.Write(bw)
410 }
411
412
413 bw.WriteString("\r\n")
414 }
415 }
416
417
418 type response struct {
419 conn *conn
420 req *Request
421 reqBody io.ReadCloser
422 cancelCtx context.CancelFunc
423 wroteHeader bool
424 wroteContinue bool
425 wants10KeepAlive bool
426 wantsClose bool
427
428
429
430
431
432
433
434
435 canWriteContinue atomicBool
436 writeContinueMu sync.Mutex
437
438 w *bufio.Writer
439 cw chunkWriter
440
441
442
443
444
445 handlerHeader Header
446 calledHeader bool
447
448 written int64
449 contentLength int64
450 status int
451
452
453
454
455
456 closeAfterReply bool
457
458
459
460
461
462
463
464
465 requestBodyLimitHit bool
466
467
468
469
470
471 trailers []string
472
473 handlerDone atomicBool
474
475
476 dateBuf [len(TimeFormat)]byte
477 clenBuf [10]byte
478 statusBuf [3]byte
479
480
481
482
483 closeNotifyCh chan bool
484 didCloseNotify int32
485 }
486
487
488
489
490
491
492
493
494
495
496
497
498
499 const TrailerPrefix = "Trailer:"
500
501
502
503 func (w *response) finalTrailers() Header {
504 var t Header
505 for k, vv := range w.handlerHeader {
506 if strings.HasPrefix(k, TrailerPrefix) {
507 if t == nil {
508 t = make(Header)
509 }
510 t[strings.TrimPrefix(k, TrailerPrefix)] = vv
511 }
512 }
513 for _, k := range w.trailers {
514 if t == nil {
515 t = make(Header)
516 }
517 for _, v := range w.handlerHeader[k] {
518 t.Add(k, v)
519 }
520 }
521 return t
522 }
523
524 type atomicBool int32
525
526 func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
527 func (b *atomicBool) setTrue() { atomic.StoreInt32((*int32)(b), 1) }
528 func (b *atomicBool) setFalse() { atomic.StoreInt32((*int32)(b), 0) }
529
530
531
532
533 func (w *response) declareTrailer(k string) {
534 k = CanonicalHeaderKey(k)
535 if !httpguts.ValidTrailerHeader(k) {
536
537 return
538 }
539 w.trailers = append(w.trailers, k)
540 }
541
542
543
544 func (w *response) requestTooLarge() {
545 w.closeAfterReply = true
546 w.requestBodyLimitHit = true
547 if !w.wroteHeader {
548 w.Header().Set("Connection", "close")
549 }
550 }
551
552
553 func (w *response) needsSniff() bool {
554 _, haveType := w.handlerHeader["Content-Type"]
555 return !w.cw.wroteHeader && !haveType && w.written < sniffLen
556 }
557
558
559
560 type writerOnly struct {
561 io.Writer
562 }
563
564 func srcIsRegularFile(src io.Reader) (isRegular bool, err error) {
565 switch v := src.(type) {
566 case *os.File:
567 fi, err := v.Stat()
568 if err != nil {
569 return false, err
570 }
571 return fi.Mode().IsRegular(), nil
572 case *io.LimitedReader:
573 return srcIsRegularFile(v.R)
574 default:
575 return
576 }
577 }
578
579
580
581 func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
582
583
584
585 rf, ok := w.conn.rwc.(io.ReaderFrom)
586 regFile, err := srcIsRegularFile(src)
587 if err != nil {
588 return 0, err
589 }
590 if !ok || !regFile {
591 bufp := copyBufPool.Get().(*[]byte)
592 defer copyBufPool.Put(bufp)
593 return io.CopyBuffer(writerOnly{w}, src, *bufp)
594 }
595
596
597
598 if !w.wroteHeader {
599 w.WriteHeader(StatusOK)
600 }
601
602 if w.needsSniff() {
603 n0, err := io.Copy(writerOnly{w}, io.LimitReader(src, sniffLen))
604 n += n0
605 if err != nil {
606 return n, err
607 }
608 }
609
610 w.w.Flush()
611 w.cw.flush()
612
613
614 if !w.cw.chunking && w.bodyAllowed() {
615 n0, err := rf.ReadFrom(src)
616 n += n0
617 w.written += n0
618 return n, err
619 }
620
621 n0, err := io.Copy(writerOnly{w}, src)
622 n += n0
623 return n, err
624 }
625
626
627
628 const debugServerConnections = false
629
630
631 func (srv *Server) newConn(rwc net.Conn) *conn {
632 c := &conn{
633 server: srv,
634 rwc: rwc,
635 }
636 if debugServerConnections {
637 c.rwc = newLoggingConn("server", c.rwc)
638 }
639 return c
640 }
641
642 type readResult struct {
643 _ incomparable
644 n int
645 err error
646 b byte
647 }
648
649
650
651
652
653
654 type connReader struct {
655 conn *conn
656
657 mu sync.Mutex
658 hasByte bool
659 byteBuf [1]byte
660 cond *sync.Cond
661 inRead bool
662 aborted bool
663 remain int64
664 }
665
666 func (cr *connReader) lock() {
667 cr.mu.Lock()
668 if cr.cond == nil {
669 cr.cond = sync.NewCond(&cr.mu)
670 }
671 }
672
673 func (cr *connReader) unlock() { cr.mu.Unlock() }
674
675 func (cr *connReader) startBackgroundRead() {
676 cr.lock()
677 defer cr.unlock()
678 if cr.inRead {
679 panic("invalid concurrent Body.Read call")
680 }
681 if cr.hasByte {
682 return
683 }
684 cr.inRead = true
685 cr.conn.rwc.SetReadDeadline(time.Time{})
686 go cr.backgroundRead()
687 }
688
689 func (cr *connReader) backgroundRead() {
690 n, err := cr.conn.rwc.Read(cr.byteBuf[:])
691 cr.lock()
692 if n == 1 {
693 cr.hasByte = true
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716 }
717 if ne, ok := err.(net.Error); ok && cr.aborted && ne.Timeout() {
718
719
720 } else if err != nil {
721 cr.handleReadError(err)
722 }
723 cr.aborted = false
724 cr.inRead = false
725 cr.unlock()
726 cr.cond.Broadcast()
727 }
728
729 func (cr *connReader) abortPendingRead() {
730 cr.lock()
731 defer cr.unlock()
732 if !cr.inRead {
733 return
734 }
735 cr.aborted = true
736 cr.conn.rwc.SetReadDeadline(aLongTimeAgo)
737 for cr.inRead {
738 cr.cond.Wait()
739 }
740 cr.conn.rwc.SetReadDeadline(time.Time{})
741 }
742
743 func (cr *connReader) setReadLimit(remain int64) { cr.remain = remain }
744 func (cr *connReader) setInfiniteReadLimit() { cr.remain = maxInt64 }
745 func (cr *connReader) hitReadLimit() bool { return cr.remain <= 0 }
746
747
748
749
750
751
752
753
754
755
756
757 func (cr *connReader) handleReadError(_ error) {
758 cr.conn.cancelCtx()
759 cr.closeNotify()
760 }
761
762
763 func (cr *connReader) closeNotify() {
764 res, _ := cr.conn.curReq.Load().(*response)
765 if res != nil && atomic.CompareAndSwapInt32(&res.didCloseNotify, 0, 1) {
766 res.closeNotifyCh <- true
767 }
768 }
769
770 func (cr *connReader) Read(p []byte) (n int, err error) {
771 cr.lock()
772 if cr.inRead {
773 cr.unlock()
774 if cr.conn.hijacked() {
775 panic("invalid Body.Read call. After hijacked, the original Request must not be used")
776 }
777 panic("invalid concurrent Body.Read call")
778 }
779 if cr.hitReadLimit() {
780 cr.unlock()
781 return 0, io.EOF
782 }
783 if len(p) == 0 {
784 cr.unlock()
785 return 0, nil
786 }
787 if int64(len(p)) > cr.remain {
788 p = p[:cr.remain]
789 }
790 if cr.hasByte {
791 p[0] = cr.byteBuf[0]
792 cr.hasByte = false
793 cr.unlock()
794 return 1, nil
795 }
796 cr.inRead = true
797 cr.unlock()
798 n, err = cr.conn.rwc.Read(p)
799
800 cr.lock()
801 cr.inRead = false
802 if err != nil {
803 cr.handleReadError(err)
804 }
805 cr.remain -= int64(n)
806 cr.unlock()
807
808 cr.cond.Broadcast()
809 return n, err
810 }
811
812 var (
813 bufioReaderPool sync.Pool
814 bufioWriter2kPool sync.Pool
815 bufioWriter4kPool sync.Pool
816 )
817
818 var copyBufPool = sync.Pool{
819 New: func() interface{} {
820 b := make([]byte, 32*1024)
821 return &b
822 },
823 }
824
825 func bufioWriterPool(size int) *sync.Pool {
826 switch size {
827 case 2 << 10:
828 return &bufioWriter2kPool
829 case 4 << 10:
830 return &bufioWriter4kPool
831 }
832 return nil
833 }
834
835 func newBufioReader(r io.Reader) *bufio.Reader {
836 if v := bufioReaderPool.Get(); v != nil {
837 br := v.(*bufio.Reader)
838 br.Reset(r)
839 return br
840 }
841
842
843 return bufio.NewReader(r)
844 }
845
846 func putBufioReader(br *bufio.Reader) {
847 br.Reset(nil)
848 bufioReaderPool.Put(br)
849 }
850
851 func newBufioWriterSize(w io.Writer, size int) *bufio.Writer {
852 pool := bufioWriterPool(size)
853 if pool != nil {
854 if v := pool.Get(); v != nil {
855 bw := v.(*bufio.Writer)
856 bw.Reset(w)
857 return bw
858 }
859 }
860 return bufio.NewWriterSize(w, size)
861 }
862
863 func putBufioWriter(bw *bufio.Writer) {
864 bw.Reset(nil)
865 if pool := bufioWriterPool(bw.Available()); pool != nil {
866 pool.Put(bw)
867 }
868 }
869
870
871
872
873 const DefaultMaxHeaderBytes = 1 << 20
874
875 func (srv *Server) maxHeaderBytes() int {
876 if srv.MaxHeaderBytes > 0 {
877 return srv.MaxHeaderBytes
878 }
879 return DefaultMaxHeaderBytes
880 }
881
882 func (srv *Server) initialReadLimitSize() int64 {
883 return int64(srv.maxHeaderBytes()) + 4096
884 }
885
886
887
888 type expectContinueReader struct {
889 resp *response
890 readCloser io.ReadCloser
891 closed bool
892 sawEOF atomicBool
893 }
894
895 func (ecr *expectContinueReader) Read(p []byte) (n int, err error) {
896 if ecr.closed {
897 return 0, ErrBodyReadAfterClose
898 }
899 w := ecr.resp
900 if !w.wroteContinue && w.canWriteContinue.isSet() && !w.conn.hijacked() {
901 w.wroteContinue = true
902 w.writeContinueMu.Lock()
903 if w.canWriteContinue.isSet() {
904 w.conn.bufw.WriteString("HTTP/1.1 100 Continue\r\n\r\n")
905 w.conn.bufw.Flush()
906 w.canWriteContinue.setFalse()
907 }
908 w.writeContinueMu.Unlock()
909 }
910 n, err = ecr.readCloser.Read(p)
911 if err == io.EOF {
912 ecr.sawEOF.setTrue()
913 }
914 return
915 }
916
917 func (ecr *expectContinueReader) Close() error {
918 ecr.closed = true
919 return ecr.readCloser.Close()
920 }
921
922
923
924
925
926
927
928 const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
929
930
931 func appendTime(b []byte, t time.Time) []byte {
932 const days = "SunMonTueWedThuFriSat"
933 const months = "JanFebMarAprMayJunJulAugSepOctNovDec"
934
935 t = t.UTC()
936 yy, mm, dd := t.Date()
937 hh, mn, ss := t.Clock()
938 day := days[3*t.Weekday():]
939 mon := months[3*(mm-1):]
940
941 return append(b,
942 day[0], day[1], day[2], ',', ' ',
943 byte('0'+dd/10), byte('0'+dd%10), ' ',
944 mon[0], mon[1], mon[2], ' ',
945 byte('0'+yy/1000), byte('0'+(yy/100)%10), byte('0'+(yy/10)%10), byte('0'+yy%10), ' ',
946 byte('0'+hh/10), byte('0'+hh%10), ':',
947 byte('0'+mn/10), byte('0'+mn%10), ':',
948 byte('0'+ss/10), byte('0'+ss%10), ' ',
949 'G', 'M', 'T')
950 }
951
952 var errTooLarge = errors.New("http: request too large")
953
954
955 func (c *conn) readRequest(ctx context.Context) (w *response, err error) {
956 if c.hijacked() {
957 return nil, ErrHijacked
958 }
959
960 var (
961 wholeReqDeadline time.Time
962 hdrDeadline time.Time
963 )
964 t0 := time.Now()
965 if d := c.server.readHeaderTimeout(); d != 0 {
966 hdrDeadline = t0.Add(d)
967 }
968 if d := c.server.ReadTimeout; d != 0 {
969 wholeReqDeadline = t0.Add(d)
970 }
971 c.rwc.SetReadDeadline(hdrDeadline)
972 if d := c.server.WriteTimeout; d != 0 {
973 defer func() {
974 c.rwc.SetWriteDeadline(time.Now().Add(d))
975 }()
976 }
977
978 c.r.setReadLimit(c.server.initialReadLimitSize())
979 if c.lastMethod == "POST" {
980
981 peek, _ := c.bufr.Peek(4)
982 c.bufr.Discard(numLeadingCRorLF(peek))
983 }
984 req, err := readRequest(c.bufr, keepHostHeader)
985 if err != nil {
986 if c.r.hitReadLimit() {
987 return nil, errTooLarge
988 }
989 return nil, err
990 }
991
992 if !http1ServerSupportsRequest(req) {
993 return nil, badRequestError("unsupported protocol version")
994 }
995
996 c.lastMethod = req.Method
997 c.r.setInfiniteReadLimit()
998
999 hosts, haveHost := req.Header["Host"]
1000 isH2Upgrade := req.isH2Upgrade()
1001 if req.ProtoAtLeast(1, 1) && (!haveHost || len(hosts) == 0) && !isH2Upgrade && req.Method != "CONNECT" {
1002 return nil, badRequestError("missing required Host header")
1003 }
1004 if len(hosts) > 1 {
1005 return nil, badRequestError("too many Host headers")
1006 }
1007 if len(hosts) == 1 && !httpguts.ValidHostHeader(hosts[0]) {
1008 return nil, badRequestError("malformed Host header")
1009 }
1010 for k, vv := range req.Header {
1011 if !httpguts.ValidHeaderFieldName(k) {
1012 return nil, badRequestError("invalid header name")
1013 }
1014 for _, v := range vv {
1015 if !httpguts.ValidHeaderFieldValue(v) {
1016 return nil, badRequestError("invalid header value")
1017 }
1018 }
1019 }
1020 delete(req.Header, "Host")
1021
1022 ctx, cancelCtx := context.WithCancel(ctx)
1023 req.ctx = ctx
1024 req.RemoteAddr = c.remoteAddr
1025 req.TLS = c.tlsState
1026 if body, ok := req.Body.(*body); ok {
1027 body.doEarlyClose = true
1028 }
1029
1030
1031 if !hdrDeadline.Equal(wholeReqDeadline) {
1032 c.rwc.SetReadDeadline(wholeReqDeadline)
1033 }
1034
1035 w = &response{
1036 conn: c,
1037 cancelCtx: cancelCtx,
1038 req: req,
1039 reqBody: req.Body,
1040 handlerHeader: make(Header),
1041 contentLength: -1,
1042 closeNotifyCh: make(chan bool, 1),
1043
1044
1045
1046
1047 wants10KeepAlive: req.wantsHttp10KeepAlive(),
1048 wantsClose: req.wantsClose(),
1049 }
1050 if isH2Upgrade {
1051 w.closeAfterReply = true
1052 }
1053 w.cw.res = w
1054 w.w = newBufioWriterSize(&w.cw, bufferBeforeChunkingSize)
1055 return w, nil
1056 }
1057
1058
1059
1060 func http1ServerSupportsRequest(req *Request) bool {
1061 if req.ProtoMajor == 1 {
1062 return true
1063 }
1064
1065
1066 if req.ProtoMajor == 2 && req.ProtoMinor == 0 &&
1067 req.Method == "PRI" && req.RequestURI == "*" {
1068 return true
1069 }
1070
1071
1072 return false
1073 }
1074
1075 func (w *response) Header() Header {
1076 if w.cw.header == nil && w.wroteHeader && !w.cw.wroteHeader {
1077
1078
1079
1080 w.cw.header = w.handlerHeader.Clone()
1081 }
1082 w.calledHeader = true
1083 return w.handlerHeader
1084 }
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095 const maxPostHandlerReadBytes = 256 << 10
1096
1097 func checkWriteHeaderCode(code int) {
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109 if code < 100 || code > 999 {
1110 panic(fmt.Sprintf("invalid WriteHeader code %v", code))
1111 }
1112 }
1113
1114
1115
1116 func relevantCaller() runtime.Frame {
1117 pc := make([]uintptr, 16)
1118 n := runtime.Callers(1, pc)
1119 frames := runtime.CallersFrames(pc[:n])
1120 var frame runtime.Frame
1121 for {
1122 frame, more := frames.Next()
1123 if !strings.HasPrefix(frame.Function, "net/http.") {
1124 return frame
1125 }
1126 if !more {
1127 break
1128 }
1129 }
1130 return frame
1131 }
1132
1133 func (w *response) WriteHeader(code int) {
1134 if w.conn.hijacked() {
1135 caller := relevantCaller()
1136 w.conn.server.logf("http: response.WriteHeader on hijacked connection from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
1137 return
1138 }
1139 if w.wroteHeader {
1140 caller := relevantCaller()
1141 w.conn.server.logf("http: superfluous response.WriteHeader call from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
1142 return
1143 }
1144 checkWriteHeaderCode(code)
1145 w.wroteHeader = true
1146 w.status = code
1147
1148 if w.calledHeader && w.cw.header == nil {
1149 w.cw.header = w.handlerHeader.Clone()
1150 }
1151
1152 if cl := w.handlerHeader.get("Content-Length"); cl != "" {
1153 v, err := strconv.ParseInt(cl, 10, 64)
1154 if err == nil && v >= 0 {
1155 w.contentLength = v
1156 } else {
1157 w.conn.server.logf("http: invalid Content-Length of %q", cl)
1158 w.handlerHeader.Del("Content-Length")
1159 }
1160 }
1161 }
1162
1163
1164
1165
1166 type extraHeader struct {
1167 contentType string
1168 connection string
1169 transferEncoding string
1170 date []byte
1171 contentLength []byte
1172 }
1173
1174
1175 var extraHeaderKeys = [][]byte{
1176 []byte("Content-Type"),
1177 []byte("Connection"),
1178 []byte("Transfer-Encoding"),
1179 }
1180
1181 var (
1182 headerContentLength = []byte("Content-Length: ")
1183 headerDate = []byte("Date: ")
1184 )
1185
1186
1187
1188
1189
1190
1191 func (h extraHeader) Write(w *bufio.Writer) {
1192 if h.date != nil {
1193 w.Write(headerDate)
1194 w.Write(h.date)
1195 w.Write(crlf)
1196 }
1197 if h.contentLength != nil {
1198 w.Write(headerContentLength)
1199 w.Write(h.contentLength)
1200 w.Write(crlf)
1201 }
1202 for i, v := range []string{h.contentType, h.connection, h.transferEncoding} {
1203 if v != "" {
1204 w.Write(extraHeaderKeys[i])
1205 w.Write(colonSpace)
1206 w.WriteString(v)
1207 w.Write(crlf)
1208 }
1209 }
1210 }
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220 func (cw *chunkWriter) writeHeader(p []byte) {
1221 if cw.wroteHeader {
1222 return
1223 }
1224 cw.wroteHeader = true
1225
1226 w := cw.res
1227 keepAlivesEnabled := w.conn.server.doKeepAlives()
1228 isHEAD := w.req.Method == "HEAD"
1229
1230
1231
1232
1233
1234
1235 header := cw.header
1236 owned := header != nil
1237 if !owned {
1238 header = w.handlerHeader
1239 }
1240 var excludeHeader map[string]bool
1241 delHeader := func(key string) {
1242 if owned {
1243 header.Del(key)
1244 return
1245 }
1246 if _, ok := header[key]; !ok {
1247 return
1248 }
1249 if excludeHeader == nil {
1250 excludeHeader = make(map[string]bool)
1251 }
1252 excludeHeader[key] = true
1253 }
1254 var setHeader extraHeader
1255
1256
1257 trailers := false
1258 for k := range cw.header {
1259 if strings.HasPrefix(k, TrailerPrefix) {
1260 if excludeHeader == nil {
1261 excludeHeader = make(map[string]bool)
1262 }
1263 excludeHeader[k] = true
1264 trailers = true
1265 }
1266 }
1267 for _, v := range cw.header["Trailer"] {
1268 trailers = true
1269 foreachHeaderElement(v, cw.res.declareTrailer)
1270 }
1271
1272 te := header.get("Transfer-Encoding")
1273 hasTE := te != ""
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289 if w.handlerDone.isSet() && !trailers && !hasTE && bodyAllowedForStatus(w.status) && header.get("Content-Length") == "" && (!isHEAD || len(p) > 0) {
1290 w.contentLength = int64(len(p))
1291 setHeader.contentLength = strconv.AppendInt(cw.res.clenBuf[:0], int64(len(p)), 10)
1292 }
1293
1294
1295
1296 if w.wants10KeepAlive && keepAlivesEnabled {
1297 sentLength := header.get("Content-Length") != ""
1298 if sentLength && header.get("Connection") == "keep-alive" {
1299 w.closeAfterReply = false
1300 }
1301 }
1302
1303
1304 hasCL := w.contentLength != -1
1305
1306 if w.wants10KeepAlive && (isHEAD || hasCL || !bodyAllowedForStatus(w.status)) {
1307 _, connectionHeaderSet := header["Connection"]
1308 if !connectionHeaderSet {
1309 setHeader.connection = "keep-alive"
1310 }
1311 } else if !w.req.ProtoAtLeast(1, 1) || w.wantsClose {
1312 w.closeAfterReply = true
1313 }
1314
1315 if header.get("Connection") == "close" || !keepAlivesEnabled {
1316 w.closeAfterReply = true
1317 }
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331 if ecr, ok := w.req.Body.(*expectContinueReader); ok && !ecr.sawEOF.isSet() {
1332 w.closeAfterReply = true
1333 }
1334
1335
1336
1337
1338
1339
1340
1341
1342 if w.req.ContentLength != 0 && !w.closeAfterReply {
1343 var discard, tooBig bool
1344
1345 switch bdy := w.req.Body.(type) {
1346 case *expectContinueReader:
1347 if bdy.resp.wroteContinue {
1348 discard = true
1349 }
1350 case *body:
1351 bdy.mu.Lock()
1352 switch {
1353 case bdy.closed:
1354 if !bdy.sawEOF {
1355
1356 w.closeAfterReply = true
1357 }
1358 case bdy.unreadDataSizeLocked() >= maxPostHandlerReadBytes:
1359 tooBig = true
1360 default:
1361 discard = true
1362 }
1363 bdy.mu.Unlock()
1364 default:
1365 discard = true
1366 }
1367
1368 if discard {
1369 _, err := io.CopyN(ioutil.Discard, w.reqBody, maxPostHandlerReadBytes+1)
1370 switch err {
1371 case nil:
1372
1373 tooBig = true
1374 case ErrBodyReadAfterClose:
1375
1376 case io.EOF:
1377
1378 err = w.reqBody.Close()
1379 if err != nil {
1380 w.closeAfterReply = true
1381 }
1382 default:
1383
1384
1385
1386 w.closeAfterReply = true
1387 }
1388 }
1389
1390 if tooBig {
1391 w.requestTooLarge()
1392 delHeader("Connection")
1393 setHeader.connection = "close"
1394 }
1395 }
1396
1397 code := w.status
1398 if bodyAllowedForStatus(code) {
1399
1400 _, haveType := header["Content-Type"]
1401
1402
1403
1404 ce := header.Get("Content-Encoding")
1405 hasCE := len(ce) > 0
1406 if !hasCE && !haveType && !hasTE && len(p) > 0 {
1407 setHeader.contentType = DetectContentType(p)
1408 }
1409 } else {
1410 for _, k := range suppressedHeaders(code) {
1411 delHeader(k)
1412 }
1413 }
1414
1415 if !header.has("Date") {
1416 setHeader.date = appendTime(cw.res.dateBuf[:0], time.Now())
1417 }
1418
1419 if hasCL && hasTE && te != "identity" {
1420
1421
1422 w.conn.server.logf("http: WriteHeader called with both Transfer-Encoding of %q and a Content-Length of %d",
1423 te, w.contentLength)
1424 delHeader("Content-Length")
1425 hasCL = false
1426 }
1427
1428 if w.req.Method == "HEAD" || !bodyAllowedForStatus(code) {
1429
1430 } else if code == StatusNoContent {
1431 delHeader("Transfer-Encoding")
1432 } else if hasCL {
1433 delHeader("Transfer-Encoding")
1434 } else if w.req.ProtoAtLeast(1, 1) {
1435
1436
1437
1438
1439
1440 if hasTE && te == "identity" {
1441 cw.chunking = false
1442 w.closeAfterReply = true
1443 } else {
1444
1445
1446 cw.chunking = true
1447 setHeader.transferEncoding = "chunked"
1448 if hasTE && te == "chunked" {
1449
1450 delHeader("Transfer-Encoding")
1451 }
1452 }
1453 } else {
1454
1455
1456
1457 w.closeAfterReply = true
1458 delHeader("Transfer-Encoding")
1459 }
1460
1461
1462 if cw.chunking {
1463 delHeader("Content-Length")
1464 }
1465 if !w.req.ProtoAtLeast(1, 0) {
1466 return
1467 }
1468
1469 if w.closeAfterReply && (!keepAlivesEnabled || !hasToken(cw.header.get("Connection"), "close")) {
1470 delHeader("Connection")
1471 if w.req.ProtoAtLeast(1, 1) {
1472 setHeader.connection = "close"
1473 }
1474 }
1475
1476 writeStatusLine(w.conn.bufw, w.req.ProtoAtLeast(1, 1), code, w.statusBuf[:])
1477 cw.header.WriteSubset(w.conn.bufw, excludeHeader)
1478 setHeader.Write(w.conn.bufw)
1479 w.conn.bufw.Write(crlf)
1480 }
1481
1482
1483
1484 func foreachHeaderElement(v string, fn func(string)) {
1485 v = textproto.TrimString(v)
1486 if v == "" {
1487 return
1488 }
1489 if !strings.Contains(v, ",") {
1490 fn(v)
1491 return
1492 }
1493 for _, f := range strings.Split(v, ",") {
1494 if f = textproto.TrimString(f); f != "" {
1495 fn(f)
1496 }
1497 }
1498 }
1499
1500
1501
1502
1503
1504 func writeStatusLine(bw *bufio.Writer, is11 bool, code int, scratch []byte) {
1505 if is11 {
1506 bw.WriteString("HTTP/1.1 ")
1507 } else {
1508 bw.WriteString("HTTP/1.0 ")
1509 }
1510 if text, ok := statusText[code]; ok {
1511 bw.Write(strconv.AppendInt(scratch[:0], int64(code), 10))
1512 bw.WriteByte(' ')
1513 bw.WriteString(text)
1514 bw.WriteString("\r\n")
1515 } else {
1516
1517 fmt.Fprintf(bw, "%03d status code %d\r\n", code, code)
1518 }
1519 }
1520
1521
1522
1523 func (w *response) bodyAllowed() bool {
1524 if !w.wroteHeader {
1525 panic("")
1526 }
1527 return bodyAllowedForStatus(w.status)
1528 }
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564 func (w *response) Write(data []byte) (n int, err error) {
1565 return w.write(len(data), data, "")
1566 }
1567
1568 func (w *response) WriteString(data string) (n int, err error) {
1569 return w.write(len(data), nil, data)
1570 }
1571
1572
1573 func (w *response) write(lenData int, dataB []byte, dataS string) (n int, err error) {
1574 if w.conn.hijacked() {
1575 if lenData > 0 {
1576 caller := relevantCaller()
1577 w.conn.server.logf("http: response.Write on hijacked connection from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
1578 }
1579 return 0, ErrHijacked
1580 }
1581
1582 if w.canWriteContinue.isSet() {
1583
1584
1585
1586
1587 w.writeContinueMu.Lock()
1588 w.canWriteContinue.setFalse()
1589 w.writeContinueMu.Unlock()
1590 }
1591
1592 if !w.wroteHeader {
1593 w.WriteHeader(StatusOK)
1594 }
1595 if lenData == 0 {
1596 return 0, nil
1597 }
1598 if !w.bodyAllowed() {
1599 return 0, ErrBodyNotAllowed
1600 }
1601
1602 w.written += int64(lenData)
1603 if w.contentLength != -1 && w.written > w.contentLength {
1604 return 0, ErrContentLength
1605 }
1606 if dataB != nil {
1607 return w.w.Write(dataB)
1608 } else {
1609 return w.w.WriteString(dataS)
1610 }
1611 }
1612
1613 func (w *response) finishRequest() {
1614 w.handlerDone.setTrue()
1615
1616 if !w.wroteHeader {
1617 w.WriteHeader(StatusOK)
1618 }
1619
1620 w.w.Flush()
1621 putBufioWriter(w.w)
1622 w.cw.close()
1623 w.conn.bufw.Flush()
1624
1625 w.conn.r.abortPendingRead()
1626
1627
1628
1629 w.reqBody.Close()
1630
1631 if w.req.MultipartForm != nil {
1632 w.req.MultipartForm.RemoveAll()
1633 }
1634 }
1635
1636
1637
1638 func (w *response) shouldReuseConnection() bool {
1639 if w.closeAfterReply {
1640
1641
1642
1643 return false
1644 }
1645
1646 if w.req.Method != "HEAD" && w.contentLength != -1 && w.bodyAllowed() && w.contentLength != w.written {
1647
1648 return false
1649 }
1650
1651
1652
1653 if w.conn.werr != nil {
1654 return false
1655 }
1656
1657 if w.closedRequestBodyEarly() {
1658 return false
1659 }
1660
1661 return true
1662 }
1663
1664 func (w *response) closedRequestBodyEarly() bool {
1665 body, ok := w.req.Body.(*body)
1666 return ok && body.didEarlyClose()
1667 }
1668
1669 func (w *response) Flush() {
1670 if !w.wroteHeader {
1671 w.WriteHeader(StatusOK)
1672 }
1673 w.w.Flush()
1674 w.cw.flush()
1675 }
1676
1677 func (c *conn) finalFlush() {
1678 if c.bufr != nil {
1679
1680
1681 putBufioReader(c.bufr)
1682 c.bufr = nil
1683 }
1684
1685 if c.bufw != nil {
1686 c.bufw.Flush()
1687
1688
1689 putBufioWriter(c.bufw)
1690 c.bufw = nil
1691 }
1692 }
1693
1694
1695 func (c *conn) close() {
1696 c.finalFlush()
1697 c.rwc.Close()
1698 }
1699
1700
1701
1702
1703
1704
1705
1706
1707 const rstAvoidanceDelay = 500 * time.Millisecond
1708
1709 type closeWriter interface {
1710 CloseWrite() error
1711 }
1712
1713 var _ closeWriter = (*net.TCPConn)(nil)
1714
1715
1716
1717
1718
1719
1720
1721 func (c *conn) closeWriteAndWait() {
1722 c.finalFlush()
1723 if tcp, ok := c.rwc.(closeWriter); ok {
1724 tcp.CloseWrite()
1725 }
1726 time.Sleep(rstAvoidanceDelay)
1727 }
1728
1729
1730
1731
1732 func validNextProto(proto string) bool {
1733 switch proto {
1734 case "", "http/1.1", "http/1.0":
1735 return false
1736 }
1737 return true
1738 }
1739
1740 func (c *conn) setState(nc net.Conn, state ConnState) {
1741 srv := c.server
1742 switch state {
1743 case StateNew:
1744 srv.trackConn(c, true)
1745 case StateHijacked, StateClosed:
1746 srv.trackConn(c, false)
1747 }
1748 if state > 0xff || state < 0 {
1749 panic("internal error")
1750 }
1751 packedState := uint64(time.Now().Unix()<<8) | uint64(state)
1752 atomic.StoreUint64(&c.curState.atomic, packedState)
1753 if hook := srv.ConnState; hook != nil {
1754 hook(nc, state)
1755 }
1756 }
1757
1758 func (c *conn) getState() (state ConnState, unixSec int64) {
1759 packedState := atomic.LoadUint64(&c.curState.atomic)
1760 return ConnState(packedState & 0xff), int64(packedState >> 8)
1761 }
1762
1763
1764
1765
1766 type badRequestError string
1767
1768 func (e badRequestError) Error() string { return "Bad Request: " + string(e) }
1769
1770
1771
1772
1773
1774 var ErrAbortHandler = errors.New("net/http: abort Handler")
1775
1776
1777
1778
1779
1780 func isCommonNetReadError(err error) bool {
1781 if err == io.EOF {
1782 return true
1783 }
1784 if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
1785 return true
1786 }
1787 if oe, ok := err.(*net.OpError); ok && oe.Op == "read" {
1788 return true
1789 }
1790 return false
1791 }
1792
1793
1794 func (c *conn) serve(ctx context.Context) {
1795 c.remoteAddr = c.rwc.RemoteAddr().String()
1796 ctx = context.WithValue(ctx, LocalAddrContextKey, c.rwc.LocalAddr())
1797 defer func() {
1798 if err := recover(); err != nil && err != ErrAbortHandler {
1799 const size = 64 << 10
1800 buf := make([]byte, size)
1801 buf = buf[:runtime.Stack(buf, false)]
1802 c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
1803 }
1804 if !c.hijacked() {
1805 c.close()
1806 c.setState(c.rwc, StateClosed)
1807 }
1808 }()
1809
1810 if tlsConn, ok := c.rwc.(*tls.Conn); ok {
1811 if d := c.server.ReadTimeout; d != 0 {
1812 c.rwc.SetReadDeadline(time.Now().Add(d))
1813 }
1814 if d := c.server.WriteTimeout; d != 0 {
1815 c.rwc.SetWriteDeadline(time.Now().Add(d))
1816 }
1817 if err := tlsConn.Handshake(); err != nil {
1818
1819
1820
1821 if re, ok := err.(tls.RecordHeaderError); ok && re.Conn != nil && tlsRecordHeaderLooksLikeHTTP(re.RecordHeader) {
1822 io.WriteString(re.Conn, "HTTP/1.0 400 Bad Request\r\n\r\nClient sent an HTTP request to an HTTPS server.\n")
1823 re.Conn.Close()
1824 return
1825 }
1826 c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
1827 return
1828 }
1829 c.tlsState = new(tls.ConnectionState)
1830 *c.tlsState = tlsConn.ConnectionState()
1831 if proto := c.tlsState.NegotiatedProtocol; validNextProto(proto) {
1832 if fn := c.server.TLSNextProto[proto]; fn != nil {
1833 h := initALPNRequest{ctx, tlsConn, serverHandler{c.server}}
1834 fn(c.server, tlsConn, h)
1835 }
1836 return
1837 }
1838 }
1839
1840
1841
1842 ctx, cancelCtx := context.WithCancel(ctx)
1843 c.cancelCtx = cancelCtx
1844 defer cancelCtx()
1845
1846 c.r = &connReader{conn: c}
1847 c.bufr = newBufioReader(c.r)
1848 c.bufw = newBufioWriterSize(checkConnErrorWriter{c}, 4<<10)
1849
1850 for {
1851 w, err := c.readRequest(ctx)
1852 if c.r.remain != c.server.initialReadLimitSize() {
1853
1854 c.setState(c.rwc, StateActive)
1855 }
1856 if err != nil {
1857 const errorHeaders = "\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: close\r\n\r\n"
1858
1859 switch {
1860 case err == errTooLarge:
1861
1862
1863
1864
1865
1866 const publicErr = "431 Request Header Fields Too Large"
1867 fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
1868 c.closeWriteAndWait()
1869 return
1870
1871 case isUnsupportedTEError(err):
1872
1873
1874
1875
1876 code := StatusNotImplemented
1877
1878
1879
1880 fmt.Fprintf(c.rwc, "HTTP/1.1 %d %s%sUnsupported transfer encoding", code, StatusText(code), errorHeaders)
1881 return
1882
1883 case isCommonNetReadError(err):
1884 return
1885
1886 default:
1887 publicErr := "400 Bad Request"
1888 if v, ok := err.(badRequestError); ok {
1889 publicErr = publicErr + ": " + string(v)
1890 }
1891
1892 fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
1893 return
1894 }
1895 }
1896
1897
1898 req := w.req
1899 if req.expectsContinue() {
1900 if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
1901
1902 req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
1903 w.canWriteContinue.setTrue()
1904 }
1905 } else if req.Header.get("Expect") != "" {
1906 w.sendExpectationFailed()
1907 return
1908 }
1909
1910 c.curReq.Store(w)
1911
1912 if requestBodyRemains(req.Body) {
1913 registerOnHitEOF(req.Body, w.conn.r.startBackgroundRead)
1914 } else {
1915 w.conn.r.startBackgroundRead()
1916 }
1917
1918
1919
1920
1921
1922
1923
1924
1925 serverHandler{c.server}.ServeHTTP(w, w.req)
1926 w.cancelCtx()
1927 if c.hijacked() {
1928 return
1929 }
1930 w.finishRequest()
1931 if !w.shouldReuseConnection() {
1932 if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
1933 c.closeWriteAndWait()
1934 }
1935 return
1936 }
1937 c.setState(c.rwc, StateIdle)
1938 c.curReq.Store((*response)(nil))
1939
1940 if !w.conn.server.doKeepAlives() {
1941
1942
1943
1944
1945 return
1946 }
1947
1948 if d := c.server.idleTimeout(); d != 0 {
1949 c.rwc.SetReadDeadline(time.Now().Add(d))
1950 if _, err := c.bufr.Peek(4); err != nil {
1951 return
1952 }
1953 }
1954 c.rwc.SetReadDeadline(time.Time{})
1955 }
1956 }
1957
1958 func (w *response) sendExpectationFailed() {
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971 w.Header().Set("Connection", "close")
1972 w.WriteHeader(StatusExpectationFailed)
1973 w.finishRequest()
1974 }
1975
1976
1977
1978 func (w *response) Hijack() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
1979 if w.handlerDone.isSet() {
1980 panic("net/http: Hijack called after ServeHTTP finished")
1981 }
1982 if w.wroteHeader {
1983 w.cw.flush()
1984 }
1985
1986 c := w.conn
1987 c.mu.Lock()
1988 defer c.mu.Unlock()
1989
1990
1991
1992 rwc, buf, err = c.hijackLocked()
1993 if err == nil {
1994 putBufioWriter(w.w)
1995 w.w = nil
1996 }
1997 return rwc, buf, err
1998 }
1999
2000 func (w *response) CloseNotify() <-chan bool {
2001 if w.handlerDone.isSet() {
2002 panic("net/http: CloseNotify called after ServeHTTP finished")
2003 }
2004 return w.closeNotifyCh
2005 }
2006
2007 func registerOnHitEOF(rc io.ReadCloser, fn func()) {
2008 switch v := rc.(type) {
2009 case *expectContinueReader:
2010 registerOnHitEOF(v.readCloser, fn)
2011 case *body:
2012 v.registerOnHitEOF(fn)
2013 default:
2014 panic("unexpected type " + fmt.Sprintf("%T", rc))
2015 }
2016 }
2017
2018
2019
2020 func requestBodyRemains(rc io.ReadCloser) bool {
2021 if rc == NoBody {
2022 return false
2023 }
2024 switch v := rc.(type) {
2025 case *expectContinueReader:
2026 return requestBodyRemains(v.readCloser)
2027 case *body:
2028 return v.bodyRemains()
2029 default:
2030 panic("unexpected type " + fmt.Sprintf("%T", rc))
2031 }
2032 }
2033
2034
2035
2036
2037
2038 type HandlerFunc func(ResponseWriter, *Request)
2039
2040
2041 func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
2042 f(w, r)
2043 }
2044
2045
2046
2047
2048
2049
2050
2051 func Error(w ResponseWriter, error string, code int) {
2052 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
2053 w.Header().Set("X-Content-Type-Options", "nosniff")
2054 w.WriteHeader(code)
2055 fmt.Fprintln(w, error)
2056 }
2057
2058
2059 func NotFound(w ResponseWriter, r *Request) { Error(w, "404 page not found", StatusNotFound) }
2060
2061
2062
2063 func NotFoundHandler() Handler { return HandlerFunc(NotFound) }
2064
2065
2066
2067
2068
2069
2070 func StripPrefix(prefix string, h Handler) Handler {
2071 if prefix == "" {
2072 return h
2073 }
2074 return HandlerFunc(func(w ResponseWriter, r *Request) {
2075 if p := strings.TrimPrefix(r.URL.Path, prefix); len(p) < len(r.URL.Path) {
2076 r2 := new(Request)
2077 *r2 = *r
2078 r2.URL = new(url.URL)
2079 *r2.URL = *r.URL
2080 r2.URL.Path = p
2081 h.ServeHTTP(w, r2)
2082 } else {
2083 NotFound(w, r)
2084 }
2085 })
2086 }
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098 func Redirect(w ResponseWriter, r *Request, url string, code int) {
2099 if u, err := urlpkg.Parse(url); err == nil {
2100
2101
2102
2103
2104
2105 if u.Scheme == "" && u.Host == "" {
2106 oldpath := r.URL.Path
2107 if oldpath == "" {
2108 oldpath = "/"
2109 }
2110
2111
2112 if url == "" || url[0] != '/' {
2113
2114 olddir, _ := path.Split(oldpath)
2115 url = olddir + url
2116 }
2117
2118 var query string
2119 if i := strings.Index(url, "?"); i != -1 {
2120 url, query = url[:i], url[i:]
2121 }
2122
2123
2124 trailing := strings.HasSuffix(url, "/")
2125 url = path.Clean(url)
2126 if trailing && !strings.HasSuffix(url, "/") {
2127 url += "/"
2128 }
2129 url += query
2130 }
2131 }
2132
2133 h := w.Header()
2134
2135
2136
2137
2138 _, hadCT := h["Content-Type"]
2139
2140 h.Set("Location", hexEscapeNonASCII(url))
2141 if !hadCT && (r.Method == "GET" || r.Method == "HEAD") {
2142 h.Set("Content-Type", "text/html; charset=utf-8")
2143 }
2144 w.WriteHeader(code)
2145
2146
2147 if !hadCT && r.Method == "GET" {
2148 body := "<a href=\"" + htmlEscape(url) + "\">" + statusText[code] + "</a>.\n"
2149 fmt.Fprintln(w, body)
2150 }
2151 }
2152
2153 var htmlReplacer = strings.NewReplacer(
2154 "&", "&",
2155 "<", "<",
2156 ">", ">",
2157
2158 `"`, """,
2159
2160 "'", "'",
2161 )
2162
2163 func htmlEscape(s string) string {
2164 return htmlReplacer.Replace(s)
2165 }
2166
2167
2168 type redirectHandler struct {
2169 url string
2170 code int
2171 }
2172
2173 func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
2174 Redirect(w, r, rh.url, rh.code)
2175 }
2176
2177
2178
2179
2180
2181
2182
2183 func RedirectHandler(url string, code int) Handler {
2184 return &redirectHandler{url, code}
2185 }
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222 type ServeMux struct {
2223 mu sync.RWMutex
2224 m map[string]muxEntry
2225 es []muxEntry
2226 hosts bool
2227 }
2228
2229 type muxEntry struct {
2230 h Handler
2231 pattern string
2232 }
2233
2234
2235 func NewServeMux() *ServeMux { return new(ServeMux) }
2236
2237
2238 var DefaultServeMux = &defaultServeMux
2239
2240 var defaultServeMux ServeMux
2241
2242
2243 func cleanPath(p string) string {
2244 if p == "" {
2245 return "/"
2246 }
2247 if p[0] != '/' {
2248 p = "/" + p
2249 }
2250 np := path.Clean(p)
2251
2252
2253 if p[len(p)-1] == '/' && np != "/" {
2254
2255 if len(p) == len(np)+1 && strings.HasPrefix(p, np) {
2256 np = p
2257 } else {
2258 np += "/"
2259 }
2260 }
2261 return np
2262 }
2263
2264
2265 func stripHostPort(h string) string {
2266
2267 if strings.IndexByte(h, ':') == -1 {
2268 return h
2269 }
2270 host, _, err := net.SplitHostPort(h)
2271 if err != nil {
2272 return h
2273 }
2274 return host
2275 }
2276
2277
2278
2279 func (mux *ServeMux) match(path string) (h Handler, pattern string) {
2280
2281 v, ok := mux.m[path]
2282 if ok {
2283 return v.h, v.pattern
2284 }
2285
2286
2287
2288 for _, e := range mux.es {
2289 if strings.HasPrefix(path, e.pattern) {
2290 return e.h, e.pattern
2291 }
2292 }
2293 return nil, ""
2294 }
2295
2296
2297
2298
2299
2300 func (mux *ServeMux) redirectToPathSlash(host, path string, u *url.URL) (*url.URL, bool) {
2301 mux.mu.RLock()
2302 shouldRedirect := mux.shouldRedirectRLocked(host, path)
2303 mux.mu.RUnlock()
2304 if !shouldRedirect {
2305 return u, false
2306 }
2307 path = path + "/"
2308 u = &url.URL{Path: path, RawQuery: u.RawQuery}
2309 return u, true
2310 }
2311
2312
2313
2314
2315 func (mux *ServeMux) shouldRedirectRLocked(host, path string) bool {
2316 p := []string{path, host + path}
2317
2318 for _, c := range p {
2319 if _, exist := mux.m[c]; exist {
2320 return false
2321 }
2322 }
2323
2324 n := len(path)
2325 if n == 0 {
2326 return false
2327 }
2328 for _, c := range p {
2329 if _, exist := mux.m[c+"/"]; exist {
2330 return path[n-1] != '/'
2331 }
2332 }
2333
2334 return false
2335 }
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352 func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
2353
2354
2355 if r.Method == "CONNECT" {
2356
2357
2358
2359 if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
2360 return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
2361 }
2362
2363 return mux.handler(r.Host, r.URL.Path)
2364 }
2365
2366
2367
2368 host := stripHostPort(r.Host)
2369 path := cleanPath(r.URL.Path)
2370
2371
2372
2373 if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
2374 return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
2375 }
2376
2377 if path != r.URL.Path {
2378 _, pattern = mux.handler(host, path)
2379 url := *r.URL
2380 url.Path = path
2381 return RedirectHandler(url.String(), StatusMovedPermanently), pattern
2382 }
2383
2384 return mux.handler(host, r.URL.Path)
2385 }
2386
2387
2388
2389 func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
2390 mux.mu.RLock()
2391 defer mux.mu.RUnlock()
2392
2393
2394 if mux.hosts {
2395 h, pattern = mux.match(host + path)
2396 }
2397 if h == nil {
2398 h, pattern = mux.match(path)
2399 }
2400 if h == nil {
2401 h, pattern = NotFoundHandler(), ""
2402 }
2403 return
2404 }
2405
2406
2407
2408 func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
2409 if r.RequestURI == "*" {
2410 if r.ProtoAtLeast(1, 1) {
2411 w.Header().Set("Connection", "close")
2412 }
2413 w.WriteHeader(StatusBadRequest)
2414 return
2415 }
2416 h, _ := mux.Handler(r)
2417 h.ServeHTTP(w, r)
2418 }
2419
2420
2421
2422 func (mux *ServeMux) Handle(pattern string, handler Handler) {
2423 mux.mu.Lock()
2424 defer mux.mu.Unlock()
2425
2426 if pattern == "" {
2427 panic("http: invalid pattern")
2428 }
2429 if handler == nil {
2430 panic("http: nil handler")
2431 }
2432 if _, exist := mux.m[pattern]; exist {
2433 panic("http: multiple registrations for " + pattern)
2434 }
2435
2436 if mux.m == nil {
2437 mux.m = make(map[string]muxEntry)
2438 }
2439 e := muxEntry{h: handler, pattern: pattern}
2440 mux.m[pattern] = e
2441 if pattern[len(pattern)-1] == '/' {
2442 mux.es = appendSorted(mux.es, e)
2443 }
2444
2445 if pattern[0] != '/' {
2446 mux.hosts = true
2447 }
2448 }
2449
2450 func appendSorted(es []muxEntry, e muxEntry) []muxEntry {
2451 n := len(es)
2452 i := sort.Search(n, func(i int) bool {
2453 return len(es[i].pattern) < len(e.pattern)
2454 })
2455 if i == n {
2456 return append(es, e)
2457 }
2458
2459 es = append(es, muxEntry{})
2460 copy(es[i+1:], es[i:])
2461 es[i] = e
2462 return es
2463 }
2464
2465
2466 func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
2467 if handler == nil {
2468 panic("http: nil handler")
2469 }
2470 mux.Handle(pattern, HandlerFunc(handler))
2471 }
2472
2473
2474
2475
2476 func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
2477
2478
2479
2480
2481 func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
2482 DefaultServeMux.HandleFunc(pattern, handler)
2483 }
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496 func Serve(l net.Listener, handler Handler) error {
2497 srv := &Server{Handler: handler}
2498 return srv.Serve(l)
2499 }
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513 func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error {
2514 srv := &Server{Handler: handler}
2515 return srv.ServeTLS(l, certFile, keyFile)
2516 }
2517
2518
2519
2520 type Server struct {
2521
2522
2523
2524
2525 Addr string
2526
2527 Handler Handler
2528
2529
2530
2531
2532
2533
2534
2535
2536 TLSConfig *tls.Config
2537
2538
2539
2540
2541
2542
2543
2544
2545 ReadTimeout time.Duration
2546
2547
2548
2549
2550
2551
2552
2553 ReadHeaderTimeout time.Duration
2554
2555
2556
2557
2558
2559 WriteTimeout time.Duration
2560
2561
2562
2563
2564
2565 IdleTimeout time.Duration
2566
2567
2568
2569
2570
2571
2572 MaxHeaderBytes int
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583 TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
2584
2585
2586
2587
2588 ConnState func(net.Conn, ConnState)
2589
2590
2591
2592
2593
2594 ErrorLog *log.Logger
2595
2596
2597
2598
2599
2600
2601
2602 BaseContext func(net.Listener) context.Context
2603
2604
2605
2606
2607
2608 ConnContext func(ctx context.Context, c net.Conn) context.Context
2609
2610 inShutdown atomicBool
2611
2612 disableKeepAlives int32
2613 nextProtoOnce sync.Once
2614 nextProtoErr error
2615
2616 mu sync.Mutex
2617 listeners map[*net.Listener]struct{}
2618 activeConn map[*conn]struct{}
2619 doneChan chan struct{}
2620 onShutdown []func()
2621 }
2622
2623 func (s *Server) getDoneChan() <-chan struct{} {
2624 s.mu.Lock()
2625 defer s.mu.Unlock()
2626 return s.getDoneChanLocked()
2627 }
2628
2629 func (s *Server) getDoneChanLocked() chan struct{} {
2630 if s.doneChan == nil {
2631 s.doneChan = make(chan struct{})
2632 }
2633 return s.doneChan
2634 }
2635
2636 func (s *Server) closeDoneChanLocked() {
2637 ch := s.getDoneChanLocked()
2638 select {
2639 case <-ch:
2640
2641 default:
2642
2643
2644 close(ch)
2645 }
2646 }
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657 func (srv *Server) Close() error {
2658 srv.inShutdown.setTrue()
2659 srv.mu.Lock()
2660 defer srv.mu.Unlock()
2661 srv.closeDoneChanLocked()
2662 err := srv.closeListenersLocked()
2663 for c := range srv.activeConn {
2664 c.rwc.Close()
2665 delete(srv.activeConn, c)
2666 }
2667 return err
2668 }
2669
2670
2671
2672
2673
2674
2675
2676
2677 var shutdownPollInterval = 500 * time.Millisecond
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699 func (srv *Server) Shutdown(ctx context.Context) error {
2700 srv.inShutdown.setTrue()
2701
2702 srv.mu.Lock()
2703 lnerr := srv.closeListenersLocked()
2704 srv.closeDoneChanLocked()
2705 for _, f := range srv.onShutdown {
2706 go f()
2707 }
2708 srv.mu.Unlock()
2709
2710 ticker := time.NewTicker(shutdownPollInterval)
2711 defer ticker.Stop()
2712 for {
2713 if srv.closeIdleConns() && srv.numListeners() == 0 {
2714 return lnerr
2715 }
2716 select {
2717 case <-ctx.Done():
2718 return ctx.Err()
2719 case <-ticker.C:
2720 }
2721 }
2722 }
2723
2724
2725
2726
2727
2728
2729 func (srv *Server) RegisterOnShutdown(f func()) {
2730 srv.mu.Lock()
2731 srv.onShutdown = append(srv.onShutdown, f)
2732 srv.mu.Unlock()
2733 }
2734
2735 func (s *Server) numListeners() int {
2736 s.mu.Lock()
2737 defer s.mu.Unlock()
2738 return len(s.listeners)
2739 }
2740
2741
2742
2743 func (s *Server) closeIdleConns() bool {
2744 s.mu.Lock()
2745 defer s.mu.Unlock()
2746 quiescent := true
2747 for c := range s.activeConn {
2748 st, unixSec := c.getState()
2749
2750
2751
2752 if st == StateNew && unixSec < time.Now().Unix()-5 {
2753 st = StateIdle
2754 }
2755 if st != StateIdle || unixSec == 0 {
2756
2757
2758 quiescent = false
2759 continue
2760 }
2761 c.rwc.Close()
2762 delete(s.activeConn, c)
2763 }
2764 return quiescent
2765 }
2766
2767 func (s *Server) closeListenersLocked() error {
2768 var err error
2769 for ln := range s.listeners {
2770 if cerr := (*ln).Close(); cerr != nil && err == nil {
2771 err = cerr
2772 }
2773 }
2774 return err
2775 }
2776
2777
2778
2779 type ConnState int
2780
2781 const (
2782
2783
2784
2785
2786 StateNew ConnState = iota
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799 StateActive
2800
2801
2802
2803
2804
2805 StateIdle
2806
2807
2808
2809 StateHijacked
2810
2811
2812
2813
2814 StateClosed
2815 )
2816
2817 var stateName = map[ConnState]string{
2818 StateNew: "new",
2819 StateActive: "active",
2820 StateIdle: "idle",
2821 StateHijacked: "hijacked",
2822 StateClosed: "closed",
2823 }
2824
2825 func (c ConnState) String() string {
2826 return stateName[c]
2827 }
2828
2829
2830
2831 type serverHandler struct {
2832 srv *Server
2833 }
2834
2835 func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
2836 handler := sh.srv.Handler
2837 if handler == nil {
2838 handler = DefaultServeMux
2839 }
2840 if req.RequestURI == "*" && req.Method == "OPTIONS" {
2841 handler = globalOptionsHandler{}
2842 }
2843 handler.ServeHTTP(rw, req)
2844 }
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854 func (srv *Server) ListenAndServe() error {
2855 if srv.shuttingDown() {
2856 return ErrServerClosed
2857 }
2858 addr := srv.Addr
2859 if addr == "" {
2860 addr = ":http"
2861 }
2862 ln, err := net.Listen("tcp", addr)
2863 if err != nil {
2864 return err
2865 }
2866 return srv.Serve(ln)
2867 }
2868
2869 var testHookServerServe func(*Server, net.Listener)
2870
2871
2872
2873 func (srv *Server) shouldConfigureHTTP2ForServe() bool {
2874 if srv.TLSConfig == nil {
2875
2876
2877
2878
2879
2880
2881 return true
2882 }
2883
2884
2885
2886
2887
2888
2889
2890 return strSliceContains(srv.TLSConfig.NextProtos, http2NextProtoTLS)
2891 }
2892
2893
2894
2895 var ErrServerClosed = errors.New("http: Server closed")
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907 func (srv *Server) Serve(l net.Listener) error {
2908 if fn := testHookServerServe; fn != nil {
2909 fn(srv, l)
2910 }
2911
2912 origListener := l
2913 l = &onceCloseListener{Listener: l}
2914 defer l.Close()
2915
2916 if err := srv.setupHTTP2_Serve(); err != nil {
2917 return err
2918 }
2919
2920 if !srv.trackListener(&l, true) {
2921 return ErrServerClosed
2922 }
2923 defer srv.trackListener(&l, false)
2924
2925 baseCtx := context.Background()
2926 if srv.BaseContext != nil {
2927 baseCtx = srv.BaseContext(origListener)
2928 if baseCtx == nil {
2929 panic("BaseContext returned a nil context")
2930 }
2931 }
2932
2933 var tempDelay time.Duration
2934
2935 ctx := context.WithValue(baseCtx, ServerContextKey, srv)
2936 for {
2937 rw, err := l.Accept()
2938 if err != nil {
2939 select {
2940 case <-srv.getDoneChan():
2941 return ErrServerClosed
2942 default:
2943 }
2944 if ne, ok := err.(net.Error); ok && ne.Temporary() {
2945 if tempDelay == 0 {
2946 tempDelay = 5 * time.Millisecond
2947 } else {
2948 tempDelay *= 2
2949 }
2950 if max := 1 * time.Second; tempDelay > max {
2951 tempDelay = max
2952 }
2953 srv.logf("http: Accept error: %v; retrying in %v", err, tempDelay)
2954 time.Sleep(tempDelay)
2955 continue
2956 }
2957 return err
2958 }
2959 connCtx := ctx
2960 if cc := srv.ConnContext; cc != nil {
2961 connCtx = cc(connCtx, rw)
2962 if connCtx == nil {
2963 panic("ConnContext returned nil")
2964 }
2965 }
2966 tempDelay = 0
2967 c := srv.newConn(rw)
2968 c.setState(c.rwc, StateNew)
2969 go c.serve(connCtx)
2970 }
2971 }
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986 func (srv *Server) ServeTLS(l net.Listener, certFile, keyFile string) error {
2987
2988
2989 if err := srv.setupHTTP2_ServeTLS(); err != nil {
2990 return err
2991 }
2992
2993 config := cloneTLSConfig(srv.TLSConfig)
2994 if !strSliceContains(config.NextProtos, "http/1.1") {
2995 config.NextProtos = append(config.NextProtos, "http/1.1")
2996 }
2997
2998 configHasCert := len(config.Certificates) > 0 || config.GetCertificate != nil
2999 if !configHasCert || certFile != "" || keyFile != "" {
3000 var err error
3001 config.Certificates = make([]tls.Certificate, 1)
3002 config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
3003 if err != nil {
3004 return err
3005 }
3006 }
3007
3008 tlsListener := tls.NewListener(l, config)
3009 return srv.Serve(tlsListener)
3010 }
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022 func (s *Server) trackListener(ln *net.Listener, add bool) bool {
3023 s.mu.Lock()
3024 defer s.mu.Unlock()
3025 if s.listeners == nil {
3026 s.listeners = make(map[*net.Listener]struct{})
3027 }
3028 if add {
3029 if s.shuttingDown() {
3030 return false
3031 }
3032 s.listeners[ln] = struct{}{}
3033 } else {
3034 delete(s.listeners, ln)
3035 }
3036 return true
3037 }
3038
3039 func (s *Server) trackConn(c *conn, add bool) {
3040 s.mu.Lock()
3041 defer s.mu.Unlock()
3042 if s.activeConn == nil {
3043 s.activeConn = make(map[*conn]struct{})
3044 }
3045 if add {
3046 s.activeConn[c] = struct{}{}
3047 } else {
3048 delete(s.activeConn, c)
3049 }
3050 }
3051
3052 func (s *Server) idleTimeout() time.Duration {
3053 if s.IdleTimeout != 0 {
3054 return s.IdleTimeout
3055 }
3056 return s.ReadTimeout
3057 }
3058
3059 func (s *Server) readHeaderTimeout() time.Duration {
3060 if s.ReadHeaderTimeout != 0 {
3061 return s.ReadHeaderTimeout
3062 }
3063 return s.ReadTimeout
3064 }
3065
3066 func (s *Server) doKeepAlives() bool {
3067 return atomic.LoadInt32(&s.disableKeepAlives) == 0 && !s.shuttingDown()
3068 }
3069
3070 func (s *Server) shuttingDown() bool {
3071 return s.inShutdown.isSet()
3072 }
3073
3074
3075
3076
3077
3078 func (srv *Server) SetKeepAlivesEnabled(v bool) {
3079 if v {
3080 atomic.StoreInt32(&srv.disableKeepAlives, 0)
3081 return
3082 }
3083 atomic.StoreInt32(&srv.disableKeepAlives, 1)
3084
3085
3086 srv.closeIdleConns()
3087
3088
3089 }
3090
3091 func (s *Server) logf(format string, args ...interface{}) {
3092 if s.ErrorLog != nil {
3093 s.ErrorLog.Printf(format, args...)
3094 } else {
3095 log.Printf(format, args...)
3096 }
3097 }
3098
3099
3100
3101
3102 func logf(r *Request, format string, args ...interface{}) {
3103 s, _ := r.Context().Value(ServerContextKey).(*Server)
3104 if s != nil && s.ErrorLog != nil {
3105 s.ErrorLog.Printf(format, args...)
3106 } else {
3107 log.Printf(format, args...)
3108 }
3109 }
3110
3111
3112
3113
3114
3115
3116
3117
3118 func ListenAndServe(addr string, handler Handler) error {
3119 server := &Server{Addr: addr, Handler: handler}
3120 return server.ListenAndServe()
3121 }
3122
3123
3124
3125
3126
3127
3128 func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error {
3129 server := &Server{Addr: addr, Handler: handler}
3130 return server.ListenAndServeTLS(certFile, keyFile)
3131 }
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148 func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
3149 if srv.shuttingDown() {
3150 return ErrServerClosed
3151 }
3152 addr := srv.Addr
3153 if addr == "" {
3154 addr = ":https"
3155 }
3156
3157 ln, err := net.Listen("tcp", addr)
3158 if err != nil {
3159 return err
3160 }
3161
3162 defer ln.Close()
3163
3164 return srv.ServeTLS(ln, certFile, keyFile)
3165 }
3166
3167
3168
3169
3170 func (srv *Server) setupHTTP2_ServeTLS() error {
3171 srv.nextProtoOnce.Do(srv.onceSetNextProtoDefaults)
3172 return srv.nextProtoErr
3173 }
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183 func (srv *Server) setupHTTP2_Serve() error {
3184 srv.nextProtoOnce.Do(srv.onceSetNextProtoDefaults_Serve)
3185 return srv.nextProtoErr
3186 }
3187
3188 func (srv *Server) onceSetNextProtoDefaults_Serve() {
3189 if srv.shouldConfigureHTTP2ForServe() {
3190 srv.onceSetNextProtoDefaults()
3191 }
3192 }
3193
3194
3195
3196
3197 func (srv *Server) onceSetNextProtoDefaults() {
3198 if omitBundledHTTP2 || strings.Contains(os.Getenv("GODEBUG"), "http2server=0") {
3199 return
3200 }
3201
3202
3203 if srv.TLSNextProto == nil {
3204 conf := &http2Server{
3205 NewWriteScheduler: func() http2WriteScheduler { return http2NewPriorityWriteScheduler(nil) },
3206 }
3207 srv.nextProtoErr = http2ConfigureServer(srv, conf)
3208 }
3209 }
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222 func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
3223 return &timeoutHandler{
3224 handler: h,
3225 body: msg,
3226 dt: dt,
3227 }
3228 }
3229
3230
3231
3232 var ErrHandlerTimeout = errors.New("http: Handler timeout")
3233
3234 type timeoutHandler struct {
3235 handler Handler
3236 body string
3237 dt time.Duration
3238
3239
3240
3241 testContext context.Context
3242 }
3243
3244 func (h *timeoutHandler) errorBody() string {
3245 if h.body != "" {
3246 return h.body
3247 }
3248 return "<html><head><title>Timeout</title></head><body><h1>Timeout</h1></body></html>"
3249 }
3250
3251 func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) {
3252 ctx := h.testContext
3253 if ctx == nil {
3254 var cancelCtx context.CancelFunc
3255 ctx, cancelCtx = context.WithTimeout(r.Context(), h.dt)
3256 defer cancelCtx()
3257 }
3258 r = r.WithContext(ctx)
3259 done := make(chan struct{})
3260 tw := &timeoutWriter{
3261 w: w,
3262 h: make(Header),
3263 req: r,
3264 }
3265 panicChan := make(chan interface{}, 1)
3266 go func() {
3267 defer func() {
3268 if p := recover(); p != nil {
3269 panicChan <- p
3270 }
3271 }()
3272 h.handler.ServeHTTP(tw, r)
3273 close(done)
3274 }()
3275 select {
3276 case p := <-panicChan:
3277 panic(p)
3278 case <-done:
3279 tw.mu.Lock()
3280 defer tw.mu.Unlock()
3281 dst := w.Header()
3282 for k, vv := range tw.h {
3283 dst[k] = vv
3284 }
3285 if !tw.wroteHeader {
3286 tw.code = StatusOK
3287 }
3288 w.WriteHeader(tw.code)
3289 w.Write(tw.wbuf.Bytes())
3290 case <-ctx.Done():
3291 tw.mu.Lock()
3292 defer tw.mu.Unlock()
3293 w.WriteHeader(StatusServiceUnavailable)
3294 io.WriteString(w, h.errorBody())
3295 tw.timedOut = true
3296 }
3297 }
3298
3299 type timeoutWriter struct {
3300 w ResponseWriter
3301 h Header
3302 wbuf bytes.Buffer
3303 req *Request
3304
3305 mu sync.Mutex
3306 timedOut bool
3307 wroteHeader bool
3308 code int
3309 }
3310
3311 var _ Pusher = (*timeoutWriter)(nil)
3312
3313
3314 func (tw *timeoutWriter) Push(target string, opts *PushOptions) error {
3315 if pusher, ok := tw.w.(Pusher); ok {
3316 return pusher.Push(target, opts)
3317 }
3318 return ErrNotSupported
3319 }
3320
3321 func (tw *timeoutWriter) Header() Header { return tw.h }
3322
3323 func (tw *timeoutWriter) Write(p []byte) (int, error) {
3324 tw.mu.Lock()
3325 defer tw.mu.Unlock()
3326 if tw.timedOut {
3327 return 0, ErrHandlerTimeout
3328 }
3329 if !tw.wroteHeader {
3330 tw.writeHeaderLocked(StatusOK)
3331 }
3332 return tw.wbuf.Write(p)
3333 }
3334
3335 func (tw *timeoutWriter) writeHeaderLocked(code int) {
3336 checkWriteHeaderCode(code)
3337
3338 switch {
3339 case tw.timedOut:
3340 return
3341 case tw.wroteHeader:
3342 if tw.req != nil {
3343 caller := relevantCaller()
3344 logf(tw.req, "http: superfluous response.WriteHeader call from %s (%s:%d)", caller.Function, path.Base(caller.File), caller.Line)
3345 }
3346 default:
3347 tw.wroteHeader = true
3348 tw.code = code
3349 }
3350 }
3351
3352 func (tw *timeoutWriter) WriteHeader(code int) {
3353 tw.mu.Lock()
3354 defer tw.mu.Unlock()
3355 tw.writeHeaderLocked(code)
3356 }
3357
3358
3359
3360 type onceCloseListener struct {
3361 net.Listener
3362 once sync.Once
3363 closeErr error
3364 }
3365
3366 func (oc *onceCloseListener) Close() error {
3367 oc.once.Do(oc.close)
3368 return oc.closeErr
3369 }
3370
3371 func (oc *onceCloseListener) close() { oc.closeErr = oc.Listener.Close() }
3372
3373
3374 type globalOptionsHandler struct{}
3375
3376 func (globalOptionsHandler) ServeHTTP(w ResponseWriter, r *Request) {
3377 w.Header().Set("Content-Length", "0")
3378 if r.ContentLength != 0 {
3379
3380
3381
3382
3383
3384 mb := MaxBytesReader(w, r.Body, 4<<10)
3385 io.Copy(ioutil.Discard, mb)
3386 }
3387 }
3388
3389
3390
3391
3392 type initALPNRequest struct {
3393 ctx context.Context
3394 c *tls.Conn
3395 h serverHandler
3396 }
3397
3398
3399
3400
3401
3402 func (h initALPNRequest) BaseContext() context.Context { return h.ctx }
3403
3404 func (h initALPNRequest) ServeHTTP(rw ResponseWriter, req *Request) {
3405 if req.TLS == nil {
3406 req.TLS = &tls.ConnectionState{}
3407 *req.TLS = h.c.ConnectionState()
3408 }
3409 if req.Body == nil {
3410 req.Body = NoBody
3411 }
3412 if req.RemoteAddr == "" {
3413 req.RemoteAddr = h.c.RemoteAddr().String()
3414 }
3415 h.h.ServeHTTP(rw, req)
3416 }
3417
3418
3419 type loggingConn struct {
3420 name string
3421 net.Conn
3422 }
3423
3424 var (
3425 uniqNameMu sync.Mutex
3426 uniqNameNext = make(map[string]int)
3427 )
3428
3429 func newLoggingConn(baseName string, c net.Conn) net.Conn {
3430 uniqNameMu.Lock()
3431 defer uniqNameMu.Unlock()
3432 uniqNameNext[baseName]++
3433 return &loggingConn{
3434 name: fmt.Sprintf("%s-%d", baseName, uniqNameNext[baseName]),
3435 Conn: c,
3436 }
3437 }
3438
3439 func (c *loggingConn) Write(p []byte) (n int, err error) {
3440 log.Printf("%s.Write(%d) = ....", c.name, len(p))
3441 n, err = c.Conn.Write(p)
3442 log.Printf("%s.Write(%d) = %d, %v", c.name, len(p), n, err)
3443 return
3444 }
3445
3446 func (c *loggingConn) Read(p []byte) (n int, err error) {
3447 log.Printf("%s.Read(%d) = ....", c.name, len(p))
3448 n, err = c.Conn.Read(p)
3449 log.Printf("%s.Read(%d) = %d, %v", c.name, len(p), n, err)
3450 return
3451 }
3452
3453 func (c *loggingConn) Close() (err error) {
3454 log.Printf("%s.Close() = ...", c.name)
3455 err = c.Conn.Close()
3456 log.Printf("%s.Close() = %v", c.name, err)
3457 return
3458 }
3459
3460
3461
3462
3463 type checkConnErrorWriter struct {
3464 c *conn
3465 }
3466
3467 func (w checkConnErrorWriter) Write(p []byte) (n int, err error) {
3468 n, err = w.c.rwc.Write(p)
3469 if err != nil && w.c.werr == nil {
3470 w.c.werr = err
3471 w.c.cancelCtx()
3472 }
3473 return
3474 }
3475
3476 func numLeadingCRorLF(v []byte) (n int) {
3477 for _, b := range v {
3478 if b == '\r' || b == '\n' {
3479 n++
3480 continue
3481 }
3482 break
3483 }
3484 return
3485
3486 }
3487
3488 func strSliceContains(ss []string, s string) bool {
3489 for _, v := range ss {
3490 if v == s {
3491 return true
3492 }
3493 }
3494 return false
3495 }
3496
3497
3498
3499 func tlsRecordHeaderLooksLikeHTTP(hdr [5]byte) bool {
3500 switch string(hdr[:]) {
3501 case "GET /", "HEAD ", "POST ", "PUT /", "OPTIO":
3502 return true
3503 }
3504 return false
3505 }
3506
View as plain text