From 0e5fa52c29d545ed3f5686b784cdb3bb71deecdb Mon Sep 17 00:00:00 2001 From: Stefano Date: Sun, 6 Mar 2022 23:20:06 +0100 Subject: [PATCH] Implement feature request #77: Support IRCv3 capability negotiation during registration --- client/commands.go | 22 ++++++- client/commands_test.go | 19 ++++++ client/connection.go | 51 +++++++++++---- client/handlers.go | 139 ++++++++++++++++++++++++++++++++++++++++ client/handlers_test.go | 51 +++++++++++++++ 5 files changed, 268 insertions(+), 14 deletions(-) diff --git a/client/commands.go b/client/commands.go index 101c7d3..dac7059 100644 --- a/client/commands.go +++ b/client/commands.go @@ -84,6 +84,23 @@ func splitMessage(msg string, splitLen int) (msgs []string) { return append(msgs, msg) } +func splitArgs(args []string, maxLen int) []string { + res := make([]string, 0) + + i := 0 + for i < len(args) { + currArg := args[i] + i++ + + for i < len(args) && len(currArg)+len(args[i])+1 < maxLen { + currArg += " " + args[i] + i++ + } + res = append(res, currArg) + } + return res +} + // Raw sends a raw line to the server, should really only be used for // debugging purposes but may well come in handy. func (conn *Conn) Raw(rawline string) { @@ -299,6 +316,9 @@ func (conn *Conn) Cap(subcommmand string, capabilities ...string) { if len(capabilities) == 0 { conn.Raw(CAP + " " + subcommmand) } else { - conn.Raw(CAP + " " + subcommmand + " :" + strings.Join(capabilities, " ")) + cmdPrefix := CAP + " " + subcommmand + " :" + for _, args := range splitArgs(capabilities, defaultSplit-len(cmdPrefix)) { + conn.Raw(cmdPrefix + args) + } } } diff --git a/client/commands_test.go b/client/commands_test.go index 15a8a05..25af371 100644 --- a/client/commands_test.go +++ b/client/commands_test.go @@ -2,6 +2,8 @@ package client import ( "reflect" + "strconv" + "strings" "testing" ) @@ -203,3 +205,20 @@ func TestClientCommands(t *testing.T) { c.VHost("user", "pass") s.nc.Expect("VHOST user pass") } + +func TestSplitCommand(t *testing.T) { + nArgs := 100 + + args := make([]string, 0) + for i := 0; i < nArgs; i++ { + args = append(args, "arg"+strconv.Itoa(i)) + } + + for maxLen := 1; maxLen <= defaultSplit; maxLen *= 2 { + for _, argStr := range splitArgs(args, maxLen) { + if len(argStr) > maxLen && len(strings.Split(argStr, " ")) > 1 { + t.Errorf("maxLen = %d, but len(cmd) = %d", maxLen, len(argStr)) + } + } + } +} diff --git a/client/connection.go b/client/connection.go index 43bcc24..8ed5a84 100644 --- a/client/connection.go +++ b/client/connection.go @@ -45,6 +45,12 @@ type Conn struct { out chan string connected bool + // Capabilities supported by the server + supportedCaps *capSet + + // Capabilites currently enabled + currCaps *capSet + // CancelFunc and WaitGroup for goroutines die context.CancelFunc wg sync.WaitGroup @@ -89,6 +95,12 @@ type Config struct { // Passed through to https://golang.org/pkg/net/#Dialer DualStack bool + // Enable IRCv3 capability negotiation. + EnableCapabilityNegotiation bool + + // A list of capabilities to request to the server during registration. + Capabilites []string + // Replaceable function to customise the 433 handler's new nick. // By default an underscore "_" is appended to the current nick. NewNick func(string) string @@ -125,12 +137,13 @@ type Config struct { // name, but these are optional. func NewConfig(nick string, args ...string) *Config { cfg := &Config{ - Me: &state.Nick{Nick: nick}, - PingFreq: 3 * time.Minute, - NewNick: DefaultNewNick, - Recover: (*Conn).LogPanic, // in dispatch.go - SplitLen: defaultSplit, - Timeout: 60 * time.Second, + Me: &state.Nick{Nick: nick}, + PingFreq: 3 * time.Minute, + NewNick: DefaultNewNick, + Recover: (*Conn).LogPanic, // in dispatch.go + SplitLen: defaultSplit, + Timeout: 60 * time.Second, + EnableCapabilityNegotiation: false, } cfg.Me.Ident = "goirc" if len(args) > 0 && args[0] != "" { @@ -204,13 +217,15 @@ func Client(cfg *Config) *Conn { } conn := &Conn{ - cfg: cfg, - dialer: dialer, - intHandlers: handlerSet(), - fgHandlers: handlerSet(), - bgHandlers: handlerSet(), - stRemovers: make([]Remover, 0, len(stHandlers)), - lastsent: time.Now(), + cfg: cfg, + dialer: dialer, + intHandlers: handlerSet(), + fgHandlers: handlerSet(), + bgHandlers: handlerSet(), + stRemovers: make([]Remover, 0, len(stHandlers)), + lastsent: time.Now(), + supportedCaps: capabilitySet(), + currCaps: capabilitySet(), } conn.addIntHandlers() return conn @@ -289,6 +304,16 @@ func (conn *Conn) DisableStateTracking() { } } +// SupportsCapability returns true if the server supports the given capability. +func (conn *Conn) SupportsCapability(cap string) bool { + return conn.supportedCaps.Has(cap) +} + +// HasCapability returns true if the given capability has been acked by the server during negotiation. +func (conn *Conn) HasCapability(cap string) bool { + return conn.currCaps.Has(cap) +} + // Per-connection state initialisation. func (conn *Conn) initialise() { conn.io = nil diff --git a/client/handlers.go b/client/handlers.go index 24165ad..d2317df 100644 --- a/client/handlers.go +++ b/client/handlers.go @@ -4,7 +4,9 @@ package client // to manage tracking an irc connection etc. import ( + "sort" "strings" + "sync" "time" "github.com/fluffle/goirc/logging" @@ -18,8 +20,13 @@ var intHandlers = map[string]HandlerFunc{ CTCP: (*Conn).h_CTCP, NICK: (*Conn).h_NICK, PING: (*Conn).h_PING, + CAP: (*Conn).h_CAP, + "410": (*Conn).h_410, } +// set up the ircv3 capabilities supported by this client which will be requested by default to the server. +var defaultCaps = []string{} + func (conn *Conn) addIntHandlers() { for n, h := range intHandlers { // internal handlers are essential for the IRC client @@ -35,6 +42,10 @@ func (conn *Conn) h_PING(line *Line) { // Handler for initial registration with server once tcp connection is made. func (conn *Conn) h_REGISTER(line *Line) { + if conn.cfg.EnableCapabilityNegotiation { + conn.Cap(CAP_LS) + } + if conn.cfg.Pass != "" { conn.Pass(conn.cfg.Pass) } @@ -42,6 +53,134 @@ func (conn *Conn) h_REGISTER(line *Line) { conn.User(conn.cfg.Me.Ident, conn.cfg.Me.Name) } +func (conn *Conn) getRequestCapabilities() *capSet { + s := capabilitySet() + + // add capabilites supported by the client + s.Add(defaultCaps...) + + // add capabilites requested by the user + s.Add(conn.cfg.Capabilites...) + + return s +} + +func (conn *Conn) negotiateCapabilities(supportedCaps []string) { + conn.supportedCaps.Add(supportedCaps...) + + reqCaps := conn.getRequestCapabilities() + reqCaps.Intersect(conn.supportedCaps) + + if reqCaps.Size() > 0 { + conn.Cap(CAP_REQ, reqCaps.Slice()...) + } else { + conn.Cap(CAP_END) + } +} + +func (conn *Conn) handleCapAck(caps []string) { + for _, cap := range caps { + conn.currCaps.Add(cap) + } + conn.Cap(CAP_END) +} + +func (conn *Conn) handleCapNak(caps []string) { + conn.Cap(CAP_END) +} + +const ( + CAP_LS = "LS" + CAP_REQ = "REQ" + CAP_ACK = "ACK" + CAP_NAK = "NAK" + CAP_END = "END" +) + +type capSet struct { + caps map[string]bool + mu sync.RWMutex +} + +func capabilitySet() *capSet { + return &capSet{ + caps: make(map[string]bool), + } +} + +func (c *capSet) Add(caps ...string) { + c.mu.Lock() + for _, cap := range caps { + if strings.HasPrefix(cap, "-") { + c.caps[cap[1:]] = false + } else { + c.caps[cap] = true + } + } + c.mu.Unlock() +} + +func (c *capSet) Has(cap string) bool { + c.mu.RLock() + defer c.mu.RUnlock() + return c.caps[cap] +} + +// Intersect computes the intersection of two sets. +func (c *capSet) Intersect(other *capSet) { + c.mu.Lock() + + for cap := range c.caps { + if !other.Has(cap) { + delete(c.caps, cap) + } + } + + c.mu.Unlock() +} + +func (c *capSet) Slice() []string { + c.mu.RLock() + defer c.mu.RUnlock() + + capSlice := make([]string, 0, len(c.caps)) + for cap := range c.caps { + capSlice = append(capSlice, cap) + } + + // make output predictable for testing + sort.Strings(capSlice) + return capSlice +} + +func (c *capSet) Size() int { + c.mu.RLock() + defer c.mu.RUnlock() + return len(c.caps) +} + +// This handler is triggered when an invalid cap command is received by the server. +func (conn *Conn) h_410(line *Line) { + logging.Warn("Invalid cap subcommand: ", line.Args[1]) +} + +// Handler for capability negotiation commands. +// Note that even if multiple CAP_END commands may be sent to the server during negotiation, +// only the first will be considered. +func (conn *Conn) h_CAP(line *Line) { + subcommand := line.Args[1] + + caps := strings.Fields(line.Text()) + switch subcommand { + case CAP_LS: + conn.negotiateCapabilities(caps) + case CAP_ACK: + conn.handleCapAck(caps) + case CAP_NAK: + conn.handleCapNak(caps) + } +} + // Handler to trigger a CONNECTED event on receipt of numeric 001 // : 001 :Welcome message !@ func (conn *Conn) h_001(line *Line) { diff --git a/client/handlers_test.go b/client/handlers_test.go index 171e5c9..1e374d5 100644 --- a/client/handlers_test.go +++ b/client/handlers_test.go @@ -456,3 +456,54 @@ func Test671(t *testing.T) { s.st.EXPECT().GetNick("user2").Return(nil) c.h_671(ParseLine(":irc.server.org 671 test user2 :some ignored text")) } + +func TestCap(t *testing.T) { + c, s := setUp(t) + defer s.tearDown() + + c.Config().EnableCapabilityNegotiation = true + c.Config().Capabilites = []string{"cap1", "cap2", "cap3", "cap4"} + + c.h_REGISTER(&Line{Cmd: REGISTER}) + s.nc.Expect("CAP LS") + s.nc.Expect("NICK test") + s.nc.Expect("USER test 12 * :Testing IRC") + + // Ensure that capabilities not supported by the server are not requested + s.nc.Send("CAP * LS :cap2 cap4") + s.nc.Expect("CAP REQ :cap2 cap4") + + s.nc.Send("CAP * ACK :cap2 cap4") + s.nc.Expect("CAP END") + + for _, cap := range []string{"cap2", "cap4"} { + if !c.SupportsCapability(cap) { + t.Fail() + } + + if !c.HasCapability(cap) { + t.Fail() + } + } + + for _, cap := range []string{"cap1", "cap3"} { + if c.HasCapability(cap) { + t.Fail() + } + } + + // test disable capability after registration + s.c.Cap("REQ", "-cap4") + s.nc.Expect("CAP REQ :-cap4") + + s.nc.Send("CAP * ACK :-cap4") + s.nc.Expect("CAP END") + + if !c.HasCapability("cap2") { + t.Fail() + } + + if c.HasCapability("cap4") { + t.Fail() + } +}