Getting closer

.gitignore

@@ -1,2 +1,3 @@
 .idea
+bin
 anonircd

anonircd.go

@@ -8,12 +8,7 @@ import (
 	irc "gopkg.in/sorcix/irc.v2"
 	"fmt"
 	"time"
-)
-
-const (
-	MSG_RAW = 0
-	MSG_COMMAND = 1
-	MSG_PING = 2
+	"strings"
 )
 
 type Channel struct {
@@ -23,16 +18,15 @@ type Channel struct {
 type Client struct {
 	identifier  string
 	conn        net.Conn
+	pings       []string
 
 	writebuffer chan *irc.Message
 
 	reader      *irc.Decoder
 	writer      *irc.Encoder
+
+	*sync.RWMutex
 }
-/*
-func (c *Client) Send(message Message) {
-	c.conn.wr <- message
-}*/
 
 type Server struct {
 	sync.Mutex
@@ -40,7 +34,16 @@ type Server struct {
 	clients  map[string]*Client
 }
 
+var anonymous = irc.Prefix{"Anonymous", "", "AnonIRC"}
+
 const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+const motd = `
+  _|_|                                  _|_|_|  _|_|_|      _|_|_|
+_|    _|  _|_|_|      _|_|    _|_|_|      _|    _|    _|  _|
+_|_|_|_|  _|    _|  _|    _|  _|    _|    _|    _|_|_|    _|
+_|    _|  _|    _|  _|    _|  _|    _|    _|    _|    _|  _|
+_|    _|  _|    _|    _|_|    _|    _|  _|_|_|  _|    _|    _|_|_|
+`
 
 func randomIdentifier() string {
 	b := make([]byte, 10)
@@ -50,63 +53,97 @@ func randomIdentifier() string {
 	return string(b)
 }
 
-func handleRead(c *Client, server *Server) {
+func (s *Server) handleRead(c *Client) {
 	for {
 		c.conn.SetDeadline(time.Now().Add(300 * time.Second))
-		msg, err := c.reader.Decode()
+		msg, err := s.clients[c.identifier].reader.Decode()
 		if err != nil {
-			//return c.Reconnect()
+			fmt.Println("Unable to read from client:", err)
+			return
 		}
-		fmt.Println("%#v", msg)
+		fmt.Println(fmt.Sprintf("%v", msg))
 
 		fmt.Println("PREFIX: " + fmt.Sprintf("%v", msg.Prefix))
 		fmt.Println("COMMAND: " + fmt.Sprintf("%v", msg.Command))
 		fmt.Println("PARAMS: " + fmt.Sprintf("%v", msg.Params))
 		if (msg.Command == irc.CAP && len(msg.Params) > 0 && (msg.Params[0] == irc.CAP_LS || msg.Params[0] == irc.CAP_LIST)) {
-			fmt.Println("WAS CAP")
 			response := irc.Message{nil, irc.CAP, []string{"*", msg.Params[0], ""}}
 			c.writebuffer <- &response
+		} else if (msg.Command == irc.PING) {
+			c.writebuffer <- &irc.Message{nil, irc.PONG, []string{msg.Params[0]}}
 		}
 
-		prfx := irc.Prefix{Name: "tee"}
-		for _, sclient := range server.clients {
-			msgout := irc.Message{&prfx, irc.PRIVMSG, []string{"#test", msg.Trailing()}}
-			sclient.writebuffer <- &msgout
+		if (msg.Command == irc.PRIVMSG) {
+			for _, sclient := range s.clients {
+				msgout := irc.Message{&anonymous, irc.PRIVMSG, []string{"#test", msg.Trailing()}}
+				sclient.writebuffer <- &msgout
+			}
 		}
 	}
 }
 
-func handleWrite(c *Client, server *Server) {
+func (s *Server) handleWrite(c *Client) {
 	for msg := range c.writebuffer {
+		fmt.Println("Writing...", msg)
 		c.writer.Encode(msg)
 	}
 }
 
-func handleConnection(conn net.Conn, server *Server) {
-	messages := make(chan *irc.Message)
-	client := Client{randomIdentifier(), conn, messages, irc.NewDecoder(conn), irc.NewEncoder(conn)}
-
-	server.Lock()
-	server.clients[client.identifier] = &client
-	server.Unlock()
-
+func (s *Server) handleConnection(conn net.Conn) {
+	client := Client{randomIdentifier(), conn, []string{}, make(chan *irc.Message), irc.NewDecoder(conn), irc.NewEncoder(conn), new(sync.RWMutex)}
 	defer conn.Close()
-	go handleRead(&client, server)
-	handleWrite(&client, server)
+
+	s.Lock()
+	s.clients[client.identifier] = &client
+	s.Unlock()
+
+	go s.handleWrite(&client)
+
+	client.writebuffer <- &irc.Message{&irc.Prefix{Name:"anonircd"}, irc.RPL_WELCOME, []string{"                              Welcome to"}}
+	motdsplit := strings.Split(motd, "\n")
+	for i, motdmsg := range motdsplit {
+		var motdcode string
+		if (i == 0) {
+			motdcode = irc.RPL_MOTDSTART
+		} else if (i < len(motdsplit) - 1) {
+			motdcode = irc.RPL_MOTD
+		} else {
+			motdcode = irc.RPL_ENDOFMOTD
+		}
+		client.writebuffer <- &irc.Message{&irc.Prefix{Name:"anonircd"}, motdcode, []string{"  " + motdmsg}}
+	}
+
+	client.writebuffer <- &irc.Message{&anonymous, irc.JOIN, []string{"#lobby"}}
+
+	s.handleRead(&client)
+}
+func (s *Server) pingClients() {
+	for _, c := range s.clients {
+		ping := fmt.Sprintf("anonircd%d%d", int32(time.Now().Unix()), rand.Intn(1000))
+		c.pings = append(c.pings, ping)
+		c.writebuffer <- &irc.Message{&irc.Prefix{Name: "anonircd"}, irc.PING, []string{ping}}
+	}
+	time.Sleep(15 * time.Second)
 }
 
-func listen(server *Server) {
-	ln, err := net.Listen("tcp", ":6667")
+func (s *Server) listen(server *Server) {
+	rand.Seed(time.Now().UTC().UnixNano())
+
+	listener, err := net.Listen("tcp", ":6667")
 	if err != nil {
 		log.Fatalf("Failed to listen: %v", err)
 	}
+	defer listener.Close()
+
+	go s.pingClients()
 
 	for {
-		conn, err := ln.Accept()
+		conn, err := listener.Accept()
 		if err != nil {
+			fmt.Println("Error accepting connection: %s", err)
 			continue
 		}
-		go handleConnection(conn, server)
+		go s.handleConnection(conn)
 	}
 }
 
@@ -114,5 +151,5 @@ func main() {
 	server := Server{
 		clients:  make(map[string]*Client),
 		channels: make(map[string]Channel)}
-	listen(&server)
+	server.listen(&server)
 }