irc client go library.

color.go

@@ -0,0 +1,31 @@
+package ircclient
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+)
+
+func Stripper(input string) string {
+	// \b, \_, \cNN
+	var rx *regexp.Regexp
+	var err error
+	rx, err = regexp.Compile("\x02|\x16|\x0f|\x03[0-9]{2}")
+	if err != nil {
+		log.Panic("regexp:", err)
+	}
+	input = rx.ReplaceAllString(input, "")
+	return input
+}
+
+func Bold(input string) string {
+	return "\x02" + input + "\x02"
+}
+
+func Underline(input string) string {
+	return "\x16" + input + "\x16"
+}
+
+func Color(color int, input string) string {
+	return fmt.Sprintf("\x03%02d%s\x0f", color, input)
+}

go.mod

@@ -0,0 +1,3 @@
+module red-green.com/irc-client
+
+go 1.18

irc-client.go

@@ -0,0 +1,453 @@
+package ircclient
+
+import (
+	"bufio"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+type IRCMsg struct {
+	MsgParts []string
+	From     string
+	To       string
+	Cmd      string
+	Msg      string
+}
+
+type IRCWrite struct {
+	To     string
+	Output string
+}
+
+type IRCConfig struct {
+	Port           int
+	Hostname       string
+	UseTLS         bool // Use TLS Secure connection
+	UseSASL        bool // Authenticate via SASL
+	Insecure       bool // Allow self-signed certificates
+	Nick           string
+	MyNick         string
+	Username       string
+	Realname       string
+	Password       string // Password for nickserv
+	ServerPassword string // Password for server
+	Socket         net.Conn
+	TLSSocket      *tls.Conn
+	Reader         *bufio.Reader
+	ReadChannel    chan IRCMsg
+	ReadEvents     []string
+	WriteChannel   chan IRCWrite
+	DelChannel     chan string
+	Registered     bool
+	Flood_Num      int // Number of lines sent before considered a flood
+	Flood_Time     int // Number of Seconds to track previous messages
+	Flood_Delay    int // Delay between sending when flood protection on (Milliseconds)
+	OnExit         func()
+}
+
+// Writer       *bufio.Writer
+
+func (Config *IRCConfig) Connect() bool {
+	var err error
+
+	if Config.Flood_Num == 0 {
+		Config.Flood_Num = 5
+	}
+	if Config.Flood_Time == 0 {
+		Config.Flood_Time = 10
+	}
+
+	if Config.Flood_Delay == 0 {
+		Config.Flood_Delay = 1000
+	}
+
+	Config.Registered = false
+
+	if Config.ReadChannel == nil {
+		log.Println("Warning: ReadChannel is nil.")
+	}
+
+	if Config.UseTLS {
+		var tlsConfig tls.Config
+
+		if !Config.Insecure {
+			certPool := x509.NewCertPool()
+			tlsConfig.ClientCAs = certPool
+			tlsConfig.InsecureSkipVerify = false
+		} else {
+			tlsConfig.InsecureSkipVerify = true
+		}
+
+		Config.TLSSocket, err = tls.Dial("tcp", Config.Hostname+":"+strconv.Itoa(Config.Port), &tlsConfig)
+		if err != nil {
+			log.Fatal("tls.Dial:", err)
+		}
+		// Config.Writer = bufio.NewWriter(Config.TLSSocket)
+		Config.Reader = bufio.NewReader(Config.TLSSocket)
+	} else {
+		Config.Socket, err = net.Dial("tcp", Config.Hostname+":"+strconv.Itoa(Config.Port))
+		if err != nil {
+			log.Fatal("net.Dial:", err)
+		}
+		// Config.Writer = bufio.NewWriter(Config.Socket)
+		Config.Reader = bufio.NewReader(Config.Socket)
+	}
+
+	Config.WriteChannel = make(chan IRCWrite)
+	Config.DelChannel = make(chan string)
+
+	// We are connected.
+	go Config.WriterRoutine()
+
+	// Registration
+	if Config.UseTLS && Config.UseSASL {
+		Config.PriorityWrite("CAP REQ :sasl")
+	}
+
+	if Config.ServerPassword != "" {
+		Config.PriorityWrite(fmt.Sprintf("PASS %s", Config.ServerPassword))
+	}
+
+	// Register nick
+	Config.MyNick = Config.Nick
+	Config.PriorityWrite(fmt.Sprintf("NICK %s", Config.Nick))
+	Config.PriorityWrite(fmt.Sprintf("USER %s 0 * :%s", Config.Username, Config.Realname))
+	// Config.Writer.Flush()
+
+	go Config.ReaderRoutine()
+	return true
+}
+
+// Low level write to [TLS]Socket routine.
+func (Config *IRCConfig) write(output string) error {
+	var err error
+	log.Println(">>", output)
+	output += "\r\n"
+	if Config.UseTLS {
+		_, err = Config.TLSSocket.Write([]byte(output))
+	} else {
+		_, err = Config.Socket.Write([]byte(output))
+	}
+	return err
+}
+
+func (Config *IRCConfig) WriterRoutine() {
+	var err error
+	var throttle ThrottleBuffer
+	var Flood FloodTrack
+
+	throttle.init()
+
+	Flood.Track = make([]time.Time, Config.Flood_Num)
+
+	// signal handler
+	var sigChannel chan os.Signal = make(chan os.Signal, 1)
+	signal.Notify(sigChannel, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	// Change this into a select with timeout.
+	// Timeout, if there's something to be buffered.
+
+	for {
+		if throttle.Life_sucks {
+			select {
+			case output := <-Config.WriteChannel:
+				if output.To == "" {
+					err = Config.write(output.Output)
+					if err != nil {
+						log.Println("Writer:", err)
+					}
+					continue
+				}
+
+				throttle.push(output.To, output.Output)
+
+			case <-sigChannel:
+				if Config.OnExit != nil {
+					Config.OnExit()
+				}
+				os.Exit(2)
+
+			case remove := <-Config.DelChannel:
+				log.Printf("Remove: [%s]\n", remove)
+				throttle.delete(remove)
+
+			case <-time.After(time.Millisecond * time.Duration(Config.Flood_Delay)):
+				// Send from the buffer
+				// debugging the flood buffer
+				// log.Printf("targets: %#v\n", targets)
+				// log.Printf("last: %d\n", last)
+				// log.Printf("buffer: %#v\n", buffer)
+
+				var msg string = throttle.pop()
+				err = Config.write(msg)
+				if err != nil {
+					log.Println("Writer:", err)
+				}
+			}
+		} else {
+			// Life is good.
+			select {
+			case <-sigChannel:
+				if Config.OnExit != nil {
+					Config.OnExit()
+				}
+				os.Exit(2)
+
+			case output := <-Config.WriteChannel:
+				if output.To == "" {
+					err = Config.write(output.Output)
+					if err != nil {
+						log.Println("Writer:", err)
+					}
+					continue
+				}
+				if Flood.Pos > 0 {
+					Flood.Expire(Config.Flood_Time)
+				}
+				if Flood.Pos == Config.Flood_Num {
+					throttle.push(output.To, output.Output)
+				} else {
+					// Flood limits not reached
+					Flood.Save()
+					err = Config.write(output.Output)
+					if err != nil {
+						log.Println("Writer:", err)
+					}
+				}
+
+			}
+		}
+	}
+
+	log.Println("~WriterRoutine")
+}
+
+func (Config *IRCConfig) Close() {
+	if Config.UseTLS {
+		Config.TLSSocket.Close()
+	} else {
+		Config.Socket.Close()
+	}
+}
+
+func IRCParse(line string) []string {
+	var pos int = strings.Index(line, " :")
+	var message string
+
+	if pos != -1 {
+		message = line[pos+2:]
+		line = line[:pos]
+	}
+	var results []string
+	results = strings.Split(line, " ")
+	if message != "" {
+		results = append(results, message)
+	}
+	return results
+}
+
+func IRCNick(from string) string {
+	if from[0] == ':' {
+		from = from[1:]
+	}
+	var pos int = strings.Index(from, "!")
+	if pos != -1 {
+		from = from[:pos]
+	}
+	return from
+}
+
+func RandomNick(nick string) string {
+	var result string = nick + "-"
+	result += strconv.Itoa(rand.Intn(1000))
+	return result
+}
+
+func (Config *IRCConfig) PriorityWrite(output string) {
+	Config.WriteChannel <- IRCWrite{To: "", Output: output}
+}
+
+func (Config *IRCConfig) WriteTo(to string, output string) {
+	Config.WriteChannel <- IRCWrite{To: to, Output: output}
+}
+
+func (Config *IRCConfig) Msg(to string, message string) {
+	Config.WriteTo(to, fmt.Sprintf("PRIVMSG %s :%s", to, message))
+}
+
+func (Config *IRCConfig) Notice(to string, message string) {
+	Config.WriteTo(to, fmt.Sprintf("NOTICE %s :%s", to, message))
+}
+
+func (Config *IRCConfig) Action(to string, message string) {
+	Config.WriteTo(to, fmt.Sprintf("PRIVMSG %s :\x01ACTION %s\x01", to, message))
+}
+
+func (Config *IRCConfig) ReaderRoutine() {
+	for {
+		var line string
+		var err error
+		var results []string
+
+		line, err = Config.Reader.ReadString('\n')
+		if err == nil {
+			line = strings.Trim(line, "\r\n")
+			log.Println("<< ", line)
+
+			results = IRCParse(line)
+
+			if results[1] == "433" {
+				// Nick already in use!
+				var newNick string = RandomNick(Config.Nick)
+				Config.MyNick = newNick
+				Config.PriorityWrite("NICK " + newNick)
+			}
+
+			if results[1] == "PRIVMSG" {
+				// Is this an action?
+				if len(results) >= 3 {
+					if (results[3][0] == '\x01') && (results[3][len(results[3])-1] == '\x01') {
+						// ACTION
+						results[1] = "CTCP"
+						results[3] = results[3][1 : len(results[3])-1]
+						log.Println("CTCP:", results[3])
+
+						// Process CTCP commands
+						if strings.HasPrefix(results[3], "ACTION ") {
+							results[1] = "ACTION"
+							results[3] = results[3][7:]
+						}
+
+						if strings.HasPrefix(results[3], "PING ") {
+							Config.WriteTo(IRCNick(results[0]),
+								fmt.Sprintf("NOTICE %s :\x01PING %s\x01",
+									IRCNick(results[0]),
+									results[3][5:]))
+						}
+
+						if results[3] == "VERSION" {
+							// Send version reply
+							Config.WriteTo(IRCNick(results[0]),
+								fmt.Sprintf("NOTICE %s :\x01VERSION red-green.com/irc-client 0.1\x01",
+									IRCNick(results[0])))
+						}
+
+						if results[3] == "TIME" {
+							// Send time reply
+							var now time.Time = time.Now()
+							Config.WriteTo(IRCNick(results[0]),
+								fmt.Sprintf("NOTICE %s :\x01TIME %s\x01",
+									IRCNick(results[0]),
+									now.Format(time.ANSIC)))
+						}
+
+					}
+				}
+			}
+		} else {
+			// This is likely, 2022/04/05 10:11:41 ReadString: EOF
+			if err != io.EOF {
+				log.Println("ReadString:", err)
+			}
+			close(Config.ReadChannel)
+			return
+		}
+		var msg IRCMsg = IRCMsg{MsgParts: results}
+		if len(results) >= 3 {
+			msg.From = IRCNick(results[0])
+			msg.Cmd = results[1]
+			msg.To = results[2]
+			if len(results) >= 4 {
+				msg.Msg = results[3]
+			}
+		} else {
+			msg.Cmd = results[0]
+		}
+
+		// Answer PING/PONG immediately.
+		if results[0] == "PING" {
+			Config.PriorityWrite("PONG " + results[1])
+		}
+
+		if (msg.Cmd == "401") || (msg.Cmd == "404") {
+			// No such nick/channel
+			log.Printf("Remove %s from buffer.", msg.MsgParts[3])
+			Config.DelChannel <- msg.MsgParts[3]
+		}
+
+		if !Config.Registered {
+			// We're not registered yet
+
+			// Answer the queries for SASL authentication
+			if (msg.Cmd == "CAP") && (msg.Msg == "ACK") {
+				Config.PriorityWrite("AUTHENTICATE PLAIN")
+			}
+
+			if (msg.MsgParts[0] == "AUTHENTICATE") && (msg.MsgParts[1] == "+") {
+				var userpass string = fmt.Sprintf("\x00%s\x00%s", Config.Nick, Config.Password)
+				var b64 string = base64.StdEncoding.EncodeToString([]byte(userpass))
+				Config.PriorityWrite("AUTHENTICATE " + b64)
+			}
+
+			if msg.Cmd == "903" {
+				// Success SASL
+				Config.PriorityWrite("CAP END")
+				Config.Registered = true
+			}
+
+			if msg.Cmd == "904" {
+				// Failed SASL
+				Config.PriorityWrite("CAP END")
+				// Should we exit here?
+			}
+
+			/*
+				2022/04/06 19:12:11 <<  :[email protected] NOTICE meow :This nickname is registered and protected.  If it is your
+				2022/04/06 19:12:11 <<  :[email protected] NOTICE meow :nick, type /msg NickServ IDENTIFY password.  Otherwise,
+				2022/04/06 19:12:11 <<  :[email protected] NOTICE meow :please choose a different nick.
+			*/
+			if (msg.From == "NickServ") && (msg.Cmd == "NOTICE") {
+				if strings.Contains(msg.Msg, "IDENTIFY") {
+					Config.PriorityWrite(fmt.Sprintf("NS IDENTIFY %s", Config.Password))
+				}
+				// :[email protected] NOTICE meow :Password accepted - you are now recognized.
+			}
+
+			if !Config.UseSASL && (msg.Cmd == "900") {
+				Config.Registered = true
+			}
+
+		}
+
+		// This is a better way of knowing when we've identified for services
+		if (msg.Cmd == "MODE") && (msg.To == Config.MyNick) {
+			// This should probably be look for + and contains "r"
+			if (msg.Msg[0] == '+') && (strings.Contains(msg.Msg, "r")) {
+				Config.ReadChannel <- IRCMsg{Cmd: "Identified"}
+			}
+		}
+
+		if Config.ReadChannel != nil {
+			Config.ReadChannel <- msg
+		}
+
+		if (msg.Cmd == "376") || (msg.Cmd == "422") {
+			// End MOTD, or MOTD Missing
+			var reg IRCMsg = IRCMsg{Cmd: "EndMOTD"}
+			Config.ReadChannel <- reg
+		}
+
+	}
+}

throttle.go

@@ -0,0 +1,132 @@
+package ircclient
+
+import (
+	"log"
+	"time"
+)
+
+type FloodTrack struct {
+	Pos   int
+	Track []time.Time
+}
+
+func (F *FloodTrack) Expire(timeout int) {
+	var idx int
+
+ReCheck:
+	for idx = 0; idx < F.Pos; idx++ {
+		// log.Println(idx, time.Since(F.Track[idx]).Seconds())
+		if time.Since(F.Track[idx]).Seconds() > float64(timeout) {
+			// Remove this from the list
+			F.Pos--
+			for pos := idx; pos < F.Pos; pos++ {
+				F.Track[pos] = F.Track[pos+1]
+			}
+			goto ReCheck
+		}
+	}
+}
+
+func (F *FloodTrack) Save() {
+	F.Track[F.Pos] = time.Now()
+	F.Pos++
+}
+
+type ThrottleBuffer struct {
+	buffer     map[string][]string
+	targets    []string
+	last       int
+	Life_sucks bool
+}
+
+func (T *ThrottleBuffer) init() {
+	T.buffer = make(map[string][]string, 0)
+	T.targets = make([]string, 0)
+	T.last = 0
+}
+
+/*
+Pop next available from buffer.  If empty, remove from map and targets
+list.  Adjust last if needed.
+*/
+func (T *ThrottleBuffer) pop() string {
+	// Get next target
+	var t string = T.targets[T.last]
+
+	T.last++
+	if T.last == len(T.targets) {
+		// We're past the end, start over at the beginning.
+		T.last = 0
+	}
+
+	var msg string = T.buffer[t][0]
+
+	if len(T.buffer[t]) == 1 {
+		// This is the last entry for this target.
+		delete(T.buffer, t)
+
+		if len(T.targets) == 1 {
+			// This is the last entry
+			T.targets = make([]string, 0)
+			T.Life_sucks = false
+			log.Println("Flood control off.")
+		} else {
+			// Remove t from targets
+			for x := 0; x < len(T.targets); x++ {
+				if T.targets[x] == t {
+					T.targets = append(T.targets[:x], T.targets[x+1:]...)
+					if x <= T.last {
+						T.last--
+					}
+					break
+				}
+
+			}
+		}
+	} else {
+		// Delete the first entry for t
+		T.buffer[t] = append(T.buffer[t][:0], T.buffer[t][1:]...)
+	}
+
+	return msg
+}
+
+func (T *ThrottleBuffer) push(To string, Output string) {
+	if len(T.targets) == 0 {
+		T.Life_sucks = true
+		T.last = 0
+		log.Println("Flood control enabled.")
+	}
+
+	_, has := T.buffer[To]
+	if !has {
+		T.buffer[To] = make([]string, 0)
+		T.targets = append(T.targets, To)
+	}
+	T.buffer[To] = append(T.buffer[To], Output)
+}
+
+func (T *ThrottleBuffer) delete(To string) {
+	_, has := T.buffer[To]
+	if has {
+		// Yes, the buffer has message(s) for To
+		delete(T.buffer, To)
+		if len(T.targets) == 1 {
+			// Last entry
+			T.targets = make([]string, 0)
+			T.Life_sucks = false
+			log.Println("Flood control off.")
+		} else {
+			// Remove To from targets
+			for x := 0; x < len(T.targets); x++ {
+				if T.targets[x] == To {
+					T.targets = append(T.targets[:x], T.targets[x+1:]...)
+					if x <= T.last {
+						T.last--
+					}
+					break
+				}
+			}
+		}
+	}
+}