.gitea/workflows/go-audit.yaml

@@ -0,0 +1,27 @@
+name: Go audit
+run-name: ${{ gitea.actor }} pushed to main! 🚀
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: '>=1.22.0'
+
+    - name: Verify dependencies
+      run: go mod verify
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Run go vet
+      run: go vet ./...

.gitignore

@@ -9,8 +9,6 @@
 *.so
 *.dylib
 dist/
-server.crt
-server.key
 
 # Test binary, built with `go test -c`
 *.test

README.md

@@ -1,40 +1,11 @@
 # mini-chat
 
-Tiny IRC-like chat server written in Go
+Tiny IRC-like chat server built for compatibility with netcat and written in Go
 
-<p align="center">
+## Usage
-<img width="90%" height="90%" src="https://git.bulgariu.xyz/raul/mini-chat/raw/branch/main/demo.gif"/>
-</p>
 
-## Commands
+### Starting the server
-### Client
+./mini-chat server --port 1337
-```
-Example:
- ./mini-chat client --ip 192.168.0.100 --port 1337
 
-Usage:
+### Connecting to the server
-  mini-chat client [flags]
+nc $SERVER_IP $SERVER_PORT
-
-Flags:
-  -a, --ascii         Render UI in pure ASCII, might help with rendering issues
-  -h, --help          help for client
-      --insecure      [UNSAFE] Do not use TLS encryption
-  -i, --ip string     Server IP to connect to
-  -p, --port string   Server port to connect to (default "1302")
-```
-
-### Server
-```
-Example:
- ./mini-chat server --port 1337 --history chat.log --password coolh4x0r1337
-
-Usage:
-  mini-chat server [flags]
-
-Flags:
-  -h, --help              help for server
-  -r, --history string    File to store and recover chat history from
-      --insecure          [UNSAFE] Do not use TLS encryption
-      --password string   Password for accessing the chat server
-  -p, --port string       Port to use for listening (default "1302")
-```

cmd/client.go

@@ -1,75 +1,94 @@
 /*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
+Copyright © 2024 Raul
 */
 
 package cmd
 
 import (
+	"bufio"
 	"fmt"
+	"github.com/jroimartin/gocui"
 	"github.com/spf13/cobra"
+	"log"
+	"net"
 	"os"
 )
 
+// clientCmd represents the client command
 var clientCmd = &cobra.Command{
 	Use:   "client",
-	Short: "Client interface for mini-chat",
+	Short: "Connect to a mini-chat server",
-	Long: `Refactored mini-chat client that properly interfaces
+	Long: `Connect to a mini-chat server.
-with its server.
-
 	Example:
- ./mini-chat client --ip 192.168.0.100 --port 1337`,
+	./mini-chat client --ip 192.168.0.50 --port 1337`,
 	Run: func(cmd *cobra.Command, args []string) {
-
+		client(cmd)
-		if err := setClientParameters(cmd); err != nil {
-			cmd.Help()
-			fmt.Printf("\n-----------------------\n")
-			fmt.Println(err)
-			fmt.Printf("-----------------------\n")
-			os.Exit(0)
-		}
-
-		Client()
 	},
 }
 
+var err error
+var conn net.Conn
+
 func init() {
 	rootCmd.AddCommand(clientCmd)
-	clientCmd.PersistentFlags().StringP("ip", "i", "", "Server IP to connect to")
+
-	clientCmd.PersistentFlags().StringP("port", "p", "1302", "Server port to connect to")
+	// Here you will define your flags and configuration settings.
-	clientCmd.Flags().Bool("insecure", false, "[UNSAFE] Do not use TLS encryption")
+
-	clientCmd.Flags().BoolP("ascii", "a", false, "Render UI in pure ASCII, might help with rendering issues")
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// clientCmd.PersistentFlags().String("foo", "", "A help for foo")
+	clientCmd.Flags().String("ip", "", "Server to connect to")
+	clientCmd.Flags().String("port", "1302", "Port to connect to")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// clientCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 }
 
-func setClientParameters(cmd *cobra.Command) error {
+func client(cmd *cobra.Command) {
-	parameterPort, err := cmd.Flags().GetString("port")
+	port, _ := cmd.Flags().GetString("port")
+	ip, _ := cmd.Flags().GetString("ip")
+	if ip == "" {
+		fmt.Println("Not enough arguments, run \"-h\" parameter to see all the parameters!")
+		os.Exit(0)
+	}
+	if port == "" {
+		port = "1302"
+	}
+	socket := ip + ":" + port
+	conn, err = net.Dial("tcp", socket)
+	cobra.CheckErr(err)
+	defer conn.Close()
+
+	reply := make([]byte, 1024)
+	conn.Read(reply)
+	fmt.Print(string(reply))
+
+	msg, err := bufio.NewReader(os.Stdin).ReadString('\n')
+	cobra.CheckErr(err)
+	conn.Write([]byte(msg))
+
+	ui(conn)
+
+}
+
+func sendmsg(g *gocui.Gui, v *gocui.View) error {
+	textarea, err := g.View("textarea")
 	if err != nil {
-		return err
+		log.Panicln(err)
-	}
-	if parameterPort != "" {
-		serverPort = parameterPort
-	}
-
-	parameterIP, err := cmd.Flags().GetString("ip")
-	if err != nil {
-		return err
-	}
-	if parameterIP == "" {
-		err := fmt.Errorf("IP cannot be empty")
-		return err
-	}
-	serverIP = parameterIP
-
-	insecure, err := cmd.Flags().GetBool("insecure")
-	if insecure == true {
-		clientInsecure = true
-	}
-
-	ascii, err := cmd.Flags().GetBool("ascii")
-	if err != nil {
-		return err
-	}
-	if ascii == true {
-		useASCII = true
 	}
+	message := textarea.Buffer()
+	msg := string(message)
+	if msg == "" {
+		return nil
+	}
+
+	if msg == "" {
+		return nil
+	}
+
+	fmt.Fprint(conn, msg)
+	textarea.Clear()
+	textarea.SetCursor(0, 0)
 	return nil
 }

cmd/clientFunc.go

@@ -1,315 +0,0 @@
-/*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
-*/
-
-package cmd
-
-import (
-	"bufio"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/jroimartin/gocui"
-	"github.com/nsf/termbox-go"
-)
-
-type Message struct {
-	Contents string
-	//Date     time.Time
-	Server net.Conn
-}
-
-type ProfileData struct {
-	Username string
-}
-
-var Profile ProfileData
-
-func (m Message) toSend() {
-	m.Server.Write([]byte(m.Contents))
-}
-
-var (
-	serverPort     string = "1302"
-	serverIP       string
-	data           Message
-	clientInsecure bool
-	useASCII       bool
-)
-
-func startSecureConnection() (net.Conn, error) {
-	conf := &tls.Config{
-		InsecureSkipVerify: true,
-	}
-	conn, err := tls.Dial("tcp", serverIP+":"+serverPort, conf)
-	return conn, err
-}
-
-func startInsecureConnection() (net.Conn, error) {
-	conn, err := net.Dial("tcp", serverIP+":"+serverPort)
-	return conn, err
-}
-
-func Client() {
-	var conn net.Conn
-	var err error
-	if clientInsecure == true {
-		fmt.Println("WARNING: Starting unencrypted connection!")
-		conn, err = startInsecureConnection()
-	} else {
-		conn, err = startSecureConnection()
-	}
-
-	if err != nil {
-		log.Fatalf("Error occurred trying to connect to server: %v\n", err)
-	}
-	defer conn.Close()
-	data.Server = conn
-
-	nameRequest, b, err := receiveMessage(conn)
-	if err != nil {
-		log.Fatalf("Error occurred reading from server while requesting name: %v\n", err)
-	}
-	fmt.Print(nameRequest)
-	test := make([]byte, b)
-	copy(test, "Password: ")
-
-	if nameRequest == string(test) {
-		pass, err := scanLine()
-		if err != nil {
-			log.Fatal(err)
-		}
-		conn.Write([]byte(pass))
-
-		nameRequest, _, err := receiveMessage(conn)
-		if err != nil {
-			if err != io.EOF {
-				log.Fatalf("Error occurred reading from server while requesting name: %v\n", err)
-			}
-			os.Exit(1)
-		}
-		fmt.Print(nameRequest)
-		sendName(conn)
-	} else {
-		sendName(conn)
-	}
-	GUI()
-}
-
-////////////////////////////////////////////////////
-// 								REFACTORING BELOW 							//
-////////////////////////////////////////////////////
-
-func listenMessages(g *gocui.Gui) {
-	time.Sleep(time.Millisecond * 50)
-	chatbox, err := g.View("chatbox")
-	if err != nil {
-		log.Panicln(err)
-	}
-	for {
-		messageFromServer, _, err := receiveMessage(data.Server)
-		if err != nil {
-			g.Close()
-			os.Exit(0)
-		}
-
-		formattedMessage := strings.TrimRight(messageFromServer, "\n")
-		fmt.Fprintln(chatbox, formattedMessage)
-		termbox.Interrupt()
-	}
-}
-
-func receiveMessage(conn net.Conn) (s string, b int, err error) {
-	serverMessage := make([]byte, 1536)
-	n, err := conn.Read(serverMessage)
-	if err != nil {
-		return "", 0, err
-	}
-
-	serverMessageReduced := make([]byte, n)
-	copy(serverMessageReduced, serverMessage)
-
-	finalMessage := string(serverMessageReduced)
-	serverMessage = nil
-
-	return finalMessage, n, nil
-}
-
-func scanLine() (line string, err error) {
-	switch runtime.GOOS {
-	case "linux":
-		message, err := bufio.NewReader(os.Stdin).ReadString('\n')
-		if err != nil {
-			return "", err
-		}
-		line = message
-	case "windows":
-		message, err := bufio.NewReader(os.Stdin).ReadString('\r')
-		if err != nil {
-			return "", err
-		}
-		line = message
-	}
-	return line, nil
-}
-
-func sendName(conn net.Conn) {
-	message, err := scanLine()
-	if err != nil {
-		log.Fatalf("Error occurred sending message to server: %v\n", err)
-	}
-	Profile.Username = strings.TrimRight(message, "\n\r")
-
-	if _, err := conn.Write([]byte(Profile.Username + "\n")); err != nil {
-		log.Fatalf("Error occurred writing to server: %v\n", err)
-	}
-}
-
-func GUI() {
-	g, err := gocui.NewGui(gocui.OutputNormal)
-	if err != nil {
-		log.Panicln(err)
-	}
-	defer g.Close()
-	g.SetManagerFunc(layout)
-	g.Mouse = true
-	g.Cursor = true
-	if useASCII == true {
-		g.ASCII = true
-	}
-	initKeybindings(g)
-
-	go listenMessages(g)
-
-	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
-		log.Panicln(err)
-	}
-}
-
-func quit(*gocui.Gui, *gocui.View) error {
-	return gocui.ErrQuit
-}
-
-func sendToServer(g *gocui.Gui, v *gocui.View) error {
-	textarea, err := g.View("textarea")
-	if err != nil {
-		log.Panicln(err)
-	}
-	message := textarea.Buffer()
-	msg := string(message)
-	if msg == "" {
-		return nil
-	}
-
-	if msg == "" {
-		return nil
-	}
-
-	data.Contents = msg
-	data.toSend()
-
-	textarea.Clear()
-	textarea.SetCursor(0, 0)
-	return nil
-}
-
-func scrollView(v *gocui.View, dy int) error {
-	if v != nil {
-		v.Autoscroll = false
-		ox, oy := v.Origin()
-		if err := v.SetOrigin(ox, oy+dy); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func autoscroll(g *gocui.Gui, v *gocui.View) error {
-	chatbox, err := g.View("chatbox")
-	if err != nil {
-		log.Panicf("Error happened setting autoscroll: %v\n", err)
-	}
-	chatbox.Autoscroll = true
-	return nil
-}
-
-func initKeybindings(g *gocui.Gui) error {
-	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
-		log.Panicln(err)
-	}
-
-	// if err := g.SetKeybinding("button", gocui.MouseLeft, gocui.ModNone, sendToServer); err != nil {
-	// 	log.Panicln(err)
-	// }
-
-	if err := g.SetKeybinding("textarea", gocui.KeyCtrlA, gocui.ModNone, autoscroll); err != nil {
-		log.Panicln(err)
-	}
-
-	if err := g.SetKeybinding("textarea", gocui.KeyEnter, gocui.ModNone, sendToServer); err != nil {
-		log.Panicln(err)
-	}
-
-	if err := g.SetKeybinding("chatbox", gocui.MouseWheelUp, gocui.ModNone,
-		func(g *gocui.Gui, v *gocui.View) error {
-			scrollView(v, -1)
-			return nil
-		}); err != nil {
-		log.Panicln(err)
-	}
-
-	if err := g.SetKeybinding("chatbox", gocui.MouseWheelDown, gocui.ModNone,
-		func(g *gocui.Gui, v *gocui.View) error {
-			scrollView(v, 1)
-			return nil
-		}); err != nil {
-		log.Panicln(err)
-	}
-
-	return nil
-}
-
-func layout(g *gocui.Gui) error {
-	maxX, maxY := g.Size()
-
-	if chatbox, err := g.SetView("chatbox", 2, 1, maxX-2, maxY-5); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-
-		chatbox.Autoscroll = true
-		chatbox.Title = "Chat Box (Find source at https://git.bulgariu.xyz/raul/mini-chat!)"
-		chatbox.Wrap = true
-	}
-
-	// if button, err := g.SetView("button", maxX/2+32, maxY-4, maxX-28, maxY-2); err != nil {
-	// 	if err != gocui.ErrUnknownView {
-	// 		return err
-	// 	}
-	//
-	// 	button.Wrap = true
-	// 	button.Frame = true
-	// 	fmt.Fprintln(button, "Send it")
-	// }
-
-	if textarea, err := g.SetView("textarea", 2, maxY-4, maxX-2, maxY-2); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		if _, err := g.SetCurrentView("textarea"); err != nil {
-			log.Panicln(err)
-		}
-		textarea.Title = "(" + Profile.Username + ") " + "Send message" + " (Ctrl+A: Autoscroll)"
-		textarea.Wrap = true
-		textarea.Editable = true
-	}
-
-	return nil
-}

cmd/gen-cert.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-SSLCOMMAND=$(which openssl)
-
-echo "[+] Generating server.key..."
-$SSLCOMMAND genrsa -out server.key 2048
-
-echo "[+] Generating server.crt..."
-$SSLCOMMAND req -new -x509 -sha256 -key server.key -out server.crt -days 3650 -subj "/C=ES/ST=Valencia/L=Valencia/O=mini-chat /OU=mini-chat/CN=mini-chat"
-
-echo "[+] Success!"

cmd/root.go

@@ -1,21 +1,32 @@
 /*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
+Copyright © 2024 Raul
 */
 
 package cmd
 
 import (
-	"github.com/spf13/cobra"
 	"os"
+
+	"github.com/spf13/cobra"
 )
 
+// rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
 	Use:   "mini-chat",
-	Short: "Application for hosting and joining a simple chat server",
+	Short: "Minimalistic chat server built using Go",
+	Long: `mini-chat was originally designed to be used as a standalone server
+users could connect to using netcat, but it can be also used with the binary
+client
 
-	Long: `Application for hosting and joining a simple chat server`,
+Examples:
+	./mini-chat server --port 8080`,
+	// Uncomment the following line if your bare application
+	// has an action associated with it:
+	// Run: func(cmd *cobra.Command, args []string) { },
 }
 
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
 	err := rootCmd.Execute()
 	if err != nil {
@@ -24,4 +35,13 @@ func Execute() {
 }
 
 func init() {
+	// Here you will define your flags and configuration settings.
+	// Cobra supports persistent flags, which, if defined here,
+	// will be global for your application.
+
+	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.mini-chat.yaml)")
+
+	// Cobra also supports local flags, which will only run
+	// when this action is called directly.
+	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 }

cmd/server.go

@@ -1,69 +1,136 @@
 /*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
+Copyright © 2024 Raul
 */
 
 package cmd
 
 import (
+	"bufio"
+	"fmt"
 	"github.com/spf13/cobra"
-	"log"
+	"net"
+	"strings"
+	"time"
 )
 
+// serverCmd represents the server command
 var serverCmd = &cobra.Command{
 	Use:   "server",
-	Short: "Tiny chat server",
+	Short: "Main chat server",
-	Long: `Refactored mini-chat server designed to be connected to
+	Long: `You can connect to this server by running the following command from
-using a proper interface this time, not using netcat.
+a client:
+	nc $SERVER_IP $PORT
 
-Example:
+Assuming your IP is 192.168.0.30 and the server port is left on default the
- ./mini-chat server --port 1337 --history chat.log --password coolh4x0r1337`,
+command would be as follows:
+	nc 192.168.0.30 1302`,
 	Run: func(cmd *cobra.Command, args []string) {
-
+		server(cmd)
-		if err := setServerParameters(cmd); err != nil {
-			log.Fatalf("Error happened trying to set parameters: %v\n", err)
-		}
-
-		Server()
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(serverCmd)
-	serverCmd.PersistentFlags().StringP("port", "p", "1302", "Port to use for listening")
+
-	serverCmd.PersistentFlags().StringP("history", "r", "", "File to store and recover chat history from")
+	// Here you will define your flags and configuration settings.
-	serverCmd.PersistentFlags().String("password", "", "Password for accessing the chat server")
+
-	serverCmd.Flags().Bool("insecure", false, "[UNSAFE] Do not use TLS encryption")
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// serverCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// serverCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	serverCmd.Flags().String("port", "1302", "Port to listen on")
 }
 
-func setServerParameters(cmd *cobra.Command) error {
+var receiverIsStarted bool = false
-	parameterPort, err := cmd.Flags().GetString("port")
+
+type chatter struct {
+	Username string
+	IP       string
+}
+
+func server(cmd *cobra.Command) {
+	var lport string
+	port, _ := cmd.Flags().GetString("port")
+	if port != "" {
+		lport = port
+	} else {
+		lport = "1302"
+	}
+
+	ln, err := net.Listen("tcp", ":"+lport)
+	cobra.CheckErr(err)
+	fmt.Printf("Listening on port %v...\n", lport)
+	masterChannel := make(chan string, 20)
+
+	slaveChannel := make(chan string, 20)
+	go masterReceiver(slaveChannel, masterChannel)
+	// TODO: get channels properly working
+	// receivingChannel := make(chan string)
+	// sendingChannel := make(chan string)
+	for {
+		conn, err := ln.Accept()
+		cobra.CheckErr(err)
+		numOfClients++
+		go handleConn(conn, slaveChannel, masterChannel)
+	}
+
+}
+
+var numOfClients int = 0
+
+func masterReceiver(slaveChannel chan<- string, masterChannel <-chan string) {
+	for {
+		message := <-masterChannel
+		for i := 0; i < numOfClients; i++ {
+			slaveChannel <- message
+		}
+	}
+}
+
+func handleConn(conn net.Conn, slaveChannel <-chan string, masterChannel chan<- string) {
+	defer conn.Close()
+
+	go func() {
+		for {
+			message := <-slaveChannel
+			conn.Write([]byte(message))
+		}
+	}()
+
+	IP := getIP(conn)
+	t := time.Now()
+	date := fmt.Sprintf("%d-%02d-%02d | %02d:%02d:%02d", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
+	final_message_connect := fmt.Sprintf("[%v] Received connection from %v!\n", date, IP)
+	fmt.Print(final_message_connect)
+	conn.Write([]byte("What's your name?\nName: "))
+	name, err := bufio.NewReader(conn).ReadString('\n')
 	if err != nil {
-		return err
+		numOfClients--
+		return
 	}
-	if parameterPort != "" {
+	var NewUser = new(chatter)
-		listenPort = parameterPort
+	NewUser.Username = strings.TrimRight(name, "\n")
-	}
+	NewUser.IP = IP
-
+	for {
-	parameterHistory, err := cmd.Flags().GetString("history")
+		message, err := bufio.NewReader(conn).ReadString('\n')
 		if err != nil {
-		return err
+			fmt.Printf(NewUser.Username + " disconnected!\n")
+			numOfClients--
+			return
+		}
+		finalMessage := fmt.Sprint("{" + NewUser.IP + "} " + NewUser.Username + ": " + message)
+		fmt.Print(finalMessage)
+		masterChannel <- finalMessage
+		//conn.Write([]byte(message))
 	}
-	if parameterHistory != "" {
-		logLocation = parameterHistory
-		isLogging = true
 }
 
-	parPassword, err := cmd.Flags().GetString("password")
+func getIP(conn net.Conn) (IP string) {
-	if err != nil {
+	if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
-		return err
+		IP = fmt.Sprintf("%v", addr)
 	}
-	if parPassword != "" {
+	return IP
-		password = parPassword
-	}
-
-	insecure, err := cmd.Flags().GetBool("insecure")
-	if insecure == true {
-		servInsecure = true
-	}
-	return nil
 }

cmd/serverFunc.go

@@ -1,264 +0,0 @@
-/*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
-*/
-
-package cmd
-
-import (
-	"bufio"
-	"crypto/tls"
-	_ "embed"
-	"fmt"
-	"log"
-	"net"
-	"os"
-	"os/exec"
-	"strings"
-	"time"
-)
-
-var (
-	listenPort   string = "1302"
-	password     string = ""
-	isLogging    bool   = false
-	logLocation  string
-	listenerList []chan string
-	servInsecure bool
-)
-
-//go:embed gen-cert.sh
-var script string
-
-type User struct {
-	Username string
-	IP       string
-}
-
-func (u User) CreateUser(usr string, ip string) User {
-	u.Username = usr
-	u.IP = ip
-	return u
-}
-
-func createCerts() {
-	fmt.Println("[-] Certificates don't exist! Creating them...")
-	c := exec.Command("bash")
-	c.Stdin = strings.NewReader(script)
-	b, err := c.Output()
-	if err != nil {
-		log.Fatalf("Error occurred creating certificates: %v\n", err)
-	}
-	fmt.Print(string(b))
-}
-
-func startInsecureServer() (net.Listener, error) {
-	ln, err := net.Listen("tcp", ":"+listenPort)
-	return ln, err
-}
-
-func startSecureServer() (net.Listener, error) {
-	cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
-	if os.IsNotExist(err) {
-		createCerts()
-		cer, err = tls.LoadX509KeyPair("server.crt", "server.key")
-	}
-	if err != nil {
-		log.Fatalf("Error happened loading certificates: %v\n", err)
-	}
-	config := &tls.Config{Certificates: []tls.Certificate{cer}}
-	ln, err := tls.Listen("tcp", ":"+listenPort, config)
-	return ln, err
-}
-
-func getTime() string {
-	t := time.Now()
-	currentTime := fmt.Sprintf("%d-%02d-%02d | %02d:%02d:%02d", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
-	return currentTime
-}
-
-func Server() {
-	var ln net.Listener
-	var err error
-	if servInsecure == true {
-		fmt.Println("WARNING: Starting unencrypted server!")
-		ln, err = startInsecureServer()
-	} else {
-		ln, err = startSecureServer()
-	}
-
-	if err != nil {
-		log.Fatalf("Error happened trying to listen on port: %v\n", err)
-	}
-	defer ln.Close()
-	fmt.Printf("Listening on port %v...\n", listenPort)
-	for {
-		conn, err := ln.Accept()
-		if err != nil {
-			log.Fatalf("Error happened trying to accept connection: %v\n", err)
-		}
-		chatChan := make(chan string, 30)
-		listenerList = append(listenerList, chatChan)
-		go handleConn(conn, chatChan)
-	}
-}
-
-func getUsername(conn net.Conn) (s string, err error) {
-	conn.Write([]byte("What's your name?\nChoice: "))
-	name, err := bufio.NewReader(conn).ReadString('\n')
-	if err != nil {
-		return "", err
-	}
-	trimmedName := strings.TrimRight(name, "\n")
-	return trimmedName, nil
-}
-
-func getUserInput(conn net.Conn) (s string, err error) {
-	message, err := bufio.NewReader(conn).ReadString('\n')
-	if err != nil {
-		return "", err
-	}
-
-	return message, nil
-}
-
-func removeFromList(chatChan chan string) {
-	for i, v := range listenerList {
-		if v == chatChan {
-			listenerList = append(listenerList[:i], listenerList[:i+1]...)
-		}
-	}
-}
-
-func populateChat(conn net.Conn) {
-	if isLogging == false {
-		return
-	}
-	file, err := os.Open(logLocation)
-	if err != nil {
-		log.Printf("Error opening file for populating: %v\n", err)
-	}
-	defer file.Close()
-	scanner := bufio.NewScanner(file)
-	// For WHATEVER reason, writing to a TLS-based conn here appends newlines by default,
-	// so we have to split it off here to avoid ending up with chat logs full of
-	// unnecessary newlines
-	if servInsecure == true {
-		for scanner.Scan() {
-			conn.Write([]byte(fmt.Sprintln(scanner.Text())))
-		}
-	} else {
-		for scanner.Scan() {
-			conn.Write([]byte(fmt.Sprint(scanner.Text())))
-		}
-	}
-}
-
-func getPasswd(conn net.Conn) error {
-	conn.Write([]byte("Password: "))
-	userPassNewline, err := bufio.NewReader(conn).ReadString('\n')
-	userPass := strings.TrimRight(userPassNewline, "\n")
-	if err != nil {
-		e := fmt.Errorf("Node %v didn't respond to password prompt!\n", getIP(conn))
-		return e
-	}
-	if userPass != password {
-		e := fmt.Errorf("Node %v attempted connecting with an incorrect password!\n", getIP(conn))
-		return e
-	}
-	return nil
-}
-
-func handleConn(conn net.Conn, chatChan chan string) {
-	defer conn.Close()
-
-	if password != "" {
-		if err := getPasswd(conn); err != nil {
-			log.Print(err)
-			return
-		}
-	}
-
-	go receiveMessageServer(conn, chatChan)
-
-	//////////////////////////////////
-	// Get user information
-	//////////////////////////////////
-	userName, err := getUsername(conn)
-	if err != nil {
-		log.Printf("Error occurred getting username: %v\n", err)
-		//removeFromList(chatChan)
-		return
-	}
-	userIP := getIP(conn)
-	//////////////////////////////////
-	populateChat(conn)
-
-	newUserTemplate := new(User)
-	newUser := newUserTemplate.CreateUser(userName, userIP)
-	joinMessage := fmt.Sprintf("[%v] %v has joined the chat!", getTime(), newUser.Username)
-	fmt.Println(joinMessage + " [" + newUser.IP + "]")
-	addToLog(fmt.Sprintln(joinMessage))
-	//conn.Write([]byte(joinMessage))
-	sendMessage(joinMessage)
-
-	//////////////////////////////////
-	for {
-		message, err := getUserInput(conn)
-		if err != nil {
-			quitMessage := fmt.Sprintf("[%v] %v has disconnected!", getTime(), newUser.Username)
-			fmt.Println(quitMessage + " [" + newUser.IP + "]")
-			addToLog(fmt.Sprintln(quitMessage))
-			sendMessage(quitMessage)
-			//removeFromList(chatChan)
-			// if _, err := conn.Write([]byte(quitMessage)); err != nil {
-			// 	log.Printf("Error happened sending disconnect message: %v", err)
-			// }
-			return
-		}
-		finalMessage := fmt.Sprintf("[%v] %v: %v", getTime(), newUser.Username, strings.TrimRight(message, "\n"))
-		fm := fmt.Sprintf("%v\n", finalMessage)
-		fmt.Print(fm)
-		addToLog(fm)
-		sendMessage(finalMessage)
-
-		//chatChan <- finalMessage
-		// if _, err := conn.Write([]byte(finalMessage)); err != nil {
-		// 	log.Printf("Error happened sending message: %v", err)
-		// }
-	}
-	//////////////////////////////////
-}
-
-func sendMessage(msg string) {
-	for _, ch := range listenerList {
-		ch <- msg
-	}
-}
-
-func receiveMessageServer(conn net.Conn, chatChan chan string) {
-	for {
-		select {
-		case message := <-chatChan:
-			conn.Write([]byte(message))
-		}
-	}
-}
-
-func getIP(conn net.Conn) (IP string) {
-	if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
-		IP = fmt.Sprintf("%v", addr.IP)
-	}
-	return IP
-}
-
-func addToLog(s string) {
-	if isLogging == false {
-		return
-	}
-	file, err := os.OpenFile(logLocation, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0640)
-	if err != nil {
-		log.Printf("Error occurred: %v\n", err)
-	}
-	defer file.Close()
-	file.WriteString(s)
-}

cmd/ui.go

@@ -0,0 +1,108 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/jroimartin/gocui"
+	"github.com/nsf/termbox-go"
+	"log"
+	"net"
+	"time"
+)
+
+func ui(conn net.Conn) {
+	g, err := gocui.NewGui(gocui.OutputNormal)
+	if err != nil {
+		log.Panicln(err)
+	}
+	defer g.Close()
+	g.SetManagerFunc(layout)
+	g.Mouse = true
+	g.Cursor = true
+	initKeybindings(g)
+
+	go listener(g, conn)
+
+	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
+		log.Panicln(err)
+	}
+}
+
+func listener(g *gocui.Gui, conn net.Conn) {
+	time.Sleep(time.Second)
+	chatbox, err := g.View("chatbox")
+	if err != nil {
+		log.Panicln(err)
+	}
+	for {
+		reply := make([]byte, 2048)
+		_, err := conn.Read(reply)
+		if err != nil {
+			g.Close()
+			log.Fatalf("Server closed connection\n")
+		}
+
+		fmt.Fprintln(chatbox, string(reply))
+		termbox.Interrupt()
+	}
+}
+
+func quit(*gocui.Gui, *gocui.View) error {
+	return gocui.ErrQuit
+}
+
+func initKeybindings(g *gocui.Gui) error {
+	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
+		log.Panicln(err)
+	}
+
+	if err := g.SetKeybinding("button", gocui.MouseLeft, gocui.ModNone, sendmsg); err != nil {
+		log.Panicln(err)
+	}
+
+	if err := g.SetKeybinding("textarea", gocui.KeyEnter, gocui.ModNone, sendmsg); err != nil {
+		log.Panicln(err)
+	}
+	return nil
+}
+
+func layout(g *gocui.Gui) error {
+	maxX, maxY := g.Size()
+
+	if chatbox, err := g.SetView("chatbox", 2, 1, maxX/2+40, maxY-6); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		chatbox.Title = "Chat Box"
+	}
+
+	if button, err := g.SetView("button", maxX/2+32, maxY-4, maxX/2+40, maxY-2); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		//button.BgColor = gocui.ColorRed
+		button.Wrap = true
+		button.Frame = true
+		fmt.Fprintln(button, "Send it")
+	}
+
+	if textarea, err := g.SetView("textarea", 2, maxY-4, maxX/2+28, maxY-2); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		if _, err := g.SetCurrentView("textarea"); err != nil {
+			log.Panicln(err)
+		}
+		textarea.Title = "Send message"
+		textarea.Wrap = true
+		textarea.Editable = true
+	}
+
+	// if currentUsers, err := g.SetView("currentUsers", maxX/2+42, 1, maxX-6, maxY-6); err != nil {
+	// 	if err != gocui.ErrUnknownView {
+	// 		return err
+	// 	}
+	// 	currentUsers.Title = "Connected users"
+	// }
+
+	return nil
+}

go.mod

@@ -1,6 +1,6 @@
 module mini-chat
 
-go 1.22.2
+go 1.22.1
 
 require (
 	github.com/jroimartin/gocui v0.5.0

main.go

@@ -1,5 +1,5 @@
 /*
-Copyright © 2024 Raul <raul@bulgariu.xyz>
+Copyright © 2024 Raul
 */
 
 package main