Fix access flags checks and message-tags support

- Access flag accounts are normalized to all-lowercase in db.py so
  ensure that we normalize when checking them as well
- We requested message-tags but oyoyo had no support for parsing them
  and it broke everything if enabled. Fix that, and also enable
  account-tag for another means of checking accounts more reliably

Author: skizzerz

oyoyo/client.py

@@ -296,7 +296,7 @@ def connect(self):
                     buffer = data.pop()
 
                     for el in data:
-                        prefix, command, args = parse_raw_irc_command(el)
+                        tags, prefix, command, args = parse_raw_irc_command(el)
 
                         try:
                             enc = "utf8"
@@ -306,16 +306,18 @@ def connect(self):
                             fargs = [arg.decode(enc) for arg in args if isinstance(arg,bytes)]
 
                         try:
-                            largs = list(args)
                             if prefix is not None:
                                 prefix = prefix.decode(enc)
                             self.stream_handler("<--- receive {0} {1} ({2})".format(prefix, command, ", ".join(fargs)), level="debug")
-                            # for i,arg in enumerate(largs):
-                                # if arg is not None: largs[i] = arg.decode(enc)
+                            if tags:
+                                # TODO: this sucks for two reasons: 1) value is unescaped and may contain semicolons/newlines,
+                                # 2) we're doing str.format unconditionally here (and above) when it should be passed the logging layer as args
+                                # so that we don't waste CPU cycles doing string formatting when the message is never going to be displayed
+                                self.stream_handler("     @{0}".format(";".join("{0}={1}".format(k, v) if v else k for k, v in tags.items())), level="debug")
                             if command in self.command_handler:
-                                self.command_handler[command](self, prefix,*fargs)
+                                self.command_handler[command](self, prefix, *fargs, tags=tags)
                             elif "" in self.command_handler:
-                                self.command_handler[""](self, prefix, command, *fargs)
+                                self.command_handler[""](self, prefix, command, *fargs, tags=tags)
                         except Exception as e:
                             sys.stderr.write(traceback.format_exc())
                             raise e  # ?

oyoyo/parse.py

@@ -25,36 +25,83 @@ def parse_raw_irc_command(element):
     of (prefix, command, args).
     The following is a psuedo BNF of the input text:
 
-    <message>  ::= [':' <prefix> <SPACE> ] <command> <params> <crlf>
+    <message>  ::= [ '@' <tags> <SPACE> ] [ ':' <prefix> <SPACE> ] <command> <params> <crlf>
+    <tags>     ::= <tag> { ';' <tag> }
+    <tag>      ::= <key> [ '=' <value> ]
     <prefix>   ::= <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
     <command>  ::= <letter> { <letter> } | <number> <number> <number>
     <SPACE>    ::= ' ' { ' ' }
     <params>   ::= <SPACE> [ ':' <trailing> | <middle> <params> ]
+    <key>      ::= [ '+' ] [ <vendor> '/' ] <key_name>
 
     <middle>   ::= <Any *non-empty* sequence of octets not including SPACE
                    or NUL or CR or LF, the first of which may not be ':'>
     <trailing> ::= <Any, possibly *empty*, sequence of octets not including
                      NUL or CR or LF>
 
+    <key>      ::= <Any *non-empty* sequence of ASCII letters, digits, or hyphens>
+    <vendor>   ::= <hostname>
+    <value>    ::= <Any, possibly *empty*, sequence of utf-8 characters except
+                   NUL, CR, LF, semicolon (';'), and SPACE>
+
     <crlf>     ::= CR LF
     """
     parts = element.strip().split(bytes(" ", "utf_8"))
-    if parts[0].startswith(bytes(':', 'utf_8')):
-        prefix = parts[0][1:]
-        command = parts[1]
-        args = parts[2:]
+    off = 0
+    tags = {}
+    if parts[0].startswith(bytes('@', "utf_8")):
+        off = 1
+        tags_str = parts[0][1:].split(bytes(';', "utf_8"))
+        for tag in tags_str:
+            tag_parts = tag.split(bytes('=', "utf_8"), maxsplit=1)
+            if len(tag_parts) == 2 and len(tag_parts[1]) > 0:
+                v = []
+                esc = False
+                for c in tag_parts[1].decode("utf-8"):
+                    match (esc, c):
+                        case (True, ':'):
+                            v.append(';')
+                            esc = False
+                        case (True, 's'):
+                            v.append(' ')
+                            esc = False
+                        case (True, '\\'):
+                            v.append('\\')
+                            esc = False
+                        case (True, 'r'):
+                            v.append('\r')
+                            esc = False
+                        case (True, 'n'):
+                            v.append('\n')
+                            esc = False
+                        case (True, _):
+                            v.append(c)
+                            esc = False
+                        case (False, '\\'):
+                            esc = True
+                        case (False, _):
+                            v.append(c)
+                tags[tag_parts[0].decode("utf-8")] = "".join(v)
+            else:
+                tags[tag_parts[0].decode("utf-8")] = None
+
+    if parts[off].startswith(bytes(':', 'utf_8')):
+        prefix = parts[off][1:]
+        command = parts[off+1]
+        args = parts[off+2:]
     else:
         prefix = None
-        command = parts[0]
-        args = parts[1:]
+        command = parts[off]
+        args = parts[off+1:]
 
     if command.isdigit():
         try:
             command = numeric_events[command]
         except KeyError:
             pass
     command = command.lower()
-    if isinstance(command, bytes): command = command.decode("utf_8")
+    if isinstance(command, bytes):
+        command = command.decode("utf_8")
 
     if args[0].startswith(bytes(':', 'utf_8')):
         args = [bytes(" ", "utf_8").join(args)[1:]]
@@ -64,7 +111,7 @@ def parse_raw_irc_command(element):
                 args = args[:idx] + [bytes(" ", 'utf_8').join(args[idx:])[1:]]
                 break
 
-    return (prefix, command, args)
+    return tags, prefix, command, args
 
 
 def parse_nick(name):

src/handler.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 import base64
+import functools
 import threading
 import subprocess
 import platform
 import time
-import functools
 import logging
 import sys
 from typing import Optional
@@ -16,22 +16,26 @@
 from src.functions import get_participants, get_all_roles, match_role
 from src.dispatcher import MessageDispatcher
 from src.decorators import handle_error, command, hook
-from src.context import Features
+from src.context import Features, NotLoggedIn
 from src.users import User
 from src.events import Event, EventListener
 from src.transport.irc import get_services
 from src.channels import Channel
 
 @handle_error
-def on_privmsg(cli, rawnick, chan, msg, *, notice=False):
+def on_privmsg(cli, rawnick, chan, msg, *, notice=False, tags=None):
     if notice and "!" not in rawnick or not rawnick: # server notice; we don't care about those
         return
 
     _ignore_locals_ = False
     if config.Main.get("telemetry.errors.user_data_level") == 0 or config.Main.get("telemetry.errors.channel_data_level") == 0:
         _ignore_locals_ = True  # don't expose in tb if we're trying to anonymize stuff
 
+    if tags is None:
+        tags = {}
+
     user = users.get(rawnick, allow_none=True)
+    account_tag = tags.get("account", NotLoggedIn)
 
     ch = chan.lstrip("".join(Features["PREFIX"]))
 
@@ -43,6 +47,13 @@ def on_privmsg(cli, rawnick, chan, msg, *, notice=False):
     if user is None or target is None:
         return
 
+    if Features.account_tag and user.account != account_tag:
+        old_account = user.account
+        old_user = user
+        user.account = account_tag
+        user = users.get(user.nick, user.ident, user.host, account_tag)
+        Event("account_change", {}, old=old_user).dispatch(user, old_account)
+
     wrapper = MessageDispatcher(user, target)
 
     if wrapper.public and config.Main.get("transports[0].user.ignore.hidden") and not chan.startswith(tuple(Features["CHANTYPES"])):
@@ -194,9 +205,9 @@ def parse_and_dispatch(wrapper: MessageDispatcher,
         if phase == cur_phase: # don't call any more commands if one we just called executed a phase transition
             fn.caller(dispatch, message)
 
-def unhandled(cli, prefix, cmd, *args):
+def unhandled(cli, prefix, cmd, *args, tags):
     for fn in decorators.HOOKS.get(cmd, []):
-        fn.caller(cli, prefix, *args)
+        fn.caller(cli, prefix, *args, tags=tags)
 
 def ping_server(cli: IRCClient):
     cli.send("PING :{0}".format(time.time()))
@@ -206,7 +217,7 @@ def latency(wrapper, message):
     ping_server(wrapper.client)
 
     @hook("pong", hookid=300)
-    def latency_pong(cli, server, target, ts):
+    def latency_pong(cli, server, target, ts, *, tags):
         lat = round(time.time() - float(ts), 3)
         wrapper.reply(messages["latency"].format(lat))
         hook.unhook(300)
@@ -235,7 +246,7 @@ def connect_callback(cli: IRCClient):
 
     @hook("endofmotd", hookid=294)
     @hook("nomotd", hookid=294)
-    def prepare_stuff(cli: IRCClient, prefix: str, *args: str):
+    def prepare_stuff(cli: IRCClient, prefix: str, *args, tags):
         logger.info("Received end of MOTD from {0}", prefix)
 
         # This callback only sets up event listeners
@@ -285,7 +296,7 @@ def setup_handler(evt, target: User | Channel):
     who_end = EventListener(setup_handler)
     who_end.install("who_end")
 
-    def mustregain(cli: IRCClient, server, bot_nick, nick, msg):
+    def mustregain(cli: IRCClient, server, bot_nick, nick, msg, *, tags):
         nonlocal regaincount
 
         config_nick = config.Main.get("transports[0].user.nick")
@@ -303,7 +314,7 @@ def mustregain(cli: IRCClient, server, bot_nick, nick, msg):
         regaincount += 1
         users.Bot.change_nick(config_nick)
 
-    def mustrelease(cli: IRCClient, server, bot_nick, nick, msg):
+    def mustrelease(cli: IRCClient, server, bot_nick, nick, msg, *, tags):
         nonlocal releasecount
 
         config_nick = config.Main.get("transports[0].user.nick")
@@ -331,7 +342,14 @@ def must_use_temp_nick(cli, *etc):
         if services.supports_regain() or services.supports_ghost():
             hook("nicknameinuse", hookid=241)(mustregain)
 
-    request_caps = {"account-notify", "chghost", "extended-join", "multi-prefix"}
+    request_caps = {
+        "account-notify",
+        "account-tag",
+        "chghost",
+        "extended-join",
+        "message-tags",
+        "multi-prefix",
+    }
 
     if config.Main.get("transports[0].authentication.services.use_sasl"):
         request_caps.add("sasl")
@@ -341,7 +359,7 @@ def must_use_temp_nick(cli, *etc):
     selected_sasl = None
 
     @hook("cap")
-    def on_cap(cli: IRCClient, svr, mynick, cmd: str, *caps: str):
+    def on_cap(cli: IRCClient, svr, mynick, cmd: str, *caps: str, tags):
         nonlocal supported_sasl, selected_sasl
         # caps is a star because we might receive multiline in LS
         if cmd == "LS":
@@ -422,7 +440,7 @@ def on_cap(cli: IRCClient, svr, mynick, cmd: str, *caps: str):
 
     if config.Main.get("transports[0].authentication.services.use_sasl"):
         @hook("authenticate")
-        def auth_plus(cli: IRCClient, _, plus):
+        def auth_plus(cli: IRCClient, _, plus, *, tags):
             username: str = config.Main.get("transports[0].authentication.services.username")
             if not username:
                 username = config.Main.get("transports[0].user.nick")
@@ -443,14 +461,14 @@ def auth_plus(cli: IRCClient, _, plus):
                         cli.send("AUTHENTICATE " + auth_token, log="AUTHENTICATE [redacted]")
 
         @hook("saslsuccess")
-        def on_successful_auth(cli: IRCClient, *_):
+        def on_successful_auth(cli: IRCClient, *args, tags):
             Features["sasl"] = selected_sasl
             cli.send("CAP END")
 
         @hook("saslfail")
         @hook("sasltoolong")
         @hook("saslaborted")
-        def on_failure_auth(cli: IRCClient, *_):
+        def on_failure_auth(cli: IRCClient, *args, tags):
             nonlocal selected_sasl
             if selected_sasl == "EXTERNAL" and (supported_sasl is None or "PLAIN" in supported_sasl):
                 # EXTERNAL failed, retry with PLAIN as we may not have set up the client cert yet