Changeset 684 in code for trunk/downstream.go

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@…>

File:

• trunk/downstream.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