code review 5058043: websocket: add mutex to make websocket full-duplex

src/pkg/websocket/websocket.go

 // 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 websocket implements a client and server for the WebSocket protocol.
 // The protocol is defined at http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol
 package websocket
 
 import (
         "bufio"
         "crypto/tls"
         "http"
         "io"
         "io/ioutil"
         "json"
         "net"
         "os"
+        "sync"
         "url"
 )
 
 const (
         ProtocolVersionHixie75 = -75
         ProtocolVersionHixie76 = -76
         ProtocolVersionHybi00  = 0
         ProtocolVersionHybi    = 8
 
         ContinuationFrame = 0
@@ skipping 112 matching lines @@
 }
 
 // Conn represents a WebSocket connection.
 type Conn struct {
         config  *Config
         request *http.Request
 
         buf *bufio.ReadWriter
         rwc io.ReadWriteCloser
 
+        rio sync.Mutex
         frameReaderFactory
         frameReader
 
+        wio sync.Mutex
         frameWriterFactory
 
         frameHandler
         PayloadType        byte
         defaultCloseStatus int
 }
 
 // Read implements the io.Reader interface:
 // it reads data of a frame from the WebSocket connection.
 // if msg is not large enough for the frame data, it fills the msg and next Read
 // will read the rest of the frame data.
 // it reads Text frame or Binary frame.
 func (ws *Conn) Read(msg []byte) (n int, err os.Error) {
+        ws.rio.Lock()
+        defer ws.rio.Unlock()
 again:
         if ws.frameReader == nil {
                 frame, err := ws.frameReaderFactory.NewFrameReader()
                 if err != nil {
                         return 0, err
                 }
                 ws.frameReader, err = ws.frameHandler.HandleFrame(frame)
                 if err != nil {
                         return 0, err
                 }
                 if ws.frameReader == nil {
                         goto again
                 }
         }
         n, err = ws.frameReader.Read(msg)
         if err == os.EOF {
                 if trailer := ws.frameReader.TrailerReader(); trailer != nil {
                         io.Copy(ioutil.Discard, trailer)
                 }
                 ws.frameReader = nil
                 goto again
         }
         return n, err
 }
 
 // Write implements the io.Writer interface:
 // it writes data as a frame to the WebSocket connection.
 func (ws *Conn) Write(msg []byte) (n int, err os.Error) {
+        ws.wio.Lock()
+        defer ws.wio.Unlock()
         w, err := ws.frameWriterFactory.NewFrameWriter(ws.PayloadType)
         if err != nil {
                 return 0, err
         }
         n, err = w.Write(msg)
         w.Close()
         if err != nil {
                 return n, err
         }
         return n, err
@@ skipping 68 matching lines @@
 
 // Send sends v marshaled by cd.Marshal as single frame to ws.
 func (cd Codec) Send(ws *Conn, v interface{}) (err os.Error) {
         if err != nil {
                 return err
         }
         data, payloadType, err := cd.Marshal(v)
         if err != nil {
                 return err
         }
+        ws.wio.Lock()
+        defer ws.wio.Unlock()
         w, err := ws.frameWriterFactory.NewFrameWriter(payloadType)
         _, err = w.Write(data)
         w.Close()
         return err
 }
 
 // Receive receives single frame from ws, unmarshaled by cd.Unmarshal and stores in v.
 func (cd Codec) Receive(ws *Conn, v interface{}) (err os.Error) {
+        ws.rio.Lock()
+        defer ws.rio.Unlock()
         if ws.frameReader != nil {
                 _, err = io.Copy(ioutil.Discard, ws.frameReader)
                 if err != nil {
                         return err
                 }
                 ws.frameReader = nil
         }
 again:
         frame, err := ws.frameReaderFactory.NewFrameReader()
         if err != nil {
@@ skipping 86 matching lines @@
         }
 
         // receive JSON type T
         var data T
         websocket.JSON.Receive(ws, &data)
 
         // send JSON type T
         websocket.JSON.Send(ws, data)
 */
 var JSON = Codec{jsonMarshal, jsonUnmarshal}