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