Changeset 684 in code for trunk

Timestamp:

Nov 15, 2021, 1:34:04 PM (4 years ago)

Author:

contact

Message:

Add support for MONITOR

Add support for MONITOR in single-upstream mode.

Each downstream has its own set of monitored targets. These sets
are merged together to compute the MONITOR commands to send to
upstream.

Each upstream has a set of monitored targets accepted by the server
alongside with their status (online/offline). This is used to
directly send replies to downstreams adding a target another
downstream has already added, and send MONITOR S[TATUS] replies.

Co-authored-by: delthas <delthas@…>

Location:

trunk

Files:

• downstream.go (modified) (4 diffs)
• irc.go (modified) (2 diffs)
• upstream.go (modified) (4 diffs)
• user.go (modified) (4 diffs)

trunk/downstream.go

@@ -229 +229 @@
         "MAXTARGETS":    true,
         "MODES":         true,
+        "MONITOR":       true,
         "NAMELEN":       true,
         "NETWORK":       true,
@@ -265 +266 @@
         lastBatchRef uint64
 
+        monitored casemapMap
+
         saslServer sasl.Server
 }
@@ -277 +280 @@
                 supportedCaps: make(map[string]string),
                 caps:          make(map[string]bool),
+                monitored:     newCasemapMap(0),
         }
         dc.hostname = remoteAddr
@@ -2254 +2258 @@
                         Params:  []string{upstreamUser, upstreamChannel},
                 })
+        case "MONITOR":
+                // MONITOR is unsupported in multi-upstream mode
+                uc := dc.upstream()
+                if uc == nil {
+                        return newUnknownCommandError(msg.Command)
+                }
+
+                var subcommand string
+                if err := parseMessageParams(msg, &subcommand); err != nil {
+                        return err
+                }
+
+                switch strings.ToUpper(subcommand) {
+                case "+", "-":
+                        var targets string
+                        if err := parseMessageParams(msg, nil, &targets); err != nil {
+                                return err
+                        }
+                        for _, target := range strings.Split(targets, ",") {
+                                if subcommand == "+" {
+                                        // Hard limit, just to avoid having downstreams fill our map
+                                        if len(dc.monitored.innerMap) >= 1000 {
+                                                dc.SendMessage(&irc.Message{
+                                                        Prefix:  dc.srv.prefix(),
+                                                        Command: irc.ERR_MONLISTFULL,
+                                                        Params:  []string{dc.nick, "1000", target, "Bouncer monitor list is full"},
+                                                })
+                                                continue
+                                        }
+
+                                        dc.monitored.SetValue(target, nil)
+
+                                        if uc.monitored.Has(target) {
+                                                cmd := irc.RPL_MONOFFLINE
+                                                if online := uc.monitored.Value(target); online {
+                                                        cmd = irc.RPL_MONONLINE
+                                                }
+
+                                                dc.SendMessage(&irc.Message{
+                                                        Prefix:  dc.srv.prefix(),
+                                                        Command: cmd,
+                                                        Params:  []string{dc.nick, target},
+                                                })
+                                        }
+                                } else {
+                                        dc.monitored.Delete(target)
+                                }
+                        }
+                        uc.updateMonitor()
+                case "C": // clear
+                        dc.monitored = newCasemapMap(0)
+                        uc.updateMonitor()
+                case "L": // list
+                        // TODO: be less lazy and pack the list
+                        for _, entry := range dc.monitored.innerMap {
+                                dc.SendMessage(&irc.Message{
+                                        Prefix:  dc.srv.prefix(),
+                                        Command: irc.RPL_MONLIST,
+                                        Params:  []string{dc.nick, entry.originalKey},
+                                })
+                        }
+                        dc.SendMessage(&irc.Message{
+                                Prefix:  dc.srv.prefix(),
+                                Command: irc.RPL_ENDOFMONLIST,
+                                Params:  []string{dc.nick, "End of MONITOR list"},
+                        })
+                case "S": // status
+                        // TODO: be less lazy and pack the lists
+                        for _, entry := range dc.monitored.innerMap {
+                                target := entry.originalKey
+
+                                cmd := irc.RPL_MONOFFLINE
+                                if online := uc.monitored.Value(target); online {
+                                        cmd = irc.RPL_MONONLINE
+                                }
+
+                                dc.SendMessage(&irc.Message{
+                                        Prefix:  dc.srv.prefix(),
+                                        Command: cmd,
+                                        Params:  []string{dc.nick, target},
+                                })
+                        }
+                }
         case "CHATHISTORY":
                 var subcommand string

trunk/irc.go

@@ -409 +409 @@
 }
 
+func generateMonitor(subcmd string, targets []string) []*irc.Message {
+        maxLength := maxMessageLength - len("MONITOR "+subcmd+" ")
+
+        var msgs []*irc.Message
+        var buf []string
+        n := 0
+        for _, target := range targets {
+                if n+len(target)+1 > maxLength {
+                        msgs = append(msgs, &irc.Message{
+                                Command: "MONITOR",
+                                Params:  []string{subcmd, strings.Join(buf, ",")},
+                        })
+                        buf = buf[:0]
+                        n = 0
+                }
+
+                buf = append(buf, target)
+                n += len(target) + 1
+        }
+
+        if len(buf) > 0 {
+                msgs = append(msgs, &irc.Message{
+                        Command: "MONITOR",
+                        Params:  []string{subcmd, strings.Join(buf, ",")},
+                })
+        }
+
+        return msgs
+}
+
 type joinSorter struct {
         channels []string
@@ -635 +665 @@
 }
 
+type monitorCasemapMap struct{ casemapMap }
+
+func (cm *monitorCasemapMap) Value(name string) (online bool) {
+        entry, ok := cm.innerMap[cm.casemap(name)]
+        if !ok {
+                return false
+        }
+        return entry.value.(bool)
+}
+
 func isWordBoundary(r rune) bool {
         switch r {

trunk/upstream.go

@@ -104 +104 @@
         account       string
         nextLabelID   uint64
+        monitored     monitorCasemapMap
 
         saslClient  sasl.Client
@@ -210 +211 @@
                 isupport:              make(map[string]*string),
                 pendingCmds:           make(map[string][]pendingUpstreamCommand),
+                monitored:             monitorCasemapMap{newCasemapMap(0)},
         }
         return uc, nil
@@ -1414 +1416 @@
                         })
                 })
+        case irc.RPL_MONONLINE, irc.RPL_MONOFFLINE:
+                var targetsStr string
+                if err := parseMessageParams(msg, nil, &targetsStr); err != nil {
+                        return err
+                }
+                targets := strings.Split(targetsStr, ",")
+
+                online := msg.Command == irc.RPL_MONONLINE
+                for _, target := range targets {
+                        prefix := irc.ParsePrefix(target)
+                        uc.monitored.SetValue(prefix.Name, online)
+                }
+
+                uc.forEachDownstream(func(dc *downstreamConn) {
+                        for _, target := range targets {
+                                prefix := irc.ParsePrefix(target)
+                                if dc.monitored.Has(prefix.Name) {
+                                        dc.SendMessage(&irc.Message{
+                                                Prefix:  dc.srv.prefix(),
+                                                Command: msg.Command,
+                                                Params:  []string{dc.nick, target},
+                                        })
+                                }
+                        }
+                })
+        case irc.ERR_MONLISTFULL:
+                var limit, targetsStr string
+                if err := parseMessageParams(msg, nil, &limit, &targetsStr); err != nil {
+                        return err
+                }
+
+                targets := strings.Split(targetsStr, ",")
+                uc.forEachDownstream(func(dc *downstreamConn) {
+                        for _, target := range targets {
+                                if dc.monitored.Has(target) {
+                                        dc.SendMessage(&irc.Message{
+                                                Prefix:  dc.srv.prefix(),
+                                                Command: msg.Command,
+                                                Params:  []string{dc.nick, limit, target},
+                                        })
+                                }
+                        }
+                })
         case irc.RPL_AWAY:
                 var nick, reason string
@@ -1913 +1958 @@
         uch.updateAutoDetach(ch.DetachAfter)
 }
+
+func (uc *upstreamConn) updateMonitor() {
+        add := make(map[string]struct{})
+        var addList []string
+        seen := make(map[string]struct{})
+        uc.forEachDownstream(func(dc *downstreamConn) {
+                for targetCM := range dc.monitored.innerMap {
+                        if !uc.monitored.Has(targetCM) {
+                                if _, ok := add[targetCM]; !ok {
+                                        addList = append(addList, targetCM)
+                                }
+                                add[targetCM] = struct{}{}
+                        } else {
+                                seen[targetCM] = struct{}{}
+                        }
+                }
+        })
+
+        removeAll := true
+        var removeList []string
+        for targetCM, entry := range uc.monitored.innerMap {
+                if _, ok := seen[targetCM]; ok {
+                        removeAll = false
+                } else {
+                        removeList = append(removeList, entry.originalKey)
+                }
+        }
+
+        // TODO: better handle the case where len(uc.monitored) + len(addList)
+        // exceeds the limit, probably by immediately sending ERR_MONLISTFULL?
+
+        if removeAll && len(addList) == 0 && len(removeList) > 0 {
+                // Optimization when the last MONITOR-aware downstream disconnects
+                uc.SendMessage(&irc.Message{
+                        Command: "MONITOR",
+                        Params:  []string{"C"},
+                })
+        } else {
+                msgs := generateMonitor("-", removeList)
+                msgs = append(msgs, generateMonitor("+", addList)...)
+                for _, msg := range msgs {
+                        uc.SendMessage(msg)
+                }
+        }
+
+        for _, target := range removeList {
+                uc.monitored.Delete(target)
+        }
+}

trunk/user.go

@@ -343 +343 @@
         net.channels.SetCasemapping(newCasemap)
         net.delivered.m.SetCasemapping(newCasemap)
-        if net.conn != nil {
-                net.conn.channels.SetCasemapping(newCasemap)
-                for _, entry := range net.conn.channels.innerMap {
+        if uc := net.conn; uc != nil {
+                uc.channels.SetCasemapping(newCasemap)
+                for _, entry := range uc.channels.innerMap {
                         uch := entry.value.(*upstreamChannel)
                         uch.Members.SetCasemapping(newCasemap)
                 }
-        }
+                uc.monitored.SetCasemapping(newCasemap)
+        }
+        net.forEachDownstream(func(dc *downstreamConn) {
+                dc.monitored.SetCasemapping(newCasemap)
+        })
 }
 
@@ -520 +524 @@
 
                         uc.updateAway()
+                        uc.updateMonitor()
 
                         netIDStr := fmt.Sprintf("%v", uc.network.ID)
@@ -589 +594 @@
                         dc := e.dc
 
+                        if dc.network != nil {
+                                dc.monitored.SetCasemapping(dc.network.casemap)
+                        }
+
                         if err := dc.welcome(); err != nil {
                                 dc.logger.Printf("failed to handle new registered connection: %v", err)
@@ -621 +630 @@
                         u.forEachUpstream(func(uc *upstreamConn) {
                                 uc.updateAway()
+                                uc.updateMonitor()
                         })
                 case eventDownstreamMessage: