Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Package httputil provides HTTP utility functions, complementing the

// more common ones in the net/http package.

package httputil

import (

        "bufio"

        "errors"

        "io"

        "net"

        "net/http"

        "net/textproto"

        "os"

        "sync"

)

var (

        ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}

        ErrPipeline   = &http.ProtocolError{ErrorString: "pipeline error"}

)

// This is an API usage error - the local side is closed.

// ErrPersistEOF (above) reports that the remote side is closed.

var errClosed = errors.New("i/o operation on closed connection")

// A ServerConn reads requests and sends responses over an underlying

// connection, until the HTTP keepalive logic commands an end. ServerConn

// also allows hijacking the underlying connection by calling Hijack

// to regain control over the connection. ServerConn supports pipe-lining,

// i.e. requests can be read out of sync (but in the same order) while the

// respective responses are sent.

//

// ServerConn is low-level and should not be needed by most applications.

// See Server.

type ServerConn struct {

        lk              sync.Mutex // read-write protects the following fields

        c               net.Conn

        r               *bufio.Reader

        re, we          error // read/write errors

        lastbody        io.ReadCloser

        nread, nwritten int

        pipereq         map[*http.Request]uint

        pipe textproto.Pipeline

}

// NewServerConn returns a new ServerConn reading and writing c.  If r is not

// nil, it is the buffer to use when reading c.

func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn {

        if r == nil {

                r = bufio.NewReader(c)

        }

        return &ServerConn{c: c, r: r, pipereq: make(map[*http.Request]uint)}

}

// Hijack detaches the ServerConn and returns the underlying connection as well

// as the read-side bufio which may have some left over data. Hijack may be

// called before Read has signaled the end of the keep-alive logic. The user

// should not call Hijack while Read or Write is in progress.

func (sc *ServerConn) Hijack() (c net.Conn, r *bufio.Reader) {

        sc.lk.Lock()

        defer sc.lk.Unlock()

        c = sc.c

        r = sc.r

        sc.c = nil

        sc.r = nil

        return

}

// Close calls Hijack and then also closes the underlying connection

func (sc *ServerConn) Close() error {

        c, _ := sc.Hijack()

        if c != nil {

                return c.Close()

        }

        return nil

}

// Read returns the next request on the wire. An ErrPersistEOF is returned if

// it is gracefully determined that there are no more requests (e.g. after the

// first request on an HTTP/1.0 connection, or after a Connection:close on a

// HTTP/1.1 connection).

func (sc *ServerConn) Read() (req *http.Request, err error) {

        // Ensure ordered execution of Reads and Writes

        id := sc.pipe.Next()

        sc.pipe.StartRequest(id)

        defer func() {

                sc.pipe.EndRequest(id)

                if req == nil {

                        sc.pipe.StartResponse(id)

                        sc.pipe.EndResponse(id)

                } else {

                        // Remember the pipeline id of this request

                        sc.lk.Lock()

                        sc.pipereq[req] = id

                        sc.lk.Unlock()

                }

        }()

        sc.lk.Lock()

        if sc.we != nil { // no point receiving if write-side broken or closed

                defer sc.lk.Unlock()

                return nil, sc.we

        }

        if sc.re != nil {

                defer sc.lk.Unlock()

                return nil, sc.re

        }

        if sc.r == nil { // connection closed by user in the meantime

                defer sc.lk.Unlock()

                return nil, errClosed

        }

        r := sc.r

        lastbody := sc.lastbody

        sc.lastbody = nil

        sc.lk.Unlock()

        // Make sure body is fully consumed, even if user does not call body.Close

        if lastbody != nil {

                // body.Close is assumed to be idempotent and multiple calls to

                // it should return the error that its first invocation

                // returned.

                err = lastbody.Close()

                if err != nil {

                        sc.lk.Lock()

                        defer sc.lk.Unlock()

                        sc.re = err

                        return nil, err

                }

        }

        req, err = http.ReadRequest(r)

        sc.lk.Lock()

        defer sc.lk.Unlock()

        if err != nil {

                if err == io.ErrUnexpectedEOF {

                        // A close from the opposing client is treated as a

                        // graceful close, even if there was some unparse-able

                        // data before the close.

                        sc.re = ErrPersistEOF

                        return nil, sc.re

                } else {

                        sc.re = err

                        return req, err

                }

        }

        sc.lastbody = req.Body

        sc.nread++

        if req.Close {

                sc.re = ErrPersistEOF

                return req, sc.re

        }

        return req, err

}

// Pending returns the number of unanswered requests

// that have been received on the connection.

func (sc *ServerConn) Pending() int {

        sc.lk.Lock()

        defer sc.lk.Unlock()

        return sc.nread - sc.nwritten

}

// Write writes resp in response to req. To close the connection gracefully, set the

// Response.Close field to true. Write should be considered operational until

// it returns an error, regardless of any errors returned on the Read side.

func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error {

        // Retrieve the pipeline ID of this request/response pair

        sc.lk.Lock()

        id, ok := sc.pipereq[req]

        delete(sc.pipereq, req)

        if !ok {

                sc.lk.Unlock()

                return ErrPipeline

        }

        sc.lk.Unlock()

        // Ensure pipeline order

        sc.pipe.StartResponse(id)

        defer sc.pipe.EndResponse(id)

        sc.lk.Lock()

        if sc.we != nil {

                defer sc.lk.Unlock()

                return sc.we

        }

        if sc.c == nil { // connection closed by user in the meantime

                defer sc.lk.Unlock()

                return os.EBADF

        }

        c := sc.c

        if sc.nread <= sc.nwritten {

                defer sc.lk.Unlock()

                return errors.New("persist server pipe count")

        }

        if resp.Close {

                // After signaling a keep-alive close, any pipelined unread

                // requests will be lost. It is up to the user to drain them

                // before signaling.

                sc.re = ErrPersistEOF

        }

        sc.lk.Unlock()

        err := resp.Write(c)

        sc.lk.Lock()

        defer sc.lk.Unlock()

        if err != nil {

                sc.we = err

                return err

        }

        sc.nwritten++

        return nil

}

// A ClientConn sends request and receives headers over an underlying

// connection, while respecting the HTTP keepalive logic. ClientConn

// supports hijacking the connection calling Hijack to

// regain control of the underlying net.Conn and deal with it as desired.

//

// ClientConn is low-level and should not be needed by most applications.

// See Client.

type ClientConn struct {

        lk              sync.Mutex // read-write protects the following fields

        c               net.Conn

        r               *bufio.Reader

        re, we          error // read/write errors

        lastbody        io.ReadCloser

        nread, nwritten int

        pipereq         map[*http.Request]uint

        pipe     textproto.Pipeline

        writeReq func(*http.Request, io.Writer) error

}

// NewClientConn returns a new ClientConn reading and writing c.  If r is not

// nil, it is the buffer to use when reading c.

func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn {

        if r == nil {

                r = bufio.NewReader(c)

        }

        return &ClientConn{

                c:        c,

                r:        r,

                pipereq:  make(map[*http.Request]uint),

                writeReq: (*http.Request).Write,

        }

}

// NewProxyClientConn works like NewClientConn but writes Requests

// using Request's WriteProxy method.

func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn {

        cc := NewClientConn(c, r)

        cc.writeReq = (*http.Request).WriteProxy

        return cc

}

// Hijack detaches the ClientConn and returns the underlying connection as well

// as the read-side bufio which may have some left over data. Hijack may be

// called before the user or Read have signaled the end of the keep-alive

// logic. The user should not call Hijack while Read or Write is in progress.

func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader) {

        cc.lk.Lock()

        defer cc.lk.Unlock()

        c = cc.c

        r = cc.r

        cc.c = nil

        cc.r = nil

        return

}

// Close calls Hijack and then also closes the underlying connection

func (cc *ClientConn) Close() error {

        c, _ := cc.Hijack()

        if c != nil {

                return c.Close()

        }

        return nil

}

// Write writes a request. An ErrPersistEOF error is returned if the connection

// has been closed in an HTTP keepalive sense. If req.Close equals true, the

// keepalive connection is logically closed after this request and the opposing

// server is informed. An ErrUnexpectedEOF indicates the remote closed the

// underlying TCP connection, which is usually considered as graceful close.

func (cc *ClientConn) Write(req *http.Request) (err error) {

        // Ensure ordered execution of Writes

        id := cc.pipe.Next()

        cc.pipe.StartRequest(id)

        defer func() {

                cc.pipe.EndRequest(id)

                if err != nil {

                        cc.pipe.StartResponse(id)

                        cc.pipe.EndResponse(id)

                } else {

                        // Remember the pipeline id of this request

                        cc.lk.Lock()

                        cc.pipereq[req] = id

                        cc.lk.Unlock()

                }

        }()

        cc.lk.Lock()

        if cc.re != nil { // no point sending if read-side closed or broken

                defer cc.lk.Unlock()

                return cc.re

        }

        if cc.we != nil {

                defer cc.lk.Unlock()

                return cc.we

        }

        if cc.c == nil { // connection closed by user in the meantime

                defer cc.lk.Unlock()

                return errClosed

        }

        c := cc.c

        if req.Close {

                // We write the EOF to the write-side error, because there

                // still might be some pipelined reads

                cc.we = ErrPersistEOF

        }

        cc.lk.Unlock()

        err = cc.writeReq(req, c)

        cc.lk.Lock()

        defer cc.lk.Unlock()

        if err != nil {

                cc.we = err

                return err

        }

        cc.nwritten++

        return nil

}

// Pending returns the number of unanswered requests

// that have been sent on the connection.

func (cc *ClientConn) Pending() int {

        cc.lk.Lock()

        defer cc.lk.Unlock()

        return cc.nwritten - cc.nread

}

// Read reads the next response from the wire. A valid response might be

// returned together with an ErrPersistEOF, which means that the remote

// requested that this be the last request serviced. Read can be called

// concurrently with Write, but not with another Read.

func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) {

        // Retrieve the pipeline ID of this request/response pair

        cc.lk.Lock()

        id, ok := cc.pipereq[req]

        delete(cc.pipereq, req)

        if !ok {

                cc.lk.Unlock()

                return nil, ErrPipeline

        }

        cc.lk.Unlock()

        // Ensure pipeline order

        cc.pipe.StartResponse(id)

        defer cc.pipe.EndResponse(id)

        cc.lk.Lock()

        if cc.re != nil {

                defer cc.lk.Unlock()

                return nil, cc.re

        }

        if cc.r == nil { // connection closed by user in the meantime

                defer cc.lk.Unlock()

                return nil, errClosed

        }

        r := cc.r

        lastbody := cc.lastbody

        cc.lastbody = nil

        cc.lk.Unlock()

        // Make sure body is fully consumed, even if user does not call body.Close

        if lastbody != nil {

                // body.Close is assumed to be idempotent and multiple calls to

                // it should return the error that its first invokation

                // returned.

                err = lastbody.Close()

                if err != nil {

                        cc.lk.Lock()

                        defer cc.lk.Unlock()

                        cc.re = err

                        return nil, err

                }

        }

        resp, err = http.ReadResponse(r, req)

        cc.lk.Lock()

        defer cc.lk.Unlock()

        if err != nil {

                cc.re = err

                return resp, err

        }

        cc.lastbody = resp.Body

        cc.nread++

        if resp.Close {

                cc.re = ErrPersistEOF // don't send any more requests

                return resp, cc.re

        }

        return resp, err

}

// Do is convenience method that writes a request and reads a response.

func (cc *ClientConn) Do(req *http.Request) (resp *http.Response, err error) {

        err = cc.Write(req)

        if err != nil {

                return

        }

        return cc.Read(req)

}