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