Source file src/pkg/net/http/httputil/dump.go
1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package httputil 6 7 import ( 8 "bufio" 9 "bytes" 10 "fmt" 11 "io" 12 "io/ioutil" 13 "net" 14 "net/http" 15 "net/url" 16 "strings" 17 "time" 18 ) 19 20 // One of the copies, say from b to r2, could be avoided by using a more 21 // elaborate trick where the other copy is made during Request/Response.Write. 22 // This would complicate things too much, given that these functions are for 23 // debugging only. 24 func drainBody(b io.ReadCloser) (r1, r2 io.ReadCloser, err error) { 25 var buf bytes.Buffer 26 if _, err = buf.ReadFrom(b); err != nil { 27 return nil, nil, err 28 } 29 if err = b.Close(); err != nil { 30 return nil, nil, err 31 } 32 return ioutil.NopCloser(&buf), ioutil.NopCloser(bytes.NewBuffer(buf.Bytes())), nil 33 } 34 35 // dumpConn is a net.Conn which writes to Writer and reads from Reader 36 type dumpConn struct { 37 io.Writer 38 io.Reader 39 } 40 41 func (c *dumpConn) Close() error { return nil } 42 func (c *dumpConn) LocalAddr() net.Addr { return nil } 43 func (c *dumpConn) RemoteAddr() net.Addr { return nil } 44 func (c *dumpConn) SetDeadline(t time.Time) error { return nil } 45 func (c *dumpConn) SetReadDeadline(t time.Time) error { return nil } 46 func (c *dumpConn) SetWriteDeadline(t time.Time) error { return nil } 47 48 // DumpRequestOut is like DumpRequest but includes 49 // headers that the standard http.Transport adds, 50 // such as User-Agent. 51 func DumpRequestOut(req *http.Request, body bool) ([]byte, error) { 52 save := req.Body 53 if !body || req.Body == nil { 54 req.Body = nil 55 } else { 56 var err error 57 save, req.Body, err = drainBody(req.Body) 58 if err != nil { 59 return nil, err 60 } 61 } 62 63 // Since we're using the actual Transport code to write the request, 64 // switch to http so the Transport doesn't try to do an SSL 65 // negotiation with our dumpConn and its bytes.Buffer & pipe. 66 // The wire format for https and http are the same, anyway. 67 reqSend := req 68 if req.URL.Scheme == "https" { 69 reqSend = new(http.Request) 70 *reqSend = *req 71 reqSend.URL = new(url.URL) 72 *reqSend.URL = *req.URL 73 reqSend.URL.Scheme = "http" 74 } 75 76 // Use the actual Transport code to record what we would send 77 // on the wire, but not using TCP. Use a Transport with a 78 // customer dialer that returns a fake net.Conn that waits 79 // for the full input (and recording it), and then responds 80 // with a dummy response. 81 var buf bytes.Buffer // records the output 82 pr, pw := io.Pipe() 83 dr := &delegateReader{c: make(chan io.Reader)} 84 // Wait for the request before replying with a dummy response: 85 go func() { 86 http.ReadRequest(bufio.NewReader(pr)) 87 dr.c <- strings.NewReader("HTTP/1.1 204 No Content\r\n\r\n") 88 }() 89 90 t := &http.Transport{ 91 Dial: func(net, addr string) (net.Conn, error) { 92 return &dumpConn{io.MultiWriter(pw, &buf), dr}, nil 93 }, 94 } 95 96 _, err := t.RoundTrip(reqSend) 97 98 req.Body = save 99 if err != nil { 100 return nil, err 101 } 102 return buf.Bytes(), nil 103 } 104 105 // delegateReader is a reader that delegates to another reader, 106 // once it arrives on a channel. 107 type delegateReader struct { 108 c chan io.Reader 109 r io.Reader // nil until received from c 110 } 111 112 func (r *delegateReader) Read(p []byte) (int, error) { 113 if r.r == nil { 114 r.r = <-r.c 115 } 116 return r.r.Read(p) 117 } 118 119 // Return value if nonempty, def otherwise. 120 func valueOrDefault(value, def string) string { 121 if value != "" { 122 return value 123 } 124 return def 125 } 126 127 var reqWriteExcludeHeaderDump = map[string]bool{ 128 "Host": true, // not in Header map anyway 129 "Content-Length": true, 130 "Transfer-Encoding": true, 131 "Trailer": true, 132 } 133 134 // dumpAsReceived writes req to w in the form as it was received, or 135 // at least as accurately as possible from the information retained in 136 // the request. 137 func dumpAsReceived(req *http.Request, w io.Writer) error { 138 return nil 139 } 140 141 // DumpRequest returns the as-received wire representation of req, 142 // optionally including the request body, for debugging. 143 // DumpRequest is semantically a no-op, but in order to 144 // dump the body, it reads the body data into memory and 145 // changes req.Body to refer to the in-memory copy. 146 // The documentation for http.Request.Write details which fields 147 // of req are used. 148 func DumpRequest(req *http.Request, body bool) (dump []byte, err error) { 149 save := req.Body 150 if !body || req.Body == nil { 151 req.Body = nil 152 } else { 153 save, req.Body, err = drainBody(req.Body) 154 if err != nil { 155 return 156 } 157 } 158 159 var b bytes.Buffer 160 161 fmt.Fprintf(&b, "%s %s HTTP/%d.%d\r\n", valueOrDefault(req.Method, "GET"), 162 req.URL.RequestURI(), req.ProtoMajor, req.ProtoMinor) 163 164 host := req.Host 165 if host == "" && req.URL != nil { 166 host = req.URL.Host 167 } 168 if host != "" { 169 fmt.Fprintf(&b, "Host: %s\r\n", host) 170 } 171 172 chunked := len(req.TransferEncoding) > 0 && req.TransferEncoding[0] == "chunked" 173 if len(req.TransferEncoding) > 0 { 174 fmt.Fprintf(&b, "Transfer-Encoding: %s\r\n", strings.Join(req.TransferEncoding, ",")) 175 } 176 if req.Close { 177 fmt.Fprintf(&b, "Connection: close\r\n") 178 } 179 180 err = req.Header.WriteSubset(&b, reqWriteExcludeHeaderDump) 181 if err != nil { 182 return 183 } 184 185 io.WriteString(&b, "\r\n") 186 187 if req.Body != nil { 188 var dest io.Writer = &b 189 if chunked { 190 dest = NewChunkedWriter(dest) 191 } 192 _, err = io.Copy(dest, req.Body) 193 if chunked { 194 dest.(io.Closer).Close() 195 io.WriteString(&b, "\r\n") 196 } 197 } 198 199 req.Body = save 200 if err != nil { 201 return 202 } 203 dump = b.Bytes() 204 return 205 } 206 207 // DumpResponse is like DumpRequest but dumps a response. 208 func DumpResponse(resp *http.Response, body bool) (dump []byte, err error) { 209 var b bytes.Buffer 210 save := resp.Body 211 savecl := resp.ContentLength 212 if !body || resp.Body == nil { 213 resp.Body = nil 214 resp.ContentLength = 0 215 } else { 216 save, resp.Body, err = drainBody(resp.Body) 217 if err != nil { 218 return 219 } 220 } 221 err = resp.Write(&b) 222 resp.Body = save 223 resp.ContentLength = savecl 224 if err != nil { 225 return 226 } 227 dump = b.Bytes() 228 return 229 }