package httpapi import ( "bufio" "crypto/sha1" "encoding/base64" "encoding/json" "fmt" "io" "net" "net/http" "sync" ) const websocketGUID = "258EAFA5-E914-47DA-95CA-5AB5D10B5E23" // websocketConn represents a websocket connection with send channel and mutex. type websocketConn struct { conn net.Conn send chan []byte mu sync.Mutex } // Hub manages websocket connections and broadcasts state updates. type Hub struct { clients map[*websocketConn]bool broadcast chan []byte register chan *websocketConn unregister chan *websocketConn mu sync.RWMutex } var hub *Hub var hubOnce sync.Once func getHub() *Hub { hubOnce.Do(func() { hub = &Hub{ clients: make(map[*websocketConn]bool), broadcast: make(chan []byte, 256), register: make(chan *websocketConn), unregister: make(chan *websocketConn), } go hub.run() }) return hub } func (h *Hub) run() { for { select { case client := <-h.register: h.mu.Lock() h.clients[client] = true h.mu.Unlock() case client := <-h.unregister: h.mu.Lock() if _, ok := h.clients[client]; ok { delete(h.clients, client) close(client.send) } h.mu.Unlock() case message := <-h.broadcast: h.mu.RLock() for client := range h.clients { select { case client.send <- message: default: close(client.send) delete(h.clients, client) } } h.mu.RUnlock() } } } // upgradeWebSocket performs a WebSocket handshake using raw net.Conn. func upgradeWebSocket(w http.ResponseWriter, r *http.Request) (*websocketConn, error) { key := r.Header.Get("Sec-WebSocket-Key") if key == "" { return nil, fmt.Errorf("missing Sec-WebSocket-Key") } // Calculate accept key h := sha1.New() h.Write([]byte(key + websocketGUID)) acceptKey := base64.StdEncoding.EncodeToString(h.Sum(nil)) // Hijack the connection hj, ok := w.(http.Hijacker) if !ok { return nil, fmt.Errorf("server does not support hijacking") } conn, bufrw, err := hj.Hijack() if err != nil { return nil, fmt.Errorf("hijack failed: %v", err) } // Write handshake response response := "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: " + acceptKey + "\r\n\r\n" bufrw.WriteString(response) bufrw.Flush() return &websocketConn{ conn: conn, send: make(chan []byte, 256), }, nil } // wsHandler handles websocket upgrades and client communication. func (s *Server) wsHandler(w http.ResponseWriter, r *http.Request) { conn, err := upgradeWebSocket(w, r) if err != nil { fmt.Fprintf(nil, "[ws] upgrade failed: %v\n", err) return } h := getHub() h.register <- conn go s.wsWriteHandler(conn) s.wsReadHandler(conn) } func (s *Server) wsWriteHandler(c *websocketConn) { for { message, ok := <-c.send if !ok { c.conn.Close() return } c.mu.Lock() _, err := c.conn.Write(message) c.mu.Unlock() if err != nil { c.conn.Close() return } } } func (s *Server) wsReadHandler(c *websocketConn) { br := bufio.NewReader(c.conn) for { line, err := br.ReadString('\n') if err != nil { if err != io.EOF { fmt.Fprintf(nil, "[ws] read error: %v\n", err) } h := getHub() h.unregister <- c return } _ = line // consume header lines if line == "\r\n" { break } } // Connection established, start reading frames // For simplicity, just keep reading until close for { data, err := br.ReadBytes(0xFF) if err != nil { h := getHub() h.unregister <- c return } _ = data } } // broadcastState broadcasts the current scoreboard state to all websocket clients. func (s *Server) broadcastState() { state := map[string]interface{}{ "current_round": s.sb.CurrentRound, "red_score": s.sb.RedScore, "green_score": s.sb.GreenScore, "rounds": s.sb.Rounds, } data, err := json.Marshal(state) if err != nil { fmt.Fprintf(nil, "[ws] JSON error: %v\n", err) return } h := getHub() h.broadcast <- data }