type maxBytesReader struct {
    w         ResponseWriter
    r         io.ReadCloser // underlying reader
    n         int64         // max bytes remaining
    stopped   bool
    sawEOF    bool
    overLimit bool
}

func (l *maxBytesReader) Read(p []byte) (n int, err error) {
    toRead := l.n
    if l.n <= 0 {
        if l.overLimit {
            return l.tooLarge()
        }
        if l.sawEOF {
            return 0, io.EOF
        }
        // The underlying io.Reader may not return (0, io.EOF)
        // at EOF if the requested size is 0, so read 1 byte
        // instead. The io.Reader docs are a bit ambiguous
        // about the return value of Read when 0 bytes are
        // requested, and {bytes,strings}.Reader gets it wrong
        // too (it returns (0, nil) even at EOF).
        toRead = 1
    }
    if int64(len(p)) > toRead {
        p = p[:toRead]
    }
    n, err = l.r.Read(p)
    if err == io.EOF {
        l.sawEOF = true
    }
    if l.n <= 0 {
        // If we had zero bytes to read remaining (but hadn't seen EOF)
        // and we get a byte here, that means we went over our limit.
        if n > 0 {
            l.overLimit = true
            return l.tooLarge()
        }
        return 0, err
    }
    l.n -= int64(n)
    return
}