}
// Chop off trailing white space.
- var i int
+ var i int;
for i = len(p); i > 0; i-- {
if c := p[i-1]; c != ' ' && c != '\r' && c != '\t' && c != '\n' {
break
// ReadLineByte, but convert the bytes into a string.
func ReadLine(b *bufio.BufRead) (s string, err *os.Error) {
- p, e := ReadLineBytes(b)
+ p, e := ReadLineBytes(b);
if e != nil {
return "", e
}
// and the Value can continue on multiple lines if each continuation line
// starts with a space.
func ReadKeyValue(b *bufio.BufRead) (key, value string, err *os.Error) {
- line, e := ReadLineBytes(b)
+ line, e := ReadLineBytes(b);
if e != nil {
return "", "", e
}
switch line[i] {
case ' ':
// Key field has space - no good.
- return "", "", BadHeader
+ return "", "", BadHeader;
case ':':
key = string(line[0:i]);
// Skip initial space before value.
break
}
}
- value = string(line[i:len(line)])
+ value = string(line[i:len(line)]);
// Look for extension lines, which must begin with space.
for {
}
if c != ' ' {
// Not leading space; stop.
- b.UnreadByte()
+ b.UnreadByte();
break
}
return "", "", e
}
}
- b.UnreadByte()
+ b.UnreadByte();
// Read the rest of the line and add to value.
if line, e = ReadLineBytes(b); e != nil {
return "", "", e
}
- value += " " + string(line)
+ value += " " + string(line);
if len(value) >= MaxValueLength {
return "", "", ValueTooLong
// returning value, string position where the digits stopped,
// and whether there was a valid number (digits, not too big).
func atoi(s string, i int) (n, i1 int, ok bool) {
- const Big = 1000000
+ const Big = 1000000;
if i >= len(s) || s[i] < '0' || s[i] > '9' {
return 0, 0, false
}
- n = 0
+ n = 0;
for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
- n = n*10 + int(s[i]-'0')
+ n = n*10 + int(s[i]-'0');
if n > Big {
return 0, 0, false
}
if vers[0:5] != "HTTP/" {
return 0, 0, false
}
- major, i, ok := atoi(vers, 5)
+ major, i, ok := atoi(vers, 5);
if !ok || i >= len(vers) || vers[i] != '.' {
return 0, 0, false
}
var minor int;
- minor, i, ok = atoi(vers, i+1)
+ minor, i, ok = atoi(vers, i+1);
if !ok || i != len(vers) {
return 0, 0, false
}
req = new(Request);
// First line: GET /index.html HTTP/1.0
- var s string
+ var s string;
if s, err = ReadLine(b); err != nil {
return nil, err
}
- var f *[]string
+ var f *[]string;
if f = strings.split(s, " "); len(f) != 3 {
return nil, BadRequest
}
- req.method, req.rawurl, req.proto = f[0], f[1], f[2]
+ req.method, req.rawurl, req.proto = f[0], f[1], f[2];
var ok bool;
if req.pmajor, req.pminor, ok = ParseHTTPVersion(req.proto); !ok {
return nil, BadHTTPVersion
// Subsequent lines: Key: value.
nheader := 0;
- req.header = new(map[string] string)
+ req.header = new(map[string] string);
for {
- var key, value string
+ var key, value string;
if key, value, err = ReadKeyValue(b); err != nil {
return nil, err
}
// RFC 2616 says that if you send the same header key
// multiple times, it has to be semantically equivalent
// to concatenating the values separated by commas.
- oldvalue, present := req.header[key]
+ oldvalue, present := req.header[key];
if present {
req.header[key] = oldvalue+","+value
} else {
// Serve a new connection.
func ServeConnection(fd net.Conn, raddr string, f *(*Conn, *Request)) {
- c, err := NewConn(fd)
+ c, err := NewConn(fd);
if err != nil {
return
}
for {
- req, err := c.ReadRequest()
+ req, err := c.ReadRequest();
if err != nil {
break
}
- f(c, req)
+ f(c, req);
if c.close {
break
}
}
for {
- rw, raddr, e := l.Accept()
+ rw, raddr, e := l.Accept();
if e != nil {
return e
}
// Web server: listen on address, call f for each request.
export func ListenAndServe(addr string, f *(*Conn, *Request)) *os.Error {
- l, e := net.Listen("tcp", addr)
+ l, e := net.Listen("tcp", addr);
if e != nil {
return e
}
e = Serve(l, f);
- l.Close()
+ l.Close();
return e
}
func IsHex(c byte) bool {
switch {
case '0' <= c && c <= '9':
- return true
+ return true;
case 'a' <= c && c <= 'f':
- return true
+ return true;
case 'A' <= c && c <= 'F':
- return true
+ return true;
}
return false
}
func UnHex(c byte) byte {
switch {
case '0' <= c && c <= '9':
- return c - '0'
+ return c - '0';
case 'a' <= c && c <= 'f':
- return c - 'a' + 10
+ return c - 'a' + 10;
case 'A' <= c && c <= 'F':
- return c - 'A' + 10
+ return c - 'A' + 10;
}
return 0
}
// Unescape %xx into hex.
export func URLUnescape(s string) (string, *os.Error) {
// Count %, check that they're well-formed.
- n := 0
+ n := 0;
for i := 0; i < len(s); {
if s[i] == '%' {
- n++
+ n++;
if !IsHex(s[i+1]) || !IsHex(s[i+2]) {
- return "", BadURL
+ return "", BadURL;
}
i += 3
} else {
}
t := new([]byte, len(s)-2*n);
- j := 0
+ j := 0;
for i := 0; i < len(s); {
if s[i] == '%' {
t[j] = UnHex(s[i+1]) << 4 | UnHex(s[i+2]);
- j++
- i += 3
+ j++;
+ i += 3;
} else {
t[j] = s[i];
- j++
- i++
+ j++;
+ i++;
}
}
- return string(t), nil
+ return string(t), nil;
}
export type URL struct {
return nil, BadURL
}
url = new(URL);
- url.raw = rawurl
+ url.raw = rawurl;
// Split off possible leading "http:", "mailto:", etc.
- var path string
+ var path string;
if url.scheme, path, err = GetScheme(rawurl); err != nil {
return nil, err
}
- url.rawpath = path
+ url.rawpath = path;
// RFC 2396: a relative URI (no scheme) has a ?query,
// but absolute URIs only have query if path begins with /