// - BufRead: ReadRune, UnreadRune ?
// could make ReadRune generic if we dropped UnreadRune
// - buffered output
+// - would like to rename to Read, Write, but breaks
+// embedding of these: would lose the Read, Write methods.
const (
defaultBufSize = 4096
rd io.Read;
r, w int;
err *os.Error;
+ lastbyte int;
}
func NewBufReadSize(rd io.Read, size int) (b *BufRead, err *os.Error) {
b = new(BufRead);
b.buf = make([]byte, size);
b.rd = rd;
+ b.lastbyte = -1;
return b, nil
}
-func NewBufRead(rd io.Read) (b *BufRead, err *os.Error) {
- return NewBufReadSize(rd, defaultBufSize);
+func NewBufRead(rd io.Read) *BufRead {
+ b, err := NewBufReadSize(rd, defaultBufSize);
+ if err != nil {
+ // cannot happen - defaultBufSize is a valid size
+ panic("bufio: NewBufRead: ", err.String());
+ }
+ return b;
}
// Read a new chunk into the buffer.
for len(p) > 0 {
n := len(p);
if b.w == b.r {
+ if len(p) >= len(b.buf) {
+ // Large read, empty buffer.
+ // Read directly into p to avoid copy.
+ n, b.err = b.rd.Read(p);
+ if n > 0 {
+ b.lastbyte = int(p[n-1]);
+ }
+ p = p[n:len(p)];
+ nn += n;
+ if b.err != nil {
+ return nn, b.err
+ }
+ if n == 0 {
+ return nn, EndOfFile
+ }
+ continue;
+ }
b.Fill();
if b.err != nil {
return nn, b.err
copySlice(p[0:n], b.buf[b.r:b.r+n]);
p = p[n:len(p)];
b.r += n;
+ b.lastbyte = int(b.buf[b.r-1]);
nn += n
}
return nn, nil
}
c = b.buf[b.r];
b.r++;
+ b.lastbyte = int(c);
return c, nil
}
if b.err != nil {
return b.err
}
+ if b.r == b.w && b.lastbyte >= 0 {
+ b.w = 1;
+ b.r = 0;
+ b.buf[0] = byte(b.lastbyte);
+ b.lastbyte = -1;
+ return nil;
+ }
if b.r <= 0 {
return PhaseError
}
b.r--;
+ b.lastbyte = -1;
return nil
}
rune, size = utf8.DecodeRune(b.buf[b.r:b.w]);
}
b.r += size;
+ b.lastbyte = int(b.buf[b.r-1]);
return rune, size, nil
}
return b, nil
}
-func NewBufWrite(wr io.Write) (b *BufWrite, err *os.Error) {
- return NewBufWriteSize(wr, defaultBufSize);
+func NewBufWrite(wr io.Write) *BufWrite {
+ b, err := NewBufWriteSize(wr, defaultBufSize);
+ if err != nil {
+ // cannot happen - defaultBufSize is valid size
+ panic("bufio: NewBufWrite: ", err.String());
+ }
+ return b;
}
// Flush the output buffer.
}
n = b.Available()
}
+ if b.Available() == 0 && len(p) >= len(b.buf) {
+ // Large write, empty buffer.
+ // Write directly from p to avoid copy.
+ n, b.err = b.wr.Write(p);
+ nn += n;
+ p = p[n:len(p)];
+ if b.err != nil {
+ break;
+ }
+ continue;
+ }
if n > len(p) {
n = len(p)
}
return nil
}
+// buffered input and output
+
+type BufReadWrite struct {
+ *BufRead;
+ *BufWrite;
+}
+
+func NewBufReadWrite(r *BufRead, w *BufWrite) *BufReadWrite {
+ return &BufReadWrite{r, w}
+}
+
"fmt";
"http";
"io";
+ "log";
"net";
"os";
"strconv";
)
var ErrWriteAfterFlush = os.NewError("Conn.Write called after Flush")
+var ErrHijacked = os.NewError("Conn has been hijacked")
type Conn struct
// Active HTTP connection (server side).
type Conn struct {
- Fd io.ReadWriteClose;
- RemoteAddr string;
- Req *Request;
- Br *bufio.BufRead;
-
- br *bufio.BufRead;
- bw *bufio.BufWrite;
- close bool;
- chunking bool;
- flushed bool;
- header map[string] string;
- wroteHeader bool;
- handler Handler;
-}
-
-// HTTP response codes.
-// TODO(rsc): Maybe move these to their own file, so that
-// clients can use them too.
-
-const (
- StatusContinue = 100;
- StatusSwitchingProtocols = 101;
-
- StatusOK = 200;
- StatusCreated = 201;
- StatusAccepted = 202;
- StatusNonAuthoritativeInfo = 203;
- StatusNoContent = 204;
- StatusResetContent = 205;
- StatusPartialContent = 206;
-
- StatusMultipleChoices = 300;
- StatusMovedPermanently = 301;
- StatusFound = 302;
- StatusSeeOther = 303;
- StatusNotModified = 304;
- StatusUseProxy = 305;
- StatusTemporaryRedirect = 307;
-
- StatusBadRequest = 400;
- StatusUnauthorized = 401;
- StatusPaymentRequired = 402;
- StatusForbidden = 403;
- StatusNotFound = 404;
- StatusMethodNotAllowed = 405;
- StatusNotAcceptable = 406;
- StatusProxyAuthRequired = 407;
- StatusRequestTimeout = 408;
- StatusConflict = 409;
- StatusGone = 410;
- StatusLengthRequired = 411;
- StatusPreconditionFailed = 412;
- StatusRequestEntityTooLarge = 413;
- StatusRequestURITooLong = 414;
- StatusUnsupportedMediaType = 415;
- StatusRequestedRangeNotSatisfiable = 416;
- StatusExpectationFailed = 417;
-
- StatusInternalServerError = 500;
- StatusNotImplemented = 501;
- StatusBadGateway = 502;
- StatusServiceUnavailable = 503;
- StatusGatewayTimeout = 504;
- StatusHTTPVersionNotSupported = 505;
-)
-
-var statusText = map[int]string {
- StatusContinue: "Continue",
- StatusSwitchingProtocols: "Switching Protocols",
-
- StatusOK: "OK",
- StatusCreated: "Created",
- StatusAccepted: "Accepted",
- StatusNonAuthoritativeInfo: "Non-Authoritative Information",
- StatusNoContent: "No Content",
- StatusResetContent: "Reset Content",
- StatusPartialContent: "Partial Content",
-
- StatusMultipleChoices: "Multiple Choices",
- StatusMovedPermanently: "Moved Permanently",
- StatusFound: "Found",
- StatusSeeOther: "See Other",
- StatusNotModified: "Not Modified",
- StatusUseProxy: "Use Proxy",
- StatusTemporaryRedirect: "Temporary Redirect",
-
- StatusBadRequest: "Bad Request",
- StatusUnauthorized: "Unauthorized",
- StatusPaymentRequired: "Payment Required",
- StatusForbidden: "Forbidden",
- StatusNotFound: "Not Found",
- StatusMethodNotAllowed: "Method Not Allowed",
- StatusNotAcceptable: "Not Acceptable",
- StatusProxyAuthRequired: "Proxy Authentication Required",
- StatusRequestTimeout: "Request Timeout",
- StatusConflict: "Conflict",
- StatusGone: "Gone",
- StatusLengthRequired: "Length Required",
- StatusPreconditionFailed: "Precondition Failed",
- StatusRequestEntityTooLarge: "Request Entity Too Large",
- StatusRequestURITooLong: "Request URI Too Long",
- StatusUnsupportedMediaType: "Unsupported Media Type",
- StatusRequestedRangeNotSatisfiable: "Requested Range Not Satisfiable",
- StatusExpectationFailed: "Expectation Failed",
-
- StatusInternalServerError: "Internal Server Error",
- StatusNotImplemented: "Not Implemented",
- StatusBadGateway: "Bad Gateway",
- StatusServiceUnavailable: "Service Unavailable",
- StatusGatewayTimeout: "Gateway Timeout",
- StatusHTTPVersionNotSupported: "HTTP Version Not Supported",
+ RemoteAddr string; // network address of remote side
+ Req *Request; // current HTTP request
+
+ fd io.ReadWriteClose; // i/o connection
+ buf *bufio.BufReadWrite; // buffered fd
+ handler Handler; // request handler
+ hijacked bool; // connection has been hijacked by handler
+
+ // state for the current reply
+ closeAfterReply bool; // close connection after this reply
+ chunking bool; // using chunked transfer encoding for reply body
+ wroteHeader bool; // reply header has been written
+ header map[string] string; // reply header parameters
}
// Create new connection from rwc.
func newConn(rwc io.ReadWriteClose, raddr string, handler Handler) (c *Conn, err *os.Error) {
c = new(Conn);
- c.Fd = rwc;
c.RemoteAddr = raddr;
c.handler = handler;
- if c.br, err = bufio.NewBufRead(rwc.(io.Read)); err != nil {
- return nil, err
- }
-c.Br = c.br;
- if c.bw, err = bufio.NewBufWrite(rwc); err != nil {
- return nil, err
- }
+ c.fd = rwc;
+ br := bufio.NewBufRead(rwc);
+ bw := bufio.NewBufWrite(rwc);
+ c.buf = bufio.NewBufReadWrite(br, bw);
return c, nil
}
// Read next request from connection.
func (c *Conn) readRequest() (req *Request, err *os.Error) {
- if req, err = ReadRequest(c.br); err != nil {
+ if c.hijacked {
+ return nil, ErrHijacked
+ }
+ if req, err = ReadRequest(c.buf.BufRead); err != nil {
return nil, err
}
// Reset per-request connection state.
c.header = make(map[string] string);
c.wroteHeader = false;
- c.flushed = false;
c.Req = req;
// Default output is HTML encoded in UTF-8.
// a Content-Length: header in the response,
// but everyone who expects persistent connections
// does HTTP/1.1 now.
- c.close = true;
+ c.closeAfterReply = true;
c.chunking = false;
}
// Write header.
func (c *Conn) WriteHeader(code int) {
+ if c.hijacked {
+ log.Stderr("http: Conn.WriteHeader on hijacked connection");
+ return
+ }
if c.wroteHeader {
- // TODO(rsc): log
+ log.Stderr("http: multiple Conn.WriteHeader calls");
return
}
c.wroteHeader = true;
if !ok {
text = "status code " + codestring;
}
- io.WriteString(c.bw, proto + " " + codestring + " " + text + "\r\n");
+ io.WriteString(c.buf, proto + " " + codestring + " " + text + "\r\n");
for k,v := range c.header {
- io.WriteString(c.bw, k + ": " + v + "\r\n");
+ io.WriteString(c.buf, k + ": " + v + "\r\n");
}
- io.WriteString(c.bw, "\r\n");
+ io.WriteString(c.buf, "\r\n");
}
// TODO(rsc): BUG in 6g: must return "nn int" not "n int"
// so that the implicit struct assignment in
-// return c.bw.Write(data) works. oops
+// return c.buf.Write(data) works. oops
func (c *Conn) Write(data []byte) (nn int, err *os.Error) {
- if c.flushed {
- return 0, ErrWriteAfterFlush
+ if c.hijacked {
+ log.Stderr("http: Conn.Write on hijacked connection");
+ return 0, ErrHijacked
}
if !c.wroteHeader {
c.WriteHeader(StatusOK);
}
// TODO(rsc): if chunking happened after the buffering,
- // then there would be fewer chunk headers
+ // then there would be fewer chunk headers.
+ // On the other hand, it would make hijacking more difficult.
if c.chunking {
- fmt.Fprintf(c.bw, "%x\r\n", len(data)); // TODO(rsc): use strconv not fmt
+ fmt.Fprintf(c.buf, "%x\r\n", len(data)); // TODO(rsc): use strconv not fmt
}
- return c.bw.Write(data);
+ return c.buf.Write(data);
}
-func (c *Conn) Flush() {
- if c.flushed {
- return
- }
+func (c *Conn) flush() {
if !c.wroteHeader {
c.WriteHeader(StatusOK);
}
if c.chunking {
- io.WriteString(c.bw, "0\r\n");
+ io.WriteString(c.buf, "0\r\n");
// trailer key/value pairs, followed by blank line
- io.WriteString(c.bw, "\r\n");
+ io.WriteString(c.buf, "\r\n");
}
- c.bw.Flush();
- c.flushed = true;
+ c.buf.Flush();
}
// Close the connection.
-func (c *Conn) Close() {
- if c.bw != nil {
- c.bw.Flush();
- c.bw = nil;
+func (c *Conn) close() {
+ if c.buf != nil {
+ c.buf.Flush();
+ c.buf = nil;
}
- if c.Fd != nil {
- c.Fd.Close();
- c.Fd = nil;
+ if c.fd != nil {
+ c.fd.Close();
+ c.fd = nil;
}
}
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this thread.
c.handler.ServeHTTP(c, req);
- if c.Fd == nil {
- // Handler took over the connection.
+ if c.hijacked {
return;
}
- if !c.flushed {
- c.Flush();
- }
- if c.close {
+ c.flush();
+ if c.closeAfterReply {
break;
}
}
- c.Close();
+ c.close();
+}
+
+// Allow client to take over the connection.
+// After a handler calls c.Hijack(), the HTTP server library
+// will never touch the connection again.
+// It is the caller's responsibility to manage and close
+// the connection.
+func (c *Conn) Hijack() (fd io.ReadWriteClose, buf *bufio.BufReadWrite, err *os.Error) {
+ if c.hijacked {
+ return nil, nil, ErrHijacked;
+ }
+ c.hijacked = true;
+ fd = c.fd;
+ buf = c.buf;
+ c.fd = nil;
+ c.buf = nil;
+ return;
}
// Adapter: can use RequestFunction(f) as Handler
--- /dev/null
+// 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.
+
+// HTTP status codes. See RFC 2616.
+
+package http
+
+const (
+ StatusContinue = 100;
+ StatusSwitchingProtocols = 101;
+
+ StatusOK = 200;
+ StatusCreated = 201;
+ StatusAccepted = 202;
+ StatusNonAuthoritativeInfo = 203;
+ StatusNoContent = 204;
+ StatusResetContent = 205;
+ StatusPartialContent = 206;
+
+ StatusMultipleChoices = 300;
+ StatusMovedPermanently = 301;
+ StatusFound = 302;
+ StatusSeeOther = 303;
+ StatusNotModified = 304;
+ StatusUseProxy = 305;
+ StatusTemporaryRedirect = 307;
+
+ StatusBadRequest = 400;
+ StatusUnauthorized = 401;
+ StatusPaymentRequired = 402;
+ StatusForbidden = 403;
+ StatusNotFound = 404;
+ StatusMethodNotAllowed = 405;
+ StatusNotAcceptable = 406;
+ StatusProxyAuthRequired = 407;
+ StatusRequestTimeout = 408;
+ StatusConflict = 409;
+ StatusGone = 410;
+ StatusLengthRequired = 411;
+ StatusPreconditionFailed = 412;
+ StatusRequestEntityTooLarge = 413;
+ StatusRequestURITooLong = 414;
+ StatusUnsupportedMediaType = 415;
+ StatusRequestedRangeNotSatisfiable = 416;
+ StatusExpectationFailed = 417;
+
+ StatusInternalServerError = 500;
+ StatusNotImplemented = 501;
+ StatusBadGateway = 502;
+ StatusServiceUnavailable = 503;
+ StatusGatewayTimeout = 504;
+ StatusHTTPVersionNotSupported = 505;
+)
+
+var statusText = map[int]string {
+ StatusContinue: "Continue",
+ StatusSwitchingProtocols: "Switching Protocols",
+
+ StatusOK: "OK",
+ StatusCreated: "Created",
+ StatusAccepted: "Accepted",
+ StatusNonAuthoritativeInfo: "Non-Authoritative Information",
+ StatusNoContent: "No Content",
+ StatusResetContent: "Reset Content",
+ StatusPartialContent: "Partial Content",
+
+ StatusMultipleChoices: "Multiple Choices",
+ StatusMovedPermanently: "Moved Permanently",
+ StatusFound: "Found",
+ StatusSeeOther: "See Other",
+ StatusNotModified: "Not Modified",
+ StatusUseProxy: "Use Proxy",
+ StatusTemporaryRedirect: "Temporary Redirect",
+
+ StatusBadRequest: "Bad Request",
+ StatusUnauthorized: "Unauthorized",
+ StatusPaymentRequired: "Payment Required",
+ StatusForbidden: "Forbidden",
+ StatusNotFound: "Not Found",
+ StatusMethodNotAllowed: "Method Not Allowed",
+ StatusNotAcceptable: "Not Acceptable",
+ StatusProxyAuthRequired: "Proxy Authentication Required",
+ StatusRequestTimeout: "Request Timeout",
+ StatusConflict: "Conflict",
+ StatusGone: "Gone",
+ StatusLengthRequired: "Length Required",
+ StatusPreconditionFailed: "Precondition Failed",
+ StatusRequestEntityTooLarge: "Request Entity Too Large",
+ StatusRequestURITooLong: "Request URI Too Long",
+ StatusUnsupportedMediaType: "Unsupported Media Type",
+ StatusRequestedRangeNotSatisfiable: "Requested Range Not Satisfiable",
+ StatusExpectationFailed: "Expectation Failed",
+
+ StatusInternalServerError: "Internal Server Error",
+ StatusNotImplemented: "Not Implemented",
+ StatusBadGateway: "Bad Gateway",
+ StatusServiceUnavailable: "Service Unavailable",
+ StatusGatewayTimeout: "Gateway Timeout",
+ StatusHTTPVersionNotSupported: "HTTP Version Not Supported",
+}
+