Remote-Gameplay/core/signal.go

package core

import (
    "crypto/tls"
    "fmt"
    "github.com/Akilan1999/remotegameplay/config"
    "github.com/gorilla/websocket"
    "log"
    "net/http"
    "time"
)

type WSMessage struct {
    SessionID string
    Type      string
    Value     string
}

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func sendHeartBeatWS(ticker *time.Ticker, conn *websocket.Conn, quit chan struct{}) {
    for {
        select {
        case <-ticker.C:
            _ = conn.WriteJSON(WSMessage{
                Type: "beat",
            })
        case <-quit:
            log.Println("heartbeat stopped")
            return
        }
    }
}

func GetHttp() *http.ServeMux {
    http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
    server := http.NewServeMux()

    server.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("files/static"))))

    server.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, "files/main.html")
    })

    //Get hostname of the current machine
    server.HandleFunc("/hostname", func(w http.ResponseWriter, r *http.Request) {

        // Read hostname from config file
        configResp, err := config.ConfigInit()
        if err != nil {
            print(err)
            return
        }

        fmt.Fprintf(w, configResp.SystemUsername)
    })

    //Get SSH password of the current machine
    server.HandleFunc("/SSHPassword", func(w http.ResponseWriter, r *http.Request) {

        // Read hostname from config file
        configResp, err := config.ConfigInit()
        if err != nil {
            print(err)
            return
        }

        fmt.Fprintf(w, configResp.SSHPassword)
    })

    server.HandleFunc("/ws_serve", func(writer http.ResponseWriter, request *http.Request) {
        conn, _ := upgrader.Upgrade(writer, request, nil)
        room := NewRoom(conn)
        if err := conn.WriteJSON(WSMessage{
            SessionID: "",
            Type:      "newRoom",
            Value:     room.ID,
        }); err != nil {
            log.Println("newSessionWriteJsonError.", err)
            return
        }

        go func(r *Room) {
            ticker := time.NewTicker(10 * time.Second)
            quit := make(chan struct{})
            defer func() {
                ticker.Stop()
                _ = room.CallerConn.Close()
                close(quit)
                RemoveRoom(r.ID)

                // Close the barrier session
                if r.BarrierSession != nil {
                    r.BarrierSession.DeleteBarrierSession()
                }

                for sID, s := range r.Sessions {
                    _ = s.CalleeConn.WriteJSON(WSMessage{
                        Type:      "roomClosed",
                        SessionID: sID,
                    })
                }
            }()

            go sendHeartBeatWS(ticker, conn, quit)

            //noinspection ALL
            defer room.CallerConn.Close()
            for {
                var msg WSMessage
                if err := room.CallerConn.ReadJSON(&msg); err != nil {
                    log.Println("websocketError.", err)
                    return
                }
                //log.Println(msg)
                s := room.GetSession(msg.SessionID)
                if s == nil {
                    log.Println("session nil.", msg.SessionID)
                }
                if msg.Type == "addCallerIceCandidate" {
                    s.CallerIceCandidates = append(s.CallerIceCandidates, msg.Value)
                } else if msg.Type == "gotOffer" {
                    s.Offer = msg.Value
                }
                if err := s.CalleeConn.WriteJSON(msg); err != nil {
                    log.Println("serveEchoWriteJsonError.", err)
                }
            }
        }(room)
    })

    server.HandleFunc("/ws_connect", func(writer http.ResponseWriter, request *http.Request) {
        conn, _ := upgrader.Upgrade(writer, request, nil)

        ids, ok := request.URL.Query()["id"]

        if !ok || ids[0] == "" {
            return
        }

        room := GetRoom(ids[0])

        ip, ok := request.URL.Query()["barrierip"]

        fmt.Println(ip)

        if ok && ip[0] != "" {
            //Declaring struct
            var barriersession Barrier
            barriersession.IPAddress = ip[0]
            room.BarrierSession = &barriersession
            // Creates a barrier session
            err := room.BarrierSession.CreateBarrierSession()
            if err != nil {
                return
            }
        }

        if room == nil {
            _ = conn.WriteJSON(WSMessage{
                Type: "roomNotFound",
            })
            return
        }

        session := room.NewSession(conn)

        if err := room.CallerConn.WriteJSON(WSMessage{
            SessionID: session.ID,
            Type:      "newSession",
            Value:     session.ID,
        }); err != nil {
            log.Println("callerWriteJsonError.", err)
            return
        }

        if err := conn.WriteJSON(WSMessage{
            SessionID: session.ID,
            Type:      "newSession",
            Value:     session.ID,
        }); err != nil {
            log.Println("calleeWriteJsonError.", err)
            return
        }

        go func(s *StreamSession) {
            //noinspection ALL
            defer s.CalleeConn.Close()
            for {
                var msg WSMessage
                if err := conn.ReadJSON(&msg); err != nil {
                    log.Println("websocketError.", err)
                    return
                }
                //log.Println(msg)
                if msg.SessionID == s.ID {
                    if msg.Type == "addCalleeIceCandidate" {
                        s.CalleeIceCandidates = append(s.CalleeIceCandidates, msg.Value)
                    } else if msg.Type == "gotAnswer" {
                        s.Answer = msg.Value
                    }
                    if err := s.CallerConn.WriteJSON(msg); err != nil {
                        log.Println("connectEchoWriteJsonError.", err)
                    }
                }
            }
        }(session)
    })

    return server
}