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