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