From 3ad10e3fb3a1a91fc2de07458811570dfc511eb9 Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:41:06 -0400
Subject: [PATCH 1/6] update

+Admin account 'admin:adminpass'
+persistent messages
+User auth
+User registration
+
---
 internal/server/ascii.go   |  32 ++--
 internal/server/errors.go  |   2 +-
 internal/server/handler.go | 351 ++++++++++++++++++++++---------------
 internal/server/server.go  | 223 ++++-------------------
 4 files changed, 267 insertions(+), 341 deletions(-)

diff --git a/internal/server/ascii.go b/internal/server/ascii.go
index c72c956..37d7e3a 100644
--- a/internal/server/ascii.go
+++ b/internal/server/ascii.go
@@ -2,21 +2,25 @@ package server
 
 import (
 	"fmt"
+	"os"
+	"strings"
 
-	"go.vxn.dev/bbs-go/internal/config"
+	"bbs-go/internal/config"
 )
 
-var WelcomeMessage = `
-+-------------------------------------------+
-|       __    __                            |
-|      / /_  / /_  _____      ____  ____    |
-|     / __ \/ __ \/ ___/_____/ __ \/ __ \   |
-|    / /_/ / /_/ (__  )_____/ /_/ / /_/ /   |
-|   /_.___/_.___/____/      \__, /\____/    |
-|                          /____/           |
-|                                           |
-+-------------------------------------------+
-vxn-dev bbs-go service (` + config.Version + `)
-telnet ` + config.Host + ` ` + fmt.Sprintf("%d", config.Port) + `
+var WelcomeMessage string
 
-`
+func LoadMOTD(path string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	msg := string(content)
+	msg = strings.ReplaceAll(msg, "{{VERSION}}", config.Version)
+	msg = strings.ReplaceAll(msg, "{{HOST}}", config.Host)
+	msg = strings.ReplaceAll(msg, "{{PORT}}", fmt.Sprintf("%d", config.Port))
+
+	WelcomeMessage = msg
+	return nil
+}
diff --git a/internal/server/errors.go b/internal/server/errors.go
index 15f00fa..1b4b849 100644
--- a/internal/server/errors.go
+++ b/internal/server/errors.go
@@ -5,5 +5,5 @@ import (
 )
 
 var (
-	ErrShutdownStarted = errors.New("the server shutdown process has been already started")
+	ErrShutdownStarted = errors.New("The server shutdown process has been already started")
 )
diff --git a/internal/server/handler.go b/internal/server/handler.go
index 47fc69c..2b5ed82 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -1,71 +1,61 @@
 package server
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"net"
+	"os"
 	"strings"
 	"sync"
+	"time"
 
-	"go.vxn.dev/bbs-go/internal/config"
+	"bbs-go/internal/config"
 )
 
-const prompt = "> "
-const crlf = "\r\n"
-const shutdownMessage = "Shutdown" + crlf
-const byeMessage = "*** Bye" + crlf
-const helpMessage = "*** Commands" + crlf +
-	"    exit --- quit the session" + crlf + crlf
-const invalidCommandMessage = "*** Invalid command, try 'help'" + crlf
-
-// stripTelnetNegotiation removes Telnet command sequences from incoming data.
-// These sequences begin with the IAC (Interpret As Command) byte (decimal 255),
-// followed by one or more bytes indicating Telnet negotiation options (e.g., WILL, DO, etc.).
-// See RFC 854 for details: https://datatracker.ietf.org/doc/html/rfc854
-func stripTelnetNegotiation(data []byte) []byte {
-	result := []byte{}
-	i := 0
-	for i < len(data) {
-		if data[i] == 255 { // IAC
-			// Telnet command structure is typically IAC <command> <option>
-			// So skip the next two bytes (if available)
-			if i+2 < len(data) {
-				i += 3
-			} else {
-				break
-			}
-		} else {
-			result = append(result, data[i])
-			i++
-		}
-	}
-	return result
+type Message struct {
+	User      string
+	Timestamp string
+	Content   string
 }
 
+type User struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+var (
+	messageStore []Message
+	messageMutex sync.Mutex
+	userDB       = "users.json"
+	users        = map[string]string{}
+	usersMutex   sync.Mutex
+	messagesFile = "messages.txt"
+	motdFile     = "motd.txt"
+)
+
 type Handler struct {
-	//ctx context.Context
-	done   chan struct{}
 	conn   net.Conn
 	output io.Writer
 	wg     *sync.WaitGroup
-}
-
-// write writes data to the Handler's client connection. Any error returned is logged.
-func (h *Handler) write(data string) {
-	if _, err := h.conn.Write([]byte(data)); err != nil {
-		h.debugf("Write error: %s", err.Error())
-	}
+	done   chan struct{}
+	user   string
 }
 
 func (h *Handler) Handle() {
 	defer h.wg.Done()
+	defer h.conn.Close()
+
+	h.done = make(chan struct{})
+	h.loadUsers()
+	h.loadMessages()
 
 	h.logf("< Incoming connection: %s", h.conn.RemoteAddr().String())
-	h.write(WelcomeMessage)
-	h.write(prompt)
 
-	defer h.conn.Close()
+	h.showMOTD()
+	h.authenticate()
 
+	h.conn.Write([]byte("> "))
 	pktChan := make(chan string)
 	errChan := make(chan error)
 
@@ -74,73 +64,89 @@ func (h *Handler) Handle() {
 	go h.read(pktChan, errChan)
 
 	<-errChan
-
 	h.logf("> Connection closed: %s", h.conn.RemoteAddr().String())
 }
 
+func (h *Handler) loadUsers() {
+	data, err := os.ReadFile(userDB)
+	if err == nil {
+		json.Unmarshal(data, &users)
+	}
+}
+
+func (h *Handler) saveUsers() {
+	usersMutex.Lock()
+	defer usersMutex.Unlock()
+
+	data, _ := json.MarshalIndent(users, "", "  ")
+	_ = os.WriteFile(userDB, data, 0644)
+}
+
+func (h *Handler) authenticate() {
+	h.conn.Write([]byte("Enter username (or type 'register'): "))
+	username := h.readLine()
+	if username == "register" {
+		h.conn.Write([]byte("Choose a username: "))
+		username = h.readLine()
+		h.conn.Write([]byte("Choose a password: "))
+		password := h.readLine()
+
+		usersMutex.Lock()
+		users[username] = password
+		usersMutex.Unlock()
+		h.saveUsers()
+		h.conn.Write([]byte("Registration successful.\n"))
+	} else {
+		h.conn.Write([]byte("Enter password: "))
+		password := h.readLine()
+
+		if stored, ok := users[username]; !ok || stored != password {
+			h.conn.Write([]byte("Login failed. Goodbye.\n"))
+			h.conn.Close()
+			return
+		}
+		h.conn.Write([]byte(fmt.Sprintf("Welcome back, %s!\n", username)))
+	}
+
+	h.user = username
+}
+
+func (h *Handler) showMOTD() {
+	motd, err := os.ReadFile(motdFile)
+	if err == nil {
+		h.conn.Write(motd)
+		h.conn.Write([]byte("\n"))
+	}
+}
+
+func (h *Handler) readLine() string {
+	buf := make([]byte, 256)
+	n, _ := h.conn.Read(buf)
+	return strings.TrimSpace(string(buf[:n]))
+}
+
 func (h *Handler) read(pktChan chan string, errChan chan error) {
 	defer h.wg.Done()
 	defer h.debugf("Handler: read closed")
 
-	// Run the read loop.
-	for {
+	buf := make([]byte, 512)
 
+	for {
 		select {
 		case <-h.done:
-			h.write(shutdownMessage)
-			h.logf("> Connection closed (daemon's shutdown): %s", h.conn.RemoteAddr().String())
-
-			if errChan != nil {
-				errChan <- nil
-				close(errChan)
-			}
-
-			return
-
-		case <-errChan:
+			h.conn.Write([]byte("Shutdown\n"))
+			sendErr(errChan, nil)
 			return
 
 		default:
-			// Prepare packet's byte allocation.
-			tmp := make([]byte, 512)
-			buf := strings.Builder{}
-
-			// Read bytes from the remote conterpart.
-			for {
-				n, err := h.conn.Read(tmp)
-
-				// Handle error from the read loop.
-				if err != nil {
-					switch err {
-					case io.EOF:
-						// End-of-file
-						h.debugf("< EOF")
-
-					case err.(net.Error):
-						h.write("Too slow\n")
-						h.debugf("> Connection closed (read timeout): %s", h.conn.RemoteAddr().String())
-						return
-
-					default:
-						h.debugf("< Unexpected read error: %s", err.Error())
-						return
-					}
-				}
-
-				for i := range n {
-					b := tmp[i]
-
-					// CR or LF indicates end of line
-					if b == '\n' {
-						line := stripTelnetNegotiation([]byte(buf.String()))
-						if pktChan != nil && len(line) > 0 {
-							pktChan <- string(line)
-						}
-						buf.Reset()
-					} else if b != '\r' {
-						buf.WriteByte(b)
-					}
-				}
+			n, err := h.conn.Read(buf)
+			if err != nil {
+				sendErr(errChan, err)
+				return
+			}
+			input := strings.TrimSpace(string(buf[:n]))
+			if input != "" {
+				pktChan <- input
 			}
 		}
 	}
@@ -149,70 +155,141 @@ func (h *Handler) read(pktChan chan string, errChan chan error) {
 func (h *Handler) route(pktChan chan string, errChan chan error) {
 	defer h.wg.Done()
 	defer h.debugf("Handler: route closed")
-
-	defer func() {
-		if errChan != nil {
-			errChan <- nil
-			close(errChan)
-		}
-	}()
+	defer sendErr(errChan, nil)
 
 	for {
 		select {
 		case <-h.done:
-			h.write(shutdownMessage)
-			h.logf("> Connection closed (daemon's shutdown): %s", h.conn.RemoteAddr().String())
-			return
-
-		case <-errChan:
 			return
 
-		default:
-			// Preprocess the string for switch.
-			pkt := <-pktChan
-			// h.debugf("pkt: %s", pkt)
-			// h.debugf("pkt: %v", []byte(pkt))
-			parts := strings.Split(pkt, "\r\n")
-
-			switch strings.TrimSpace(parts[0]) {
-			case "":
+		case pkt := <-pktChan:
+			cmd := strings.ToLower(pkt)
 
-			case "exit":
-				h.write(byeMessage)
+			switch {
+			case cmd == "exit":
+				h.conn.Write([]byte("Bye!\n"))
 				return
 
-			case "help":
-				h.write(helpMessage)
+			case cmd == "help":
+				h.conn.Write([]byte("*** Commands:\n"))
+				h.conn.Write([]byte("    help           --- show this help message\n"))
+				h.conn.Write([]byte("    post <message> --- post a message to the board\n"))
+				h.conn.Write([]byte("    read           --- read recent messages\n"))
+				h.conn.Write([]byte("    exit           --- quit the session\n\n"))
+
+			case strings.HasPrefix(cmd, "post "):
+				content := strings.TrimSpace(pkt[5:])
+				if content == "" {
+					h.conn.Write([]byte("Usage: post <message>\n"))
+				} else {
+					h.saveMessage(h.user, content)
+					h.conn.Write([]byte("Message posted.\n"))
+				}
+
+			case cmd == "read":
+				messages := h.getLastMessages(config.MaxReadMessages)
+				if len(messages) == 0 {
+					h.conn.Write([]byte("No messages yet.\n"))
+				} else {
+					for _, msg := range messages {
+						h.conn.Write([]byte(fmt.Sprintf("[%s] %s: %s\n", msg.Timestamp, msg.User, msg.Content)))
+					}
+				}
 
 			default:
-				h.debugf("Invalid command")
-				h.write(invalidCommandMessage)
+				h.conn.Write([]byte("*** Invalid command, try 'help'\n"))
 			}
 
-			h.write(prompt)
+			h.conn.Write([]byte("> "))
 		}
 	}
 }
 
-// Common debug info logging wrapper function.
-func (h *Handler) debugf(format string, args ...any) {
-	if h.output == nil || !config.Debug {
-		return
+func (h *Handler) saveMessage(user, content string) {
+	msg := Message{
+		User:      user,
+		Timestamp: time.Now().Format("2006-01-02 15:04:05"),
+		Content:   content,
 	}
 
-	// Prepend the debug info prefix.
-	f := fmt.Sprintf("(dbg) %s\n", format)
+	messageMutex.Lock()
+	messageStore = append(messageStore, msg)
+
+	f, err := os.OpenFile(messagesFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err == nil {
+		defer f.Close()
+		f.WriteString(fmt.Sprintf("[%s] %s: %s\n", msg.Timestamp, user, content))
+	}
 
-	// Write to the output according to running configuration.
-	fmt.Fprintf(h.output, f, args...)
+	messageMutex.Unlock()
 }
 
-// Common basic logging wrapper function.
-func (h *Handler) logf(format string, args ...any) {
-	if h.output == nil {
+func (h *Handler) getLastMessages(n int) []Message {
+	messageMutex.Lock()
+	defer messageMutex.Unlock()
+
+	if len(messageStore) <= n {
+		return messageStore
+	}
+	return messageStore[len(messageStore)-n:]
+}
+
+func sendErr(ch chan error, err error) {
+	if ch != nil {
+		ch <- err
+		// Do NOT close the channel here!
+	}
+}
+
+func (h *Handler) debugf(format string, args ...interface{}) {
+	if h.output == nil || !config.Debug {
 		return
 	}
+	fmt.Fprintf(h.output, "(dbg) "+format+"\n", args...)
+}
 
-	// Write to the output according to running configuration.
+func (h *Handler) logf(format string, args ...interface{}) {
+	if h.output == nil {
+		return
+	}
 	fmt.Fprintf(h.output, format+"\n", args...)
 }
+
+func (h *Handler) loadMessages() {
+	messageMutex.Lock()
+	defer messageMutex.Unlock()
+
+	messageStore = nil // Clear current store
+
+	data, err := os.ReadFile(messagesFile)
+	if err != nil {
+		return // No messages file yet
+	}
+	lines := strings.Split(string(data), "\n")
+	for _, line := range lines {
+		if line == "" {
+			continue
+		}
+		// Expected format: [YYYY-MM-DD HH:MM:SS] user: content
+		if len(line) < 22 || line[0] != '[' {
+			continue
+		}
+		endIdx := strings.Index(line, "]")
+		if endIdx == -1 {
+			continue
+		}
+		timestamp := line[1:endIdx]
+		rest := strings.TrimSpace(line[endIdx+1:])
+		colonIdx := strings.Index(rest, ":")
+		if colonIdx == -1 {
+			continue
+		}
+		user := strings.TrimSpace(rest[:colonIdx])
+		content := strings.TrimSpace(rest[colonIdx+1:])
+		messageStore = append(messageStore, Message{
+			User:      user,
+			Timestamp: timestamp,
+			Content:   content,
+		})
+	}
+}
diff --git a/internal/server/server.go b/internal/server/server.go
index a9578c4..34c6cac 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -1,213 +1,58 @@
 package server
 
 import (
-	"context"
 	"fmt"
-	"io"
 	"net"
-	"os"
-	"strings"
 	"sync"
-	"time"
-
-	"go.vxn.dev/bbs-go/internal/config"
-)
-
-const (
-	ConnectionTimeout time.Duration = 5 * time.Second
-	ShutdownTimeout   time.Duration = 5 * time.Second
 )
 
+// Server struct holds server configurations and handlers.
 type Server struct {
-	ctx          context.Context
-	done         chan struct{}
-	once         sync.Once
-	outputTarget io.Writer
-	wg           sync.WaitGroup
-}
-
-func NewServer(ctx context.Context) *Server {
-	return &Server{
-		ctx: ctx,
-	}
+	Host    string
+	Port    int
+	Handler *Handler
+	wg      *sync.WaitGroup
 }
 
-// Run acts like the Server's API function to watch main's context cancelation to autostart the shutdown process.
-func (s *Server) Run() error {
-	s.init()
+// NewServer initializes and returns a new Server instance.
+func NewServer(address string) *Server {
+	host := "0.0.0.0"
+	port := 2323
 
-	for {
-		select {
-		// A signal notifying that the Shutdown procedure has been initiated.
-		case <-s.done:
-			return ErrShutdownStarted
-
-		// A signal from the parent task supervising the daemon (via the main() function),
-		// meaning the Shutdown procedure is to be started now.
-		case <-s.ctx.Done():
-			s.logf("\n--- App's context canceled: starting a graceful shutdown cleanup...")
-
-			// Create a new shutdown context with timeout to close the server by force after deadline.
-			sctx, scancel := context.WithTimeout(context.Background(), ShutdownTimeout)
-			defer scancel()
-
-			if err := s.Shutdown(sctx); err != nil {
-				s.logf("Shutdown error: %s", err.Error())
-				return err
-			}
-
-			if s.ctx.Err() != context.Canceled {
-				return s.ctx.Err()
-			}
-
-			return nil
-		}
+	// Initialize the server
+	return &Server{
+		Host:    host,
+		Port:    port,
+		wg:      &sync.WaitGroup{},
+		Handler: &Handler{},
 	}
 }
 
-// Shutdown takes care of the system resources closing and cleanup.
-func (s *Server) Shutdown(sctx context.Context) (err error) {
-	s.init()
-
-	defer func() {
-		if r := recover(); r != nil {
-			err = ErrShutdownStarted
-		}
-	}()
-
-	// This will panic when closed by any previous function invokation => to be recovered.
-	close(s.done)
-
-	// This code section should only be access once in app's lifetime!
-	s.logf("--- Shutdown invoked...")
-	shch := make(chan struct{})
-
-	go func() {
-		// Wait for all goroutines to exit gracefully.
-		s.wg.Wait()
-		close(shch)
-	}()
-
-	// Wait for the context cancelation, or a timeout.
-	select {
-	case <-shch:
-		s.logf("Graceful cleanup done.")
-
-	case <-sctx.Done():
-		if sctx.Err() != context.DeadlineExceeded {
-			err = sctx.Err()
-			return
-		}
-
+// Run starts the server and listens for incoming connections.
+func (s *Server) Run() {
+	listenAddress := fmt.Sprintf("%s:%d", s.Host, s.Port)
+	ln, err := net.Listen("tcp", listenAddress)
+	if err != nil {
+		fmt.Printf("Error starting server: %v\n", err)
 		return
 	}
+	defer ln.Close()
 
-	return
-}
+	fmt.Printf("Server is running on %s\n", listenAddress)
 
-// init gets called from any exported function to ensure that the Server instance
-// is initialized before a Shutdown routine is started.
-func (s *Server) init() {
-	if s.ctx == nil {
-		panic("Server's context missing, use NewServer(...) to initialize a new Server instance properly")
-	}
-
-	s.once.Do(func() {
-		if s.outputTarget == nil {
-			s.outputTarget = os.Stdout
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			fmt.Printf("Error accepting connection: %v\n", err)
+			continue
 		}
 
-		s.logf("*** Initializing new Server instance...")
-
-		s.done = make(chan struct{})
-
-		// Run the TCP listener.
+		// Handle the incoming connection with the Handler
+		h := &Handler{
+			conn: conn,
+			wg:   s.wg,
+		}
 		s.wg.Add(1)
-		go s.listen()
-
-		s.logf("Initialization complete.")
-	})
-}
-
-//
-//  Logging methods.
-//
-
-// Common debug info logging wrapper function.
-func (s *Server) debugf(format string, args ...any) {
-	if s.outputTarget == nil || !config.Debug {
-		return
+		go h.Handle()
 	}
-
-	// Prepend the debug info prefix.
-	f := fmt.Sprintf("(dbg) %s\n", format)
-
-	// Write to the output according to running configuration.
-	fmt.Fprintf(s.outputTarget, f, args...)
-}
-
-// Common basic logging wrapper function.
-func (s *Server) logf(format string, args ...any) {
-	if s.outputTarget == nil {
-		return
-	}
-
-	// Write to the output according to running configuration.
-	fmt.Fprintf(s.outputTarget, format+"\n", args...)
-}
-
-// Main TCP listener.
-func (s *Server) listen() {
-	defer s.wg.Done()
-
-	// Start listening on a port from daemon's running configuration.
-	l, err := net.Listen("tcp4", fmt.Sprintf(":%d", config.Port))
-	if err != nil {
-		panic(err)
-	}
-
-	defer func() {
-		s.logf("TCP listener closed.")
-		l.Close()
-	}()
-
-	// Ensure the welcome message contains carriage return + line feed
-	// Needed to display properly on Windows terminals
-	WelcomeMessage = strings.ReplaceAll(WelcomeMessage, "\n", "\r\n")
-
-	s.logf("%s", WelcomeMessage)
-	s.logf("*** Listening on port TCP/%d...", config.Port)
-
-	go func() {
-		for {
-			// Wait for a new connection.
-			conn, err := l.Accept()
-			if err != nil {
-				// Check the main context for an error (may be already canceled).
-				if s.ctx.Err() != nil {
-					return
-				}
-				s.logf("Accept error: %s", err.Error())
-				break
-			}
-
-			// Set the conn deadline.
-			//conn.SetDeadline(time.Now().Add(ConnectionTimeout))
-
-			// Handle the connection in a new goroutine.
-			// --> internal/server/handler.go
-			handler := &Handler{
-				done:   s.done,
-				conn:   conn,
-				output: s.outputTarget,
-				wg:     &s.wg,
-			}
-
-			s.wg.Add(1)
-			go handler.Handle()
-		}
-	}()
-
-	// Wait until the shutdown is invoked.
-	<-s.done
 }

From 843115f2cea076cfb29dbdddd44f0dedfd86f07e Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:41:53 -0400
Subject: [PATCH 2/6] Update config.go

Update
---
 internal/config/config.go | 63 ++++-----------------------------------
 1 file changed, 6 insertions(+), 57 deletions(-)

diff --git a/internal/config/config.go b/internal/config/config.go
index 8352786..307e613 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -1,61 +1,10 @@
 package config
 
-import (
-	"flag"
-	"os"
-	"strconv"
-)
-
-const (
-	ENV_DEBUG   string = "DEBUG"
-	ENV_HOST    string = "LISTEN_ADDR"
-	ENV_PORT    string = "LISTEN_PORT"
-	ENV_VERSION string = "PROJECT_VERSION"
-)
-
-const (
-	defaultDebug bool   = false
-	defaultHost  string = "localhost"
-	defaultPort  int    = 5555
-)
-
 var (
-	Debug   bool
-	Host    string
-	Port    int
-	Version string
+	Host            string
+	Port            int
+	Version         string
+	Debug           bool
+	MaxMessages     = 1000000
+	MaxReadMessages = 30
 )
-
-func init() {
-	flag.BoolVar(&Debug, "debug", defaultDebug, "a boolean, makes the server's output more verbose")
-	flag.StringVar(&Host, "host", defaultHost, "a string, a FQDN type of host's name")
-	flag.IntVar(&Port, "port", defaultPort, "an integer, a port to listen for incoming requests on")
-
-	flag.Parse()
-
-	//
-	//  Try ENV vars.
-	//
-
-	var err error
-
-	// Should be non-empty true, otherwise is false.
-	if os.Getenv(ENV_DEBUG) != "" {
-		Debug, err = strconv.ParseBool(os.Getenv(ENV_DEBUG))
-		if err != nil {
-			Debug = defaultDebug
-		}
-	}
-
-	// Should be set to anything non-empty.
-	if os.Getenv(ENV_PORT) != "" {
-		Port, err = strconv.Atoi(os.Getenv(ENV_PORT))
-		if err != nil {
-			Port = defaultPort
-		}
-	}
-
-	if os.Getenv(ENV_VERSION) != "" {
-		Version = os.Getenv(ENV_VERSION)
-	}
-}

From cb4cdcfff31ceeeaaf6b77c3f904da0f614c008f Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:43:24 -0400
Subject: [PATCH 3/6] update

update
---
 messages.txt | 0
 users.json   | 3 +++
 2 files changed, 3 insertions(+)
 create mode 100644 messages.txt
 create mode 100644 users.json

diff --git a/messages.txt b/messages.txt
new file mode 100644
index 0000000..e69de29
diff --git a/users.json b/users.json
new file mode 100644
index 0000000..b42878e
--- /dev/null
+++ b/users.json
@@ -0,0 +1,3 @@
+{
+  "root": "rootpasswd"
+}
\ No newline at end of file

From fa17ad3026c22c262f335994d6c10c543a6717b7 Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:43:56 -0400
Subject: [PATCH 4/6] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e192118..8c0971f 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 A tiny TCP server implementing a basic Buletin Board Service.
 
 ```shell
-telnet localhost 5555
+telnet localhost 2323
 ```
 
 ```text

From 88b611f90057bce73ea7d9ad9020458c7b2ed834 Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:44:24 -0400
Subject: [PATCH 5/6] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8c0971f..52347ce 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ telnet localhost 2323
 |                                           |
 +-------------------------------------------+
 vxn-dev bbs-go service (0.6.1)
-telnet localhost 5555
+telnet localhost 2323
 
 > test
 *** Invalid command

From 25408ab39f20b945373994570672a0ed2df2bf4c Mon Sep 17 00:00:00 2001
From: noarche <58564888+noarche@users.noreply.github.com>
Date: Sun, 20 Apr 2025 22:46:07 -0400
Subject: [PATCH 6/6] Update README.md

---
 README.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 52347ce..568a040 100644
--- a/README.md
+++ b/README.md
@@ -19,11 +19,17 @@ telnet localhost 2323
 vxn-dev bbs-go service (0.6.1)
 telnet localhost 2323
 
-> test
-*** Invalid command
+Enter username (or type 'register'): register
+Choose a username: noarche
+Choose a password:
+Registration successful.
+> help
+*** Commands:
+    help           --- show this help message
+    post <message> --- post a message to the board
+    read           --- read recent messages
+    exit           --- quit the session
 
-> exit
-*** Bye
 ```
 
 ## build and run