summaryrefslogtreecommitdiff
path: root/src/pkg/websocket
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/websocket')
-rw-r--r--src/pkg/websocket/client.go76
-rw-r--r--src/pkg/websocket/server.go40
-rw-r--r--src/pkg/websocket/websocket.go74
-rw-r--r--src/pkg/websocket/websocket_test.go48
4 files changed, 119 insertions, 119 deletions
diff --git a/src/pkg/websocket/client.go b/src/pkg/websocket/client.go
index bedaec02f..c81f4f440 100644
--- a/src/pkg/websocket/client.go
+++ b/src/pkg/websocket/client.go
@@ -5,40 +5,40 @@
package websocket
import (
- "bufio";
- "http";
- "io";
- "net";
- "os";
+ "bufio"
+ "http"
+ "io"
+ "net"
+ "os"
)
type ProtocolError struct {
- os.ErrorString;
+ os.ErrorString
}
var (
- ErrBadStatus = &ProtocolError{"bad status"};
- ErrNoUpgrade = &ProtocolError{"no upgrade"};
- ErrBadUpgrade = &ProtocolError{"bad upgrade"};
- ErrNoWebSocketOrigin = &ProtocolError{"no WebSocket-Origin"};
- ErrBadWebSocketOrigin = &ProtocolError{"bad WebSocket-Origin"};
- ErrNoWebSocketLocation = &ProtocolError{"no WebSocket-Location"};
- ErrBadWebSocketLocation = &ProtocolError{"bad WebSocket-Location"};
- ErrNoWebSocketProtocol = &ProtocolError{"no WebSocket-Protocol"};
- ErrBadWebSocketProtocol = &ProtocolError{"bad WebSocket-Protocol"};
+ ErrBadStatus = &ProtocolError{"bad status"}
+ ErrNoUpgrade = &ProtocolError{"no upgrade"}
+ ErrBadUpgrade = &ProtocolError{"bad upgrade"}
+ ErrNoWebSocketOrigin = &ProtocolError{"no WebSocket-Origin"}
+ ErrBadWebSocketOrigin = &ProtocolError{"bad WebSocket-Origin"}
+ ErrNoWebSocketLocation = &ProtocolError{"no WebSocket-Location"}
+ ErrBadWebSocketLocation = &ProtocolError{"bad WebSocket-Location"}
+ ErrNoWebSocketProtocol = &ProtocolError{"no WebSocket-Protocol"}
+ ErrBadWebSocketProtocol = &ProtocolError{"bad WebSocket-Protocol"}
)
// newClient creates a new Web Socket client connection.
func newClient(resourceName, host, origin, location, protocol string, rwc io.ReadWriteCloser) (ws *Conn, err os.Error) {
- br := bufio.NewReader(rwc);
- bw := bufio.NewWriter(rwc);
- err = handshake(resourceName, host, origin, location, protocol, br, bw);
+ br := bufio.NewReader(rwc)
+ bw := bufio.NewWriter(rwc)
+ err = handshake(resourceName, host, origin, location, protocol, br, bw)
if err != nil {
return
}
- buf := bufio.NewReadWriter(br, bw);
- ws = newConn(origin, location, protocol, buf, rwc);
- return;
+ buf := bufio.NewReadWriter(br, bw)
+ ws = newConn(origin, location, protocol, buf, rwc)
+ return
}
// Dial opens new Web Socket client connection.
@@ -68,55 +68,55 @@ func newClient(resourceName, host, origin, location, protocol string, rwc io.Rea
// }
func Dial(url, protocol, origin string) (ws *Conn, err os.Error) {
- parsedUrl, err := http.ParseURL(url);
+ parsedUrl, err := http.ParseURL(url)
if err != nil {
return
}
- client, err := net.Dial("tcp", "", parsedUrl.Host);
+ client, err := net.Dial("tcp", "", parsedUrl.Host)
if err != nil {
return
}
- return newClient(parsedUrl.Path, parsedUrl.Host, origin, url, protocol, client);
+ return newClient(parsedUrl.Path, parsedUrl.Host, origin, url, protocol, client)
}
func handshake(resourceName, host, origin, location, protocol string, br *bufio.Reader, bw *bufio.Writer) (err os.Error) {
- bw.WriteString("GET " + resourceName + " HTTP/1.1\r\n");
- bw.WriteString("Upgrade: WebSocket\r\n");
- bw.WriteString("Connection: Upgrade\r\n");
- bw.WriteString("Host: " + host + "\r\n");
- bw.WriteString("Origin: " + origin + "\r\n");
+ bw.WriteString("GET " + resourceName + " HTTP/1.1\r\n")
+ bw.WriteString("Upgrade: WebSocket\r\n")
+ bw.WriteString("Connection: Upgrade\r\n")
+ bw.WriteString("Host: " + host + "\r\n")
+ bw.WriteString("Origin: " + origin + "\r\n")
if protocol != "" {
bw.WriteString("WebSocket-Protocol: " + protocol + "\r\n")
}
- bw.WriteString("\r\n");
- bw.Flush();
- resp, err := http.ReadResponse(br);
+ bw.WriteString("\r\n")
+ bw.Flush()
+ resp, err := http.ReadResponse(br)
if err != nil {
return
}
if resp.Status != "101 Web Socket Protocol Handshake" {
return ErrBadStatus
}
- upgrade, found := resp.Header["Upgrade"];
+ upgrade, found := resp.Header["Upgrade"]
if !found {
return ErrNoUpgrade
}
if upgrade != "WebSocket" {
return ErrBadUpgrade
}
- connection, found := resp.Header["Connection"];
+ connection, found := resp.Header["Connection"]
if !found || connection != "Upgrade" {
return ErrBadUpgrade
}
- ws_origin, found := resp.Header["Websocket-Origin"];
+ ws_origin, found := resp.Header["Websocket-Origin"]
if !found {
return ErrNoWebSocketOrigin
}
if ws_origin != origin {
return ErrBadWebSocketOrigin
}
- ws_location, found := resp.Header["Websocket-Location"];
+ ws_location, found := resp.Header["Websocket-Location"]
if !found {
return ErrNoWebSocketLocation
}
@@ -124,7 +124,7 @@ func handshake(resourceName, host, origin, location, protocol string, br *bufio.
return ErrBadWebSocketLocation
}
if protocol != "" {
- ws_protocol, found := resp.Header["Websocket-Protocol"];
+ ws_protocol, found := resp.Header["Websocket-Protocol"]
if !found {
return ErrNoWebSocketProtocol
}
@@ -132,5 +132,5 @@ func handshake(resourceName, host, origin, location, protocol string, br *bufio.
return ErrBadWebSocketProtocol
}
}
- return;
+ return
}
diff --git a/src/pkg/websocket/server.go b/src/pkg/websocket/server.go
index e2d8cecbb..bf80f6cc0 100644
--- a/src/pkg/websocket/server.go
+++ b/src/pkg/websocket/server.go
@@ -5,8 +5,8 @@
package websocket
import (
- "http";
- "io";
+ "http"
+ "io"
)
// Handler is a interface that use a WebSocket.
@@ -39,35 +39,35 @@ func (f Handler) ServeHTTP(c *http.Conn, req *http.Request) {
if req.Method != "GET" || req.Proto != "HTTP/1.1" ||
req.Header["Upgrade"] != "WebSocket" ||
req.Header["Connection"] != "Upgrade" {
- c.WriteHeader(http.StatusNotFound);
- io.WriteString(c, "must use websocket to connect here");
- return;
+ c.WriteHeader(http.StatusNotFound)
+ io.WriteString(c, "must use websocket to connect here")
+ return
}
- rwc, buf, err := c.Hijack();
+ rwc, buf, err := c.Hijack()
if err != nil {
- panic("Hijack failed: ", err.String());
- return;
+ panic("Hijack failed: ", err.String())
+ return
}
- defer rwc.Close();
- origin := req.Header["Origin"];
- location := "ws://" + req.Host + req.URL.Path;
+ defer rwc.Close()
+ origin := req.Header["Origin"]
+ location := "ws://" + req.Host + req.URL.Path
// TODO(ukai): verify origin,location,protocol.
- buf.WriteString("HTTP/1.1 101 Web Socket Protocol Handshake\r\n");
- buf.WriteString("Upgrade: WebSocket\r\n");
- buf.WriteString("Connection: Upgrade\r\n");
- buf.WriteString("WebSocket-Origin: " + origin + "\r\n");
- buf.WriteString("WebSocket-Location: " + location + "\r\n");
- protocol := "";
+ buf.WriteString("HTTP/1.1 101 Web Socket Protocol Handshake\r\n")
+ buf.WriteString("Upgrade: WebSocket\r\n")
+ buf.WriteString("Connection: Upgrade\r\n")
+ buf.WriteString("WebSocket-Origin: " + origin + "\r\n")
+ buf.WriteString("WebSocket-Location: " + location + "\r\n")
+ protocol := ""
// canonical header key of WebSocket-Protocol.
if protocol, found := req.Header["Websocket-Protocol"]; found {
buf.WriteString("WebSocket-Protocol: " + protocol + "\r\n")
}
- buf.WriteString("\r\n");
+ buf.WriteString("\r\n")
if err := buf.Flush(); err != nil {
return
}
- ws := newConn(origin, location, protocol, buf, rwc);
- f(ws);
+ ws := newConn(origin, location, protocol, buf, rwc)
+ f(ws)
}
diff --git a/src/pkg/websocket/websocket.go b/src/pkg/websocket/websocket.go
index 373961d57..efcb228b3 100644
--- a/src/pkg/websocket/websocket.go
+++ b/src/pkg/websocket/websocket.go
@@ -12,52 +12,52 @@ package websocket
// better logging.
import (
- "bufio";
- "io";
- "net";
- "os";
+ "bufio"
+ "io"
+ "net"
+ "os"
)
type WebSocketAddr string
-func (addr WebSocketAddr) Network() string { return "websocket" }
+func (addr WebSocketAddr) Network() string { return "websocket" }
-func (addr WebSocketAddr) String() string { return string(addr) }
+func (addr WebSocketAddr) String() string { return string(addr) }
// Conn is an channels to communicate over Web Socket.
type Conn struct {
// An origin URI of the Web Socket.
- Origin string;
+ Origin string
// A location URI of the Web Socket.
- Location string;
+ Location string
// A subprotocol of the Web Socket.
- Protocol string;
+ Protocol string
- buf *bufio.ReadWriter;
- rwc io.ReadWriteCloser;
+ buf *bufio.ReadWriter
+ rwc io.ReadWriteCloser
}
// newConn creates a new Web Socket.
func newConn(origin, location, protocol string, buf *bufio.ReadWriter, rwc io.ReadWriteCloser) *Conn {
if buf == nil {
- br := bufio.NewReader(rwc);
- bw := bufio.NewWriter(rwc);
- buf = bufio.NewReadWriter(br, bw);
+ br := bufio.NewReader(rwc)
+ bw := bufio.NewWriter(rwc)
+ buf = bufio.NewReadWriter(br, bw)
}
- ws := &Conn{origin, location, protocol, buf, rwc};
- return ws;
+ ws := &Conn{origin, location, protocol, buf, rwc}
+ return ws
}
func (ws *Conn) Read(msg []byte) (n int, err os.Error) {
for {
- frameByte, err := ws.buf.ReadByte();
+ frameByte, err := ws.buf.ReadByte()
if err != nil {
return n, err
}
if (frameByte & 0x80) == 0x80 {
- length := 0;
+ length := 0
for {
- c, err := ws.buf.ReadByte();
+ c, err := ws.buf.ReadByte()
if err != nil {
return n, err
}
@@ -68,15 +68,15 @@ func (ws *Conn) Read(msg []byte) (n int, err os.Error) {
}
}
for length > 0 {
- _, err := ws.buf.ReadByte();
+ _, err := ws.buf.ReadByte()
if err != nil {
return n, err
}
- length--;
+ length--
}
} else {
for {
- c, err := ws.buf.ReadByte();
+ c, err := ws.buf.ReadByte()
if err != nil {
return n, err
}
@@ -87,8 +87,8 @@ func (ws *Conn) Read(msg []byte) (n int, err os.Error) {
if n+1 <= cap(msg) {
msg = msg[0 : n+1]
}
- msg[n] = c;
- n++;
+ msg[n] = c
+ n++
}
if n >= cap(msg) {
return n, os.E2BIG
@@ -97,42 +97,42 @@ func (ws *Conn) Read(msg []byte) (n int, err os.Error) {
}
}
- panic("unreachable");
+ panic("unreachable")
}
func (ws *Conn) Write(msg []byte) (n int, err os.Error) {
- ws.buf.WriteByte(0);
- ws.buf.Write(msg);
- ws.buf.WriteByte(0xff);
- err = ws.buf.Flush();
- return len(msg), err;
+ ws.buf.WriteByte(0)
+ ws.buf.Write(msg)
+ ws.buf.WriteByte(0xff)
+ err = ws.buf.Flush()
+ return len(msg), err
}
-func (ws *Conn) Close() os.Error { return ws.rwc.Close() }
+func (ws *Conn) Close() os.Error { return ws.rwc.Close() }
-func (ws *Conn) LocalAddr() net.Addr { return WebSocketAddr(ws.Origin) }
+func (ws *Conn) LocalAddr() net.Addr { return WebSocketAddr(ws.Origin) }
-func (ws *Conn) RemoteAddr() net.Addr { return WebSocketAddr(ws.Location) }
+func (ws *Conn) RemoteAddr() net.Addr { return WebSocketAddr(ws.Location) }
func (ws *Conn) SetTimeout(nsec int64) os.Error {
if conn, ok := ws.rwc.(net.Conn); ok {
return conn.SetTimeout(nsec)
}
- return os.EINVAL;
+ return os.EINVAL
}
func (ws *Conn) SetReadTimeout(nsec int64) os.Error {
if conn, ok := ws.rwc.(net.Conn); ok {
return conn.SetReadTimeout(nsec)
}
- return os.EINVAL;
+ return os.EINVAL
}
func (ws *Conn) SetWriteTimeout(nsec int64) os.Error {
if conn, ok := ws.rwc.(net.Conn); ok {
return conn.SetWriteTimeout(nsec)
}
- return os.EINVAL;
+ return os.EINVAL
}
-var _ net.Conn = (*Conn)(nil) // compile-time check that *Conn implements net.Conn.
+var _ net.Conn = (*Conn)(nil) // compile-time check that *Conn implements net.Conn.
diff --git a/src/pkg/websocket/websocket_test.go b/src/pkg/websocket/websocket_test.go
index ed2505313..c62604621 100644
--- a/src/pkg/websocket/websocket_test.go
+++ b/src/pkg/websocket/websocket_test.go
@@ -5,57 +5,57 @@
package websocket
import (
- "bytes";
- "http";
- "io";
- "log";
- "net";
- "once";
- "strings";
- "testing";
+ "bytes"
+ "http"
+ "io"
+ "log"
+ "net"
+ "once"
+ "strings"
+ "testing"
)
var serverAddr string
-func echoServer(ws *Conn) { io.Copy(ws, ws) }
+func echoServer(ws *Conn) { io.Copy(ws, ws) }
func startServer() {
- l, e := net.Listen("tcp", ":0"); // any available address
+ l, e := net.Listen("tcp", ":0") // any available address
if e != nil {
log.Exitf("net.Listen tcp :0 %v", e)
}
- serverAddr = l.Addr().String();
- log.Stderr("Test WebSocket server listening on ", serverAddr);
- http.Handle("/echo", Handler(echoServer));
- go http.Serve(l, nil);
+ serverAddr = l.Addr().String()
+ log.Stderr("Test WebSocket server listening on ", serverAddr)
+ http.Handle("/echo", Handler(echoServer))
+ go http.Serve(l, nil)
}
func TestEcho(t *testing.T) {
- once.Do(startServer);
+ once.Do(startServer)
- client, err := net.Dial("tcp", "", serverAddr);
+ client, err := net.Dial("tcp", "", serverAddr)
if err != nil {
t.Fatal("dialing", err)
}
ws, err := newClient("/echo", "localhost", "http://localhost",
- "ws://localhost/echo", "", client);
+ "ws://localhost/echo", "", client)
if err != nil {
- t.Errorf("WebSocket handshake error", err);
- return;
+ t.Errorf("WebSocket handshake error", err)
+ return
}
- msg := strings.Bytes("hello, world\n");
+ msg := strings.Bytes("hello, world\n")
if _, err := ws.Write(msg); err != nil {
t.Errorf("Write: error %v", err)
}
- var actual_msg = make([]byte, 512);
- n, err := ws.Read(actual_msg);
+ var actual_msg = make([]byte, 512)
+ n, err := ws.Read(actual_msg)
if err != nil {
t.Errorf("Read: error %v", err)
}
- actual_msg = actual_msg[0:n];
+ actual_msg = actual_msg[0:n]
if !bytes.Equal(msg, actual_msg) {
t.Errorf("Echo: expected %q got %q", msg, actual_msg)
}
- ws.Close();
+ ws.Close()
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-02 13:04:35 +0000