// Read next request from connection.
func (c *conn) readRequest() (r *request, w *response, err error) {
if c.hijacked {
return nil, nil, ErrHijacked
}
c.lr.N = int64(c.server.maxHeaderBytes()) + 4096 /* bufio slop */
var req *http.Request
if req, err = http.ReadRequest(c.buf.Reader); err != nil {
if c.lr.N == 0 {
return nil, nil, errTooLarge
}
return nil, nil, err
}
c.lr.N = noLimit
req.RemoteAddr = c.remoteAddr
w = new(response)
w.conn = c
r = new(request)
r.Request = req
r.w = w
w.reqWantsHttp10KeepAlive = r.wantsHttp10KeepAlive()
w.reqMethod = r.Method
w.reqProtoAtLeast10 = r.ProtoAtLeast(1, 0)
w.reqProtoAtLeast11 = r.ProtoAtLeast(1, 1)
w.reqExpectsContinue = r.expectsContinue()
w.reqContentLength = r.ContentLength
w.header = make(http.Header)
w.contentLength = -1
return r, w, nil
}
// newRequest is a helper function to create a new request with a method and url.
// The request returned is a 'server' request as opposed to a 'client' one through
// simulated write onto the wire and read off of the wire.
// The differences between requests are detailed in the net/http package.
func newRequest(method, url string) *http.Request {
req, err := http.NewRequest(method, url, nil)
if err != nil {
panic(err)
}
// extract the escaped original host+path from url
// http://localhost/path/here?v=1#frag -> //localhost/path/here
opaque := ""
if i := len(req.URL.Scheme); i > 0 {
opaque = url[i+1:]
}
if i := strings.LastIndex(opaque, "?"); i > -1 {
opaque = opaque[:i]
}
if i := strings.LastIndex(opaque, "#"); i > -1 {
opaque = opaque[:i]
}
// Escaped host+path workaround as detailed in https://golang.org/pkg/net/url/#URL
// for < 1.5 client side workaround
req.URL.Opaque = opaque
// Simulate writing to wire
var buff bytes.Buffer
req.Write(&buff)
ioreader := bufio.NewReader(&buff)
// Parse request off of 'wire'
req, err = http.ReadRequest(ioreader)
if err != nil {
panic(err)
}
return req
}
func req(t *testing.T, v string) *http.Request {
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(v)))
if err != nil {
t.Fatal(err)
}
return req
}
func BenchmarkSignatureSign(b *testing.B) {
b.StopTimer()
secret := "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"
access := "AKIDEXAMPLE"
signature := NewSignature(secret, access, USEast, "service")
b.StartTimer()
for i := 0; i < b.N; i++ {
b.StopTimer()
rawRequest := []byte(`POST / HTTP/1.1
Content-Type:application/x-www-form-urlencoded
Date:Mon, 09 Sep 2011 23:36:00 GMT
Host:host.foo.com
foo=bar`)
reader := bufio.NewReader(bytes.NewBuffer(rawRequest))
request, err := http.ReadRequest(reader)
if err != nil {
b.Fatal(err)
}
delete(request.Header, "User-Agent")
var body *bytes.Reader
if i := bytes.Index(rawRequest, []byte("\n\n")); i != -1 {
body = bytes.NewReader(rawRequest[i+2:])
request.Body = ioutil.NopCloser(body)
}
b.StartTimer()
_ = signature.Sign(request, body, nil)
}
}
func (this *HttpProxyServer) handleConnection(conn *hub.TCPConn) {
defer conn.Close()
reader := bufio.NewReader(conn)
request, err := http.ReadRequest(reader)
if err != nil {
log.Warning("Failed to read http request: ", err)
return
}
log.Info("Request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]")
defaultPort := v2net.Port(80)
if strings.ToLower(request.URL.Scheme) == "https" {
defaultPort = v2net.Port(443)
}
host := request.Host
if len(host) == 0 {
host = request.URL.Host
}
dest, err := parseHost(host, defaultPort)
if err != nil {
log.Warning("Malformed proxy host (", host, "): ", err)
return
}
if strings.ToUpper(request.Method) == "CONNECT" {
this.handleConnect(request, dest, reader, conn)
} else {
this.handlePlainHTTP(request, dest, reader, conn)
}
}
func TestHybiServerHandshakeHybiBadVersion(t *testing.T) {
config := new(Config)
handshaker := &hybiServerHandshaker{Config: config}
br := bufio.NewReader(strings.NewReader(`GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Origin: http://example.com
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 9
`))
req, err := http.ReadRequest(br)
if err != nil {
t.Fatal("request", err)
}
code, err := handshaker.ReadHandshake(br, req)
if err != ErrBadWebSocketVersion {
t.Errorf("handshake expected err %q but got %q", ErrBadWebSocketVersion, err)
}
if code != http.StatusBadRequest {
t.Errorf("status expected %q but got %q", http.StatusBadRequest, code)
}
}
// Serve parse data and then send to mika server.
func (h *Relay) Serve() {
bf := bufio.NewReader(h.conn)
req, err := http.ReadRequest(bf)
if err != nil {
utils.Errorf("Read request error %s", err)
return
}
// TODO Set http protocol flag
mikaConn, err := mika.DailWithRawAddrHTTP("tcp", h.ssServer, utils.ToAddr(req.URL.Host), h.cipher)
if err != nil {
return
}
defer func() {
if !h.closed {
err := mikaConn.Close()
utils.Errorf("Close connection error %v\n", err)
}
}()
if req.Method == "CONNECT" {
_HTTPSHandler(h.conn)
} else {
_HTTPHandler(mikaConn, req)
}
go protocols.Pipe(h.conn, mikaConn)
protocols.Pipe(mikaConn, h.conn)
h.closed = true
}
// handleConnection is spawned once per connection from a client, and exits when the client is
// done sending requests.
func handleConnection(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
for {
req, err := http.ReadRequest(reader)
if err != nil {
if err != io.EOF {
log.Printf("Failed to read request: %s", err)
}
return
}
// Connect to a backend and send the request along.
if be, err := net.Dial("tcp", "127.0.0.1:8081"); err == nil {
be_reader := bufio.NewReader(be)
if err := req.Write(be); err == nil {
if resp, err := http.ReadResponse(be_reader, req); err == nil {
FixHttp10Response(resp, req)
if err := resp.Write(conn); err == nil {
log.Printf("proxied %s: got %d", req.URL.Path, resp.StatusCode)
}
if resp.Close {
return
}
}
}
}
}
}
// ServeConn copies a response from c for every of the rw coonection's request.
func (srv *Server) ServeConn(rw net.Conn, c []Connection) {
var (
n int64
err error
req *http.Request
r = bufio.NewReader(rw)
rem = tcpaddrnil(rw.RemoteAddr())
)
for i := 0; ; i++ {
if req, err = http.ReadRequest(r); err != nil {
break
}
n, err = io.Copy(ioutil.Discard, req.Body)
req.Body.Close()
if i >= len(c) {
write500(rw, errNoResponse)
srv.Reply(rem, srv.src, n, errNoResponse)
continue
}
srv.Reply(rem, srv.src, n, err)
if err != nil {
write500(rw, err)
continue
}
if c[i].Res != nil {
_, err = io.Copy(rw, bytes.NewBuffer(c[i].Res))
srv.Reply(srv.src, rem, int64(len(c[i].Res)), err)
}
}
if err != nil && err != io.EOF {
srv.Reply(rem, srv.src, 0, err)
}
rw.Close()
srv.wg.Done()
}
func TestHopByHopHeadersStrip(t *testing.T) {
assert := assert.On(t)
rawRequest := `GET /pkg/net/http/ HTTP/1.1
Host: golang.org
Connection: keep-alive,Foo, Bar
Foo: foo
Bar: bar
Proxy-Connection: keep-alive
Proxy-Authenticate: abc
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; de-de) AppleWebKit/523.10.3 (KHTML, like Gecko) Version/3.0.4 Safari/523.10
Accept-Encoding: gzip
Accept-Charset: ISO-8859-1,UTF-8;q=0.7,*;q=0.7
Cache-Control: no-cache
Accept-Language: de,en;q=0.7,en-us;q=0.3
`
b := bufio.NewReader(strings.NewReader(rawRequest))
req, err := http.ReadRequest(b)
assert.Error(err).IsNil()
assert.String(req.Header.Get("Foo")).Equals("foo")
assert.String(req.Header.Get("Bar")).Equals("bar")
assert.String(req.Header.Get("Connection")).Equals("keep-alive,Foo, Bar")
assert.String(req.Header.Get("Proxy-Connection")).Equals("keep-alive")
assert.String(req.Header.Get("Proxy-Authenticate")).Equals("abc")
StripHopByHopHeaders(req)
assert.String(req.Header.Get("Connection")).Equals("close")
assert.String(req.Header.Get("Foo")).Equals("")
assert.String(req.Header.Get("Bar")).Equals("")
assert.String(req.Header.Get("Proxy-Connection")).Equals("")
assert.String(req.Header.Get("Proxy-Authenticate")).Equals("")
}
func getAWSSuiteReq(reqFileName string) (*sign4.ReusableRequest, error) {
readBytes, err := ioutil.ReadFile(reqFileName)
//fmt.Printf("Read: \n%v\n", string(readBytes))
if err != nil {
return nil, err
}
// fix lowercase http, which causes issues in the parser
if reqStr := string(readBytes); strings.Contains(reqStr, "http/1.1") {
readBytes = []byte(strings.Replace(reqStr, "http/1.1", "HTTP/1.1", 1))
}
buff := new(bytes.Buffer)
_, err = buff.Write(readBytes)
if err != nil {
return nil, err
}
hreq, err := http.ReadRequest(bufio.NewReader(buff))
if err != nil {
return nil, err
}
req, err := sign4.NewReusableRequestFromRequest(hreq)
if err != nil {
return nil, err
}
// add a blank user agent if one doesn't exist
_, ok := req.Header["User-Agent"]
if !ok {
req.Header.Set("User-Agent", "")
}
return req, nil
}
func req(s string) *http.Request {
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(s)))
if err != nil {
panic(fmt.Sprintf("bad request in test: %q (error: %v)", req, err))
}
return req
}
func (this *Server) handleConnection(conn internet.Connection) {
defer conn.Close()
timedReader := v2net.NewTimeOutReader(this.config.Timeout, conn)
reader := bufio.NewReaderSize(timedReader, 2048)
request, err := http.ReadRequest(reader)
if err != nil {
if err != io.EOF {
log.Warning("HTTP: Failed to read http request: ", err)
}
return
}
log.Info("HTTP: Request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]")
defaultPort := v2net.Port(80)
if strings.ToLower(request.URL.Scheme) == "https" {
defaultPort = v2net.Port(443)
}
host := request.Host
if len(host) == 0 {
host = request.URL.Host
}
dest, err := parseHost(host, defaultPort)
if err != nil {
log.Warning("HTTP: Malformed proxy host (", host, "): ", err)
return
}
log.Access(conn.RemoteAddr(), request.URL, log.AccessAccepted, "")
if strings.ToUpper(request.Method) == "CONNECT" {
this.handleConnect(request, dest, reader, conn)
} else {
this.handlePlainHTTP(request, dest, reader, conn)
}
}
func MustRequestFromString(reqString string) (req *http.Request) {
req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader([]byte(reqString))))
if err != nil {
panic(err)
}
return req
}
func handleConnection(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
for {
req, err := http.ReadRequest(reader)
if err != nil {
if err != io.EOF {
log.Printf("Failed to read request: %s", err)
}
return
}
be, err := getBackend()
if err != nil {
return
}
if err := req.Write(be.Writer); err == nil {
be.Writer.Flush()
if resp, err := http.ReadResponse(be.Reader, req); err == nil {
bytes := updateStats(req, resp)
resp.Header.Set("X-Bytes", strconv.FormatInt(bytes, 10))
FixHttp10Response(resp, req)
if err := resp.Write(conn); err == nil {
log.Printf("proxied %s: got %d", req.URL.Path, resp.StatusCode)
bytes, _ := httputil.DumpRequest(req, false)
log.Printf("Dump header: %s", string(bytes))
}
if resp.Close {
return
}
}
}
go queueBackend(be)
}
}
func main() {
// listen for connections
if ln, err := net.Listen("tcp", ":8080"); err == nil {
for {
// accept connections
if conn, err := ln.Accept(); err == nil {
reader := bufio.NewReader(conn)
// read requests from the client
if req, err := http.ReadRequest(reader); err == nil {
// connect to the backend web server
if be, err := net.Dial("tcp", "127.0.0.1:8081"); err == nil {
be_reader := bufio.NewReader(be)
// send the request to the backend
if err := req.Write(be); err == nil {
// read the response from the backend
if resp, err := http.ReadResponse(be_reader, req); err == nil {
// send the response to the client, making sure to close it
resp.Close = true
if err := resp.Write(conn); err == nil {
log.Printf("proxied %s: got %d", req.URL.Path, resp.StatusCode)
}
conn.Close()
// loop back to accepting the next connection
}
}
}
}
}
}
}
}
func main() {
// 1. Listen for connections.
if ln, err := net.Listen("tcp", ":8080"); err == nil {
for {
// 2. Accept connections.
if conn, err := ln.Accept(); err == nil {
reader := bufio.NewReader(conn)
// 3. Read requests from the client.
if req, err := http.ReadRequest(reader); err == nil {
// 4. Connect to the backend web server.
if be, err := net.Dial("tcp", "127.0.0.1:8081"); err == nil {
be_reader := bufio.NewReader(be)
// 5. Send the request to the backend.
if err := req.Write(be); err == nil {
// 6. Read the response from the backend.
if resp, err := http.ReadResponse(be_reader, req); err == nil {
// 7. Send the response to the client, making sure to close it.
resp.Close = true
if err := resp.Write(conn); err == nil {
log.Printf("proxied %s: got %d", req.URL.Path, resp.StatusCode)
}
conn.Close()
// Repeat back at 2: accept the next connection.
}
}
}
}
}
}
}
}
func newTransportConn(c net.Conn, tr *ProxyAuthTransport) *transportConn {
tc := &transportConn{
Conn: c,
reqDone: make(chan struct{}),
errChannel: make(chan error),
transport: tr,
}
// Intercept outgoing request as it is written out to server and store it
// in case it needs to be authenticated and replayed
//NOTE that pipelining is currently not supported
pr, pw := io.Pipe()
tc.requestInterceptor = pw
requestReader := bufio.NewReader(pr)
go func() {
requestInterceptLoop:
for {
req, err := http.ReadRequest(requestReader)
if err != nil {
tc.Conn.Close()
pr.Close()
pw.Close()
tc.errChannel <- fmt.Errorf("intercept request loop http.ReadRequest error: %s", err)
break requestInterceptLoop
}
//read and copy entire body
body, _ := ioutil.ReadAll(req.Body)
tc.lastRequest = req
tc.lastRequest.Body = ioutil.NopCloser(bytes.NewReader(body))
//Signal when we have a complete request
tc.reqDone <- struct{}{}
}
}()
return tc
}
func sendMessage(m *TCPMessage) {
conn, err := ReplayServer()
if err != nil {
log.Println("Failed to send message. Replay server not respond.")
return
} else {
defer conn.Close()
}
// For debugging purpose
// Usually request parsing happens in replay part
if Settings.Verbose {
buf := bytes.NewBuffer(m.Bytes())
reader := bufio.NewReader(buf)
request, err := http.ReadRequest(reader)
if err != nil {
Debug("Error while parsing request:", err, string(m.Bytes()))
} else {
request.ParseMultipartForm(32 << 20)
Debug("Forwarding request:", request)
}
}
_, err = conn.Write(m.Bytes())
if err != nil {
log.Println("Error while sending requests", err)
}
}
// handleConn processes conn. This is run in a separate goroutine.
func (s *Service) handleConn(conn net.Conn) {
defer s.statMap.Add(statConnectionsActive, -1)
s.statMap.Add(statConnectionsActive, 1)
s.statMap.Add(statConnectionsHandled, 1)
// Read header into buffer to check if it's HTTP.
var buf bytes.Buffer
r := bufio.NewReader(io.TeeReader(conn, &buf))
// Attempt to parse connection as HTTP.
_, err := http.ReadRequest(r)
// Rebuild connection from buffer and remaining connection data.
bufr := bufio.NewReader(io.MultiReader(&buf, conn))
conn = &readerConn{Conn: conn, r: bufr}
// If no HTTP parsing error occurred then process as HTTP.
if err == nil {
s.statMap.Add(statHTTPConnectionsHandled, 1)
s.httpln.ch <- conn
return
}
// Otherwise handle in telnet format.
s.wg.Add(1)
s.handleTelnetConn(conn)
}
func mustReadRequest(s string) *http.Request {
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(s)))
if err != nil {
panic(err)
}
return req
}
func (h *Http) readRequests(tee *conn.Tee, lastTxn chan *HttpTxn, connCtx interface{}) {
defer close(lastTxn)
for {
req, err := http.ReadRequest(tee.WriteBuffer())
if err != nil {
// no more requests to be read, we're done
break
}
// make sure we read the body of the request so that
// we don't block the writer
_, err = httputil.DumpRequest(req, true)
h.reqMeter.Mark(1)
if err != nil {
tee.Warn("Failed to extract request body: %v", err)
}
// golang's ReadRequest/DumpRequestOut is broken. Fix up the request so it works later
req.URL.Scheme = "http"
req.URL.Host = req.Host
txn := &HttpTxn{Start: time.Now(), ConnUserCtx: connCtx}
txn.Req = &HttpRequest{Request: req}
txn.Req.BodyBytes, txn.Req.Body, err = extractBody(req.Body)
lastTxn <- txn
h.Txns.In() <- txn
}
}
// handleConnection is spawned once per connection from a client,
// and exits when the client is done sending requests
func handleConnection(conn net.Conn) {
// always close the conn no matter how this function exits:
defer conn.Close()
reader := bufio.NewReader(conn)
// loop to handle multiple requests from user conn,
// since we are now running concurrently:
for {
req, err := http.ReadRequest(reader)
if err != nil {
if err != io.EOF {
log.Printf("Failed to read request: %s", err)
}
return
}
// connect to a backend and send the request along
if be, err := net.Dial("tcp", "127.0.0.1:8081"); err == nil {
be_reader := bufio.NewReader(be)
if err := req.Write(be); err == nil {
if resp, err := http.ReadResponse(be_reader, req); err == nil {
FixHttp10Response(resp, req)
if err := resp.Write(conn); err == nil {
log.Printf("proxied %s: got %d", req.URL.Path, resp.StatusCode)
}
if resp.Close {
return
}
}
}
}
}
}
func (stream HttpRequestStream) start() {
defer errorHandler()
//
logHRS.Debug("开始获取请求数据")
//
buf := bufio.NewReader(&stream.reader)
for {
logHRS.Debug("1")
req, err := http.ReadRequest(buf)
logHRS.Debug("2")
if err == io.EOF {
logHRS.Debug("请求数据全部获取完, %v", logHRSCount)
stream.end()
break
} else if err != nil {
logHRS.Debug("something error %v", err)
} else {
logHRS.Debug("请求数据获取完成")
stream.request = req
bodyBytes := tcpreader.DiscardBytesToEOF(req.Body)
req.Body.Close()
log.Println("Received request from stream:", req, "with", bodyBytes, "bytes in request body")
}
}
}
func (s *Server) Process(ctx context.Context, network v2net.Network, conn internet.Connection) error {
conn.SetReusable(false)
timedReader := v2net.NewTimeOutReader(s.config.Timeout, conn)
reader := bufio.OriginalReaderSize(timedReader, 2048)
request, err := http.ReadRequest(reader)
if err != nil {
if errors.Cause(err) != io.EOF {
log.Warning("HTTP: Failed to read http request: ", err)
}
return err
}
log.Info("HTTP: Request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]")
defaultPort := v2net.Port(80)
if strings.ToLower(request.URL.Scheme) == "https" {
defaultPort = v2net.Port(443)
}
host := request.Host
if len(host) == 0 {
host = request.URL.Host
}
dest, err := parseHost(host, defaultPort)
if err != nil {
log.Warning("HTTP: Malformed proxy host (", host, "): ", err)
return err
}
log.Access(conn.RemoteAddr(), request.URL, log.AccessAccepted, "")
ctx = proxy.ContextWithDestination(ctx, dest)
if strings.ToUpper(request.Method) == "CONNECT" {
return s.handleConnect(ctx, request, reader, conn)
} else {
return s.handlePlainHTTP(ctx, request, reader, conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
clientAddr := conn.RemoteAddr().(*net.TCPAddr).IP.To4()
ipUint32 := ip4ToUint32(clientAddr)
if perIpConnTracker.registerIp(ipUint32) > *maxConnsPerIp {
logMessage("Too many concurrent connections (more than %d) from ip=%s. Denying new connection from the ip", *maxConnsPerIp, clientAddr)
perIpConnTracker.unregisterIp(ipUint32)
return
}
defer perIpConnTracker.unregisterIp(ipUint32)
r := bufio.NewReaderSize(conn, *readBufferSize)
w := bufio.NewWriterSize(conn, *writeBufferSize)
clientAddrStr := clientAddr.String()
for {
req, err := http.ReadRequest(r)
if err != nil {
if err != io.EOF {
logMessage("Error when reading http request from ip=%s: [%s]", clientAddr, err)
}
return
}
req.RemoteAddr = clientAddrStr
ok := handleRequest(req, w)
w.Flush()
if !ok || !req.ProtoAtLeast(1, 1) || req.Header.Get("Connection") == "close" {
return
}
}
}
// Serve messages received on the given packet listener to the srv.Handler.
func (srv *Server) Serve(l net.PacketConn) error {
maxMessageBytes := DefaultMaxMessageBytes
if srv.MaxMessageBytes != 0 {
maxMessageBytes = srv.MaxMessageBytes
}
for {
buf := make([]byte, maxMessageBytes)
n, peerAddr, err := l.ReadFrom(buf)
if err != nil {
return err
}
buf = buf[:n]
go func(buf []byte, peerAddr net.Addr) {
// At least one router's UPnP implementation has added a trailing space
// after "HTTP/1.1" - trim it.
buf = trailingWhitespaceRx.ReplaceAllLiteral(buf, crlf)
req, err := http.ReadRequest(bufio.NewReader(bytes.NewBuffer(buf)))
if err != nil {
log.Printf("httpu: Failed to parse request: %v", err)
return
}
req.RemoteAddr = peerAddr.String()
srv.Handler.ServeMessage(req)
// No need to call req.Body.Close - underlying reader is bytes.Buffer.
}(buf, peerAddr)
}
}
// ParseRequest in []byte returns a http request or an error
func ParseRequest(data []byte) (request *http.Request, err error) {
buf := bytes.NewBuffer(data)
reader := bufio.NewReader(buf)
request, err = http.ReadRequest(reader)
return
}
func (h *Http) readRequests(tee *conn.Tee, lastTxn chan *HttpTxn) {
for {
req, err := http.ReadRequest(tee.WriteBuffer())
if err != nil {
// no more requests to be read, we're done
break
}
// make sure we read the body of the request so that
// we don't block the writer
_, err = httputil.DumpRequest(req, true)
h.reqMeter.Mark(1)
if err != nil {
tee.Warn("Failed to extract request body: %v", err)
}
txn := &HttpTxn{Start: time.Now()}
txn.Req = &HttpRequest{Request: req}
txn.Req.BodyBytes, txn.Req.Body, err = extractBody(req.Body)
lastTxn <- txn
h.Txns.In() <- txn
}
}
func TestSignErrors(t *testing.T) {
secret := "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"
access := "AKIDEXAMPLE"
signature := NewSignature(secret, access, USEast1, "service")
rawRequest := []byte(`POST / HTTP/1.1
Content-Type:application/x-www-form-urlencoded
Date:a
Host:host.foo.com
foo=bar`)
reader := bufio.NewReader(bytes.NewBuffer(rawRequest))
request, err := http.ReadRequest(reader)
if err != nil {
t.Fatal(err)
}
err = signature.Sign(request, nil)
if err == nil {
t.Error("expected error but got nil")
} else {
if _, ok := err.(*time.ParseError); !ok {
t.Error("url not *time.ParseError")
}
}
request.URL.RawQuery += "%jk"
err = signature.Sign(request, nil)
if err == nil {
t.Error("expected error but got nil")
} else {
if _, ok := err.(url.EscapeError); !ok {
t.Error("url not url.EscapeError")
}
}
}