func handleWebSocket(conn *websocket.Conn) {
respStatus := http.StatusOK
defer func() {
conn.Close()
logRequest(HTTPS_WEBSOCKET, respStatus, conn.Request().Host, conn.Request())
}()
request := make([]byte, 1024)
for {
n, err := conn.Read(request)
if err != nil {
if debugMode {
log.Error("Error reading on WebSocket: %s", err)
}
break
}
response, status := getLiveItems(string(request[:n]))
if status != http.StatusOK {
respStatus = status
break
}
if len(response) != 0 {
if _, err = conn.Write(response); err != nil {
break
}
}
}
}
func clientHandler(ws *websocket.Conn) {
defer func() {
subscriptionChan <- subscription{ws, false}
ws.Close()
}()
subscriptionChan <- subscription{ws, true}
for {
buf := make([]byte, 128)
n, err := ws.Read(buf)
if err != nil {
log.Print("Reading Buffer: ", err)
break
}
var m message
err = json.Unmarshal(buf[0:n], &m)
if err != nil {
log.Print("Parsing JSON: ", buf, m, err)
break
}
messageChan <- message{m.Text, m.Id, m.User, m.Command}
}
}
/*
* Get messages from client
*/
func clientHandler(ws *websocket.Conn) {
defer func() {
log.Println("Client handler closed.")
ws.Close()
}()
buf := make([]byte, 256)
stopCh := make(chan bool)
var input ProcessInput
for {
n, err := ws.Read(buf)
if err != nil {
break
}
// get data
err = json.Unmarshal(buf[0:n], &input)
if err != nil {
stopCh <- true
break
}
workChan <- Work{ws, &input, stopCh}
}
}
func IsClosed(ws *websocket.Conn) bool {
var ibuff [50]byte
_, err := ws.Read(ibuff[0:50])
if err != nil {
return true
}
return false
}
func ReadThread(ws *websocket.Conn, msg []byte, ch chan int) {
for {
n, error := ws.Read(msg)
if error != nil {
fmt.Println("WebSocket read error: ", error)
ch <- 0
break
}
ch <- n
if n == 0 {
break
}
}
}
func sub(ws *websocket.Conn) {
println("Beginning Sub")
var resp = make([]byte, 512)
for {
println("Waiting Read")
_, err := ws.Read(resp)
if err != nil {
panic(err)
}
// fmt.Println("Received 1:", string(resp[0:n]))
// fmt.Println("Received %v:", n)
ch <- 1
}
}
func clientHandler(ws *websocket.Conn) {
defer func() {
subscriptionChan <- subscription{ws, false}
ws.Close()
}()
subscriptionChan <- subscription{ws, true}
buf := make([]byte, 256)
for {
n, err := ws.Read(buf)
if err != nil {
break
}
messageChan <- buf[0:n]
}
}
func indexHandler(ws *websocket.Conn) {
var ibuff [50]byte
i, err := ws.Read(ibuff[0:50])
if err != nil {
fmt.Printf("WebSocket error: " + err.String())
return
}
msg := string(ibuff[0:i])
idx := strings.Index(msg, "!")
if idx < 0 {
fmt.Printf("Salt not found\n")
return
}
idstr := msg[0:idx]
salt := msg[idx+1:]
uid, err := strconv.Atoui64(idstr)
if err != nil {
fmt.Printf("User ID invalid\n")
return
}
defer UnlinkUser(uid, ws)
usr := LinkUser(uid, salt, ws)
if usr == nil {
fmt.Printf("Cannot link with User ID\n")
return
}
for usr.exit == false {
time.Sleep(1e8)
if IsClosed(ws) {
break
}
}
}
func doEventStream(ws *websocket.Conn) {
ID := chat.UUID()
defer func() {
subscriptionChan <- &Subscription{ws, chat.REMOVE_CONNECTION, &User{ID, nil, ""}}
ws.Close()
}()
subscriptionChan <- &Subscription{ws, chat.ADD_CONNECTION, &User{ID, nil, ""}}
newStartMessage, _ := json.Marshal(
MessageData{
"start",
map[string]interface{}{
"ID": ID,
}})
ws.Write(newStartMessage)
for {
buf := make([]byte, 1024)
n, err := ws.Read(buf)
if err != nil {
log.Println("Error reading from websocket connection: ", err.Error())
break
}
newMessageData := new(MessageData)
err = json.Unmarshal(buf[0:n], newMessageData)
if err != nil {
log.Println("Error unmarshaling message: ", string(buf[0:n]), " : ", err.Error())
}
messageChan <- message{
ws,
*newMessageData,
}
}
}
func broadcastHandler(ws *websocket.Conn) {
defer func() {
subscriptionChan <- subscription{ws, false}
ws.Close()
fmt.Printf("Closed \n")
}()
fmt.Printf("Adding to subscription \n")
subscriptionChan <- subscription{ws, true}
fmt.Printf("Added to subscription \n")
buf := make([]byte, 256)
for {
n, err := ws.Read(buf)
fmt.Printf("Reding message %v \n", n)
if err != nil {
break
}
messageChan <- buf[0:n]
}
}
func doEventStream(ws *websocket.Conn) {
defer func() {
subscriptionChan <- subscription{ws, false}
ws.Close()
}()
subscriptionChan <- subscription{ws, true}
for {
buf := make([]byte, 512)
n, err := ws.Read(buf)
if err != nil {
log.Println("Error reading from websocket connection")
break
}
messageChan <- message{
ws,
buf[0:n],
}
}
}
func wssServe(ws *websocket.Conn) {
fmt.Println("Socket connect")
ws.Write([]byte(strconv.Itoa(int(*state))))
b := make([]byte, 2)
var quit bool
for !quit {
ws.Read(b)
t, _ := strconv.Atoi(string(b))
fmt.Println(t)
switch t {
case 0:
func() {
fmt.Println("Server Init")
if *state > 0 {
ws.Write([]byte(strconv.Itoa(int(*state))))
} else {
ws.Write([]byte("0"))
b = make([]byte, 5)
ws.Read(b)
world, _ := strconv.Atob(string(b))
fmt.Println(world)
if world {
} else {
}
}
}()
default:
func() {
fmt.Println(string(b))
quit = true
}()
}
quit = true
}
}