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