package main
import (
"fmt"
"github.com/gorilla/websocket"
"github.com/tidwall/pretty"
"html/template"
"log"
"net"
"net/http"
"os"
)
const (
//CONN_HOST = "localhost"
CONN_PORT = ":3010"
CONN_TYPE = "tcp"
)
var upgrader = websocket.Upgrader{} // use default options
func echo(channel <-chan string) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Print("upgrade:", err)
return
}
defer c.Close()
for {
//mt, message, err := c.ReadMessage()
//if err != nil {
// log.Println("read:", err)
// break
//}
//log.Printf("recv: %s", message)
cmsg := <-channel
err = c.WriteMessage(websocket.TextMessage, []byte(cmsg))
if err != nil {
log.Println("write:", err)
break
}
}
}
}
func home(w http.ResponseWriter, r *http.Request) {
homeTemplate.Execute(w, "ws://"+r.Host+"/echo")
}
func main() {
channel := make(chan string)
switch CONN_TYPE {
case "tcp":
go tcp(channel)
case "udp":
go udp()
}
http.HandleFunc("/echo", echo(channel))
http.HandleFunc("/", home)
log.Fatal(http.ListenAndServe(":3011", nil))
}
func tcp(messageChannel chan<- string) {
fmt.Println("Hello TCP")
listener, err := net.Listen("tcp", CONN_PORT)
if err != nil {
fmt.Println("Error listening:", err.Error())
os.Exit(1)
}
// Close the listener when the application closes.
defer listener.Close()
//messageChannel := make(chan string)
for {
// Listen for an incoming connection.
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting: ", err.Error())
os.Exit(1)
}
// Handle connections in a new goroutine.
go handleRequest(conn, messageChannel)
}
}
// Handles incoming requests.
func handleRequest(conn net.Conn, messageChannel chan<- string) {
defer conn.Close()
// Make a buffer to hold incoming data.
for {
buf := make([]byte, 2048)
// Read the incoming connection into the buffer.
_, err := conn.Read(buf)
if err != nil {
fmt.Println("Error reading:", err.Error())
break
}
json := buf
json = pretty.Pretty(json)
fmt.Println(string(json))
messageChannel <- string(json)
// Send a response back to person contacting us.
// conn.Write([]byte("You stepped into my honey pot. I'll find you! "))
conn.Write([]byte("success"))
// Close the connection when you're done with it.
}
}
func udp() {
fmt.Println("Hello!")
port := CONN_PORT
protocol := "udp"
//Build the address
udpAddr, err := net.ResolveUDPAddr(protocol, port)
if err != nil {
fmt.Println("Wrong Address")
return
}
//Output
fmt.Println("Reading " + protocol + " from " + udpAddr.String())
//Create the connection
udpConn, err := net.ListenUDP(protocol, udpAddr)
if err != nil {
fmt.Println(err)
}
//Keep calling this function
for {
handlePacket(udpConn)
}
}
func handlePacket(conn *net.UDPConn) {
var buf = make([]byte, 2048)
n, err := conn.Read(buf)
fmt.Println("Buffersize:", n)
if err != nil {
fmt.Println("Error Reading")
return
} else {
fmt.Println(string(buf))
//fmt.Println(hex.EncodeToString(buf[0:n]))
//fmt.Println("Package Done")
}
}
var homeTemplate = template.Must(template.New("").Parse(`
Click "Open" to create a connection to the server,
"Send" to send a message to the server and "Close" to close the connection.
You can change the message and send multiple times.