""" ircs2s_common.py: Common base protocol class with functions shared by TS6 and P10-based protocols. """ import re import time from collections import defaultdict from pylinkirc import conf, utils from pylinkirc.classes import IRCNetwork, ProtocolError from pylinkirc.log import log class IncrementalUIDGenerator(): """ Incremental UID Generator module, adapted from InspIRCd source: https://github.com/inspircd/inspircd/blob/f449c6b296ab/src/server.cpp#L85-L156 """ def __init__(self, sid): if not (hasattr(self, 'allowedchars') and hasattr(self, 'length')): raise RuntimeError("Allowed characters list not defined. Subclass " "%s by defining self.allowedchars and self.length " "and then calling super().__init__()." % self.__class__.__name__) self.uidchars = [self.allowedchars[0]]*self.length self.sid = str(sid) def increment(self, pos=None): """ Increments the UID generator to the next available UID. """ # Position starts at 1 less than the UID length. if pos is None: pos = self.length - 1 # If we're at the last character in the list of allowed ones, reset # and increment the next level above. if self.uidchars[pos] == self.allowedchars[-1]: self.uidchars[pos] = self.allowedchars[0] self.increment(pos-1) else: # Find what position in the allowed characters list we're currently # on, and add one. idx = self.allowedchars.find(self.uidchars[pos]) self.uidchars[pos] = self.allowedchars[idx+1] def next_uid(self): """ Returns the next unused UID for the server. """ uid = self.sid + ''.join(self.uidchars) self.increment() return uid class IRCCommonProtocol(IRCNetwork): COMMON_PREFIXMODES = [('h', 'halfop'), ('a', 'admin'), ('q', 'owner'), ('y', 'owner')] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._caps = {} self._use_builtin_005_handling = False # Disabled by default for greater security def post_connect(self): self._caps.clear() def validate_server_conf(self): """Validates that the server block given contains the required keys.""" for k in self.conf_keys: log.debug('(%s) Checking presence of conf key %r', self.name, k) conf.validate(k in self.serverdata, "Missing option %r in server block for network %s." % (k, self.name)) port = self.serverdata['port'] conf.validate(isinstance(port, int) and 0 < port < 65535, "Invalid port %r for network %s" % (port, self.name)) @staticmethod def parse_args(args): """ Parses a string or list of of RFC1459-style arguments, where ":" may be used for multi-word arguments that last until the end of a line. """ if isinstance(args, str): args = args.split(' ') real_args = [] for idx, arg in enumerate(args): if arg.startswith(':') and idx != 0: # ":" is used to begin multi-word arguments that last until the end of the message. # Use list splicing here to join them into one argument, and then add it to our list of args. joined_arg = ' '.join(args[idx:])[1:] # Cut off the leading : as well real_args.append(joined_arg) break real_args.append(arg) return real_args @classmethod def parse_prefixed_args(cls, args): """Similar to parse_args(), but stripping leading colons from the first argument of a line (usually the sender field).""" args = cls.parse_args(args) args[0] = args[0].split(':', 1)[1] return args @staticmethod def parse_isupport(args, fallback=''): """ Parses a string of capabilities in the 005 / RPL_ISUPPORT format. """ if isinstance(args, str): args = args.split(' ') caps = {} for cap in args: try: # Try to split it as a KEY=VALUE pair. key, value = cap.split('=', 1) except ValueError: key = cap value = fallback caps[key] = value return caps @staticmethod def parse_isupport_prefixes(args): """ Separates prefixes field like "(qaohv)~&@%+" into a dict mapping mode characters to mode prefixes. """ prefixsearch = re.search(r'\(([A-Za-z]+)\)(.*)', args) return dict(zip(prefixsearch.group(1), prefixsearch.group(2))) @classmethod def parse_message_tags(cls, data): """ Parses IRCv3.2 message tags from a message, as described at http://ircv3.net/specs/core/message-tags-3.2.html data is a list of command arguments, split by spaces. """ # Example query: # @aaa=bbb;ccc;example.com/ddd=eee :nick!ident@host.com PRIVMSG me :Hello if data[0].startswith('@'): tagdata = data[0].lstrip('@').split(';') for idx, tag in enumerate(tagdata): tag = tag.replace(r'\s', ' ') tag = tag.replace(r'\\', '\\') tag = tag.replace(r'\r', '\r') tag = tag.replace(r'\n', '\n') tag = tag.replace(r'\:', ';') tagdata[idx] = tag results = cls.parse_isupport(tagdata, fallback=None) return results return {} def handle_away(self, source, command, args): """Handles incoming AWAY messages.""" # TS6: # <- :6ELAAAAAB AWAY :Auto-away # <- :6ELAAAAAB AWAY # P10: # <- ABAAA A :blah # <- ABAAA A if source not in self.users: return try: self.users[source].away = text = args[0] except IndexError: # User is unsetting away status self.users[source].away = text = '' return {'text': text} def handle_error(self, numeric, command, args): """Handles ERROR messages - these mean that our uplink has disconnected us!""" raise ProtocolError('Received an ERROR, disconnecting!') def handle_pong(self, source, command, args): """Handles incoming PONG commands.""" if source == self.uplink: self.lastping = time.time() def handle_005(self, source, command, args): """ Handles 005 / RPL_ISUPPORT. This is used by at least Clientbot and ngIRCd (for server negotiation). """ # ngIRCd: # <- :ngircd.midnight.local 005 pylink-devel.int NETWORK=ngircd-test :is my network name # <- :ngircd.midnight.local 005 pylink-devel.int RFC2812 IRCD=ngIRCd CHARSET=UTF-8 CASEMAPPING=ascii PREFIX=(qaohv)~&@%+ CHANTYPES=#&+ CHANMODES=beI,k,l,imMnOPQRstVz CHANLIMIT=#&+:10 :are supported on this server # <- :ngircd.midnight.local 005 pylink-devel.int CHANNELLEN=50 NICKLEN=21 TOPICLEN=490 AWAYLEN=127 KICKLEN=400 MODES=5 MAXLIST=beI:50 EXCEPTS=e INVEX=I PENALTY :are supported on this server # Regular clientbot, connecting to InspIRCd: # <- :millennium.overdrivenetworks.com 005 ice AWAYLEN=200 CALLERID=g CASEMAPPING=rfc1459 CHANMODES=IXbegw,k,FJLfjl,ACKMNOPQRSTUcimnprstz CHANNELLEN=64 CHANTYPES=# CHARSET=ascii ELIST=MU ESILENCE EXCEPTS=e EXTBAN=,ACNOQRSTUcmprsuz FNC INVEX=I :are supported by this server # <- :millennium.overdrivenetworks.com 005 ice KICKLEN=255 MAP MAXBANS=60 MAXCHANNELS=30 MAXPARA=32 MAXTARGETS=20 MODES=20 NAMESX NETWORK=OVERdrive-IRC NICKLEN=21 OVERRIDE PREFIX=(Yqaohv)*~&@%+ SILENCE=32 :are supported by this server # <- :millennium.overdrivenetworks.com 005 ice SSL=[::]:6697 STARTTLS STATUSMSG=*~&@%+ TOPICLEN=307 UHNAMES USERIP VBANLIST WALLCHOPS WALLVOICES WATCH=32 :are supported by this server if not self._use_builtin_005_handling: log.warning("(%s) Got spurious 005 message from %s: %r", self.name, source, args) return newcaps = self.parse_isupport(args[1:-1]) self._caps.update(newcaps) log.debug('(%s) handle_005: self._caps is %s', self.name, self._caps) if 'CHANMODES' in newcaps: self.cmodes['*A'], self.cmodes['*B'], self.cmodes['*C'], self.cmodes['*D'] = \ newcaps['CHANMODES'].split(',') log.debug('(%s) handle_005: cmodes: %s', self.name, self.cmodes) if 'USERMODES' in newcaps: self.umodes['*A'], self.umodes['*B'], self.umodes['*C'], self.umodes['*D'] = \ newcaps['USERMODES'].split(',') log.debug('(%s) handle_005: umodes: %s', self.name, self.umodes) if 'CASEMAPPING' in newcaps: self.casemapping = newcaps.get('CASEMAPPING', self.casemapping) log.debug('(%s) handle_005: casemapping set to %s', self.name, self.casemapping) if 'PREFIX' in newcaps: self.prefixmodes = prefixmodes = self.parse_isupport_prefixes(newcaps['PREFIX']) log.debug('(%s) handle_005: prefix modes set to %s', self.name, self.prefixmodes) # Autodetect common prefix mode names. for char, modename in self.COMMON_PREFIXMODES: # Don't overwrite existing named mode definitions. if char in self.prefixmodes and modename not in self.cmodes: self.cmodes[modename] = char log.debug('(%s) handle_005: autodetecting mode %s (%s) as %s', self.name, char, self.prefixmodes[char], modename) # https://defs.ircdocs.horse/defs/isupport.html if 'EXCEPTS' in newcaps: # Handle EXCEPTS=e or EXCEPTS fields self.cmodes['banexception'] = newcaps.get('EXCEPTS') or 'e' log.debug('(%s) handle_005: got cmode banexception=%r', self.name, self.cmodes['banexception']) if 'INVEX' in newcaps: # Handle INVEX=I, INVEX fields self.cmodes['invex'] = newcaps.get('INVEX') or 'I' log.debug('(%s) handle_005: got cmode invex=%r', self.name, self.cmodes['invex']) if 'NICKLEN' in newcaps: # Handle NICKLEN=number assert newcaps['NICKLEN'], "Got NICKLEN tag with no content?" self.maxnicklen = int(newcaps['NICKLEN']) log.debug('(%s) handle_005: got %r for maxnicklen', self.name, self.maxnicklen) if 'DEAF' in newcaps: # Handle DEAF=D, DEAF fields self.umodes['deaf'] = newcaps.get('DEAF') or 'D' log.debug('(%s) handle_005: got umode deaf=%r', self.name, self.umodes['deaf']) if 'CALLERID' in newcaps: # Handle CALLERID=g, CALLERID fields self.umodes['callerid'] = newcaps.get('CALLERID') or 'g' log.debug('(%s) handle_005: got umode callerid=%r', self.name, self.umodes['callerid']) if 'STATUSMSG' in newcaps: # Note: This assumes that all available prefixes can be used in STATUSMSG too. # Even though this isn't always true, I don't see the point in making things # any more complicated. self.protocol_caps |= {'has-statusmsg'} def _send_with_prefix(self, source, msg, **kwargs): """Sends a RFC1459-style raw command from the given sender.""" self.send(':%s %s' % (self._expandPUID(source), msg), **kwargs) class IRCS2SProtocol(IRCCommonProtocol): COMMAND_TOKENS = {} def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.protocol_caps = {'can-spawn-clients', 'has-ts', 'can-host-relay', 'can-track-servers'} # Alias self.handle_squit = self._squit def handle_events(self, data): """Event handler for RFC1459-like protocols. This passes most commands to the various handle_ABCD() functions elsewhere defined protocol modules, coersing various sender prefixes from nicks and server names to UIDs and SIDs respectively, whenever possible. Commands sent without an explicit sender prefix will have them set to the SID of the uplink server. """ data = data.split(" ") tags = self.parse_message_tags(data) if tags: # If we have message tags, split off the first argument. data = data[1:] args = self.parse_args(data) sender = args[0] sender = sender.lstrip(':') # If the sender isn't in numeric format, try to convert it automatically. sender_sid = self._get_SID(sender) sender_uid = self._get_UID(sender) if sender_sid in self.servers: # Sender is a server (converting from name to SID gave a valid result). sender = sender_sid elif sender_uid in self.users: # Sender is a user (converting from name to UID gave a valid result). sender = sender_uid elif not (args[0].startswith(':')): # No sender prefix; treat as coming from uplink IRCd. sender = self.uplink args.insert(0, sender) raw_command = args[1].upper() args = args[2:] log.debug('(%s) Found message sender as %s, raw_command=%r, args=%r', self.name, sender, raw_command, args) # For P10, convert the command token into a regular command, if present. command = self.COMMAND_TOKENS.get(raw_command, raw_command) if command != raw_command: log.debug('(%s) Translating token %s to command %s', self.name, raw_command, command) if self.is_internal_client(sender) or self.is_internal_server(sender): log.warning("(%s) Received command %s being routed the wrong way!", self.name, command) return if command == 'ENCAP': # Special case for TS6 encapsulated commands (ENCAP), in forms like this: # <- :00A ENCAP * SU 42XAAAAAC :GLolol command = args[1] args = args[2:] log.debug("(%s) Rewriting incoming ENCAP to command %s (args: %s)", self.name, command, args) try: func = getattr(self, 'handle_'+command.lower()) except AttributeError: # Unhandled command pass else: parsed_args = func(sender, command, args) if parsed_args is not None: if tags: parsed_args['tags'] = tags # Add message tags to this hook payload. return [sender, command, parsed_args] def invite(self, source, target, channel): """Sends an INVITE from a PyLink client.""" if not self.is_internal_client(source): raise LookupError('No such PyLink client exists.') self._send_with_prefix(source, 'INVITE %s %s' % (self._expandPUID(target), channel)) def kick(self, numeric, channel, target, reason=None): """Sends kicks from a PyLink client/server.""" if (not self.is_internal_client(numeric)) and \ (not self.is_internal_server(numeric)): raise LookupError('No such PyLink client/server exists.') if not reason: reason = 'No reason given' # Mangle kick targets for IRCds that require it. real_target = self._expandPUID(target) self._send_with_prefix(numeric, 'KICK %s %s :%s' % (channel, real_target, reason)) # We can pretend the target left by its own will; all we really care about # is that the target gets removed from the channel userlist, and calling # handle_part() does that just fine. self.handle_part(target, 'KICK', [channel]) def numeric(self, source, numeric, target, text): """Sends raw numerics from a server to a remote client. This is used for WHOIS replies.""" # Mangle the target for IRCds that require it. target = self._expandPUID(target) self._send_with_prefix(source, '%s %s %s' % (numeric, target, text)) def part(self, client, channel, reason=None): """Sends a part from a PyLink client.""" if not self.is_internal_client(client): log.error('(%s) Error trying to part %r from %r (no such client exists)', self.name, client, channel) raise LookupError('No such PyLink client exists.') msg = "PART %s" % channel if reason: msg += " :%s" % reason self._send_with_prefix(client, msg) self.handle_part(client, 'PART', [channel]) def _ping_uplink(self): """Sends a PING to the uplink. This is mostly used by PyLink internals to check whether the remote link is up.""" if self.sid and self.connected.is_set(): self._send_with_prefix(self.sid, 'PING %s' % self._expandPUID(self.uplink)) def quit(self, numeric, reason): """Quits a PyLink client.""" if self.is_internal_client(numeric): self._send_with_prefix(numeric, "QUIT :%s" % reason) self._remove_client(numeric) else: raise LookupError("No such PyLink client exists.") def message(self, numeric, target, text): """Sends a PRIVMSG from a PyLink client.""" if not self.is_internal_client(numeric): raise LookupError('No such PyLink client exists.') # Mangle message targets for IRCds that require it. target = self._expandPUID(target) self._send_with_prefix(numeric, 'PRIVMSG %s :%s' % (target, text)) def notice(self, numeric, target, text): """Sends a NOTICE from a PyLink client or server.""" if (not self.is_internal_client(numeric)) and \ (not self.is_internal_server(numeric)): raise LookupError('No such PyLink client/server exists.') # Mangle message targets for IRCds that require it. target = self._expandPUID(target) self._send_with_prefix(numeric, 'NOTICE %s :%s' % (target, text)) def squit(self, source, target, text='No reason given'): """SQUITs a PyLink server.""" # -> SQUIT 9PZ :blah, blah log.debug('(%s) squit: source=%s, target=%s', self.name, source, target) self._send_with_prefix(source, 'SQUIT %s :%s' % (self._expandPUID(target), text)) self.handle_squit(source, 'SQUIT', [target, text]) def topic(self, source, target, text): """Sends a TOPIC change from a PyLink client or server.""" if (not self.is_internal_client(source)) and (not self.is_internal_server(source)): raise LookupError('No such PyLink client/server exists.') self._send_with_prefix(source, 'TOPIC %s :%s' % (target, text)) self._channels[target].topic = text self._channels[target].topicset = True topic_burst = topic def handle_invite(self, numeric, command, args): """Handles incoming INVITEs.""" # TS6: # <- :70MAAAAAC INVITE 0ALAAAAAA #blah 12345 # P10: # <- ABAAA I PyLink-devel #services 1460948992 # Note that the target is a nickname, not a numeric. target = self._get_UID(args[0]) channel = args[1] curtime = int(time.time()) try: ts = int(args[2]) except IndexError: ts = curtime ts = ts or curtime # Treat 0 timestamps (e.g. inspircd) as the current time. return {'target': target, 'channel': channel, 'ts': ts} def handle_kick(self, source, command, args): """Handles incoming KICKs.""" # :70MAAAAAA KICK #test 70MAAAAAA :some reason channel = args[0] kicked = self._get_UID(args[1]) try: reason = args[2] except IndexError: reason = '' log.debug('(%s) Removing kick target %s from %s', self.name, kicked, channel) self.handle_part(kicked, 'KICK', [channel, reason]) return {'channel': channel, 'target': kicked, 'text': reason} def handle_kill(self, source, command, args): """Handles incoming KILLs.""" killed = self._get_UID(args[0]) # Some IRCds send explicit QUIT messages for their killed clients in addition to KILL, # meaning that our target client may have been removed already. If this is the case, # don't bother forwarding this message on. # Generally, we only need to distinguish between KILL and QUIT if the target is # one of our clients, in which case the above statement isn't really applicable. if killed in self.users: userdata = self._remove_client(killed) else: return # TS6-style kills look something like this: # <- :GL KILL 38QAAAAAA :hidden-1C620195!GL (test) # What we actually want is to format a pretty kill message, in the form # "Killed (killername (reason))". if '!' in args[1].split(" ", 1)[0]: try: # Get the nick or server name of the caller. killer = self.get_friendly_name(source) except KeyError: # Killer was... neither? We must have aliens or something. Fallback # to the given "UID". killer = source # Get the reason, which is enclosed in brackets. killmsg = ' '.join(args[1].split(" ")[1:])[1:-1] if not killmsg: log.warning('(%s) Failed to extract kill reason: %r', irc.name, args) killmsg = '' else: # We already have a preformatted kill, so just pass it on as is. # XXX: this does create a convoluted kill string if we want to forward kills # over relay. # InspIRCd: # <- :1MLAAAAA1 KILL 0ALAAAAAC :Killed (GL (test)) # ngIRCd: # <- :GL KILL PyLink-devel :KILLed by GL: ? killmsg = args[1] return {'target': killed, 'text': killmsg, 'userdata': userdata} def _check_cloak_change(self, uid): # Stub by default return def _check_umode_away_change(self, uid): # Handle away status changes based on umode +a awaymode = self.umodes.get('away') if uid in self.users and awaymode: u = self.users[uid] old_away_status = u.away # Check whether the user is marked away, and send a hook update only if the status has changed. away_status = (awaymode, None) in u.modes if away_status != bool(old_away_status): # This sets a dummy away reason of "Away" because no actual text is provided. self.call_hooks([uid, 'AWAY', {'text': 'Away' if away_status else ''}]) def _check_oper_status_change(self, uid, modes): if uid in self.users: u = self.users[uid] if 'servprotect' in self.umodes and (self.umodes['servprotect'], None) in u.modes: opertype = 'Network Service' elif 'netadmin' in self.umodes and (self.umodes['netadmin'], None) in u.modes: opertype = 'Network Administrator' elif 'admin' in self.umodes and (self.umodes['admin'], None) in u.modes: opertype = 'Server Administrator' else: opertype = 'IRC Operator' if ('+o', None) in modes: self.call_hooks([uid, 'CLIENT_OPERED', {'text': opertype}]) def handle_mode(self, source, command, args): """Handles mode changes.""" # InspIRCd: # <- :70MAAAAAA MODE 70MAAAAAA -i+xc # P10: # <- ABAAA M GL -w # <- ABAAA M #test +v ABAAB 1460747615 # <- ABAAA OM #test +h ABAAA target = self._get_UID(args[0]) if self.is_channel(target): channeldata = self._channels[target].deepcopy() else: channeldata = None modestrings = args[1:] changedmodes = self.parse_modes(target, modestrings) self.apply_modes(target, changedmodes) if target in self.users: # Target was a user. Check for any cloak and away status changes. self._check_cloak_change(target) self._check_umode_away_change(target) self._check_oper_status_change(target, changedmodes) return {'target': target, 'modes': changedmodes, 'channeldata': channeldata} def handle_part(self, source, command, args): """Handles incoming PART commands.""" channels = args[0].split(',') for channel in channels.copy(): if channel not in self._channels or source not in self._channels[channel].users: # Ignore channels the user isn't on, and remove them from any hook payloads. channels.remove(channel) self._channels[channel].remove_user(source) try: self.users[source].channels.discard(channel) except KeyError: log.debug("(%s) handle_part: KeyError trying to remove %r from %r's channel list?", self.name, channel, source) try: reason = args[1] except IndexError: reason = '' if channels: return {'channels': channels, 'text': reason} def handle_privmsg(self, source, command, args): """Handles incoming PRIVMSG/NOTICE.""" # TS6: # <- :70MAAAAAA PRIVMSG #dev :afasfsa # <- :70MAAAAAA NOTICE 0ALAAAAAA :afasfsa # P10: # <- ABAAA P AyAAA :privmsg text # <- ABAAA O AyAAA :notice text raw_target = args[0] server_check = None if '@' in raw_target and not self.is_channel(raw_target.lstrip(''.join(self.prefixmodes.values()))): log.debug('(%s) Processing user@server message with target %s', self.name, raw_target) raw_target, server_check = raw_target.split('@', 1) if not self.is_server_name(server_check): log.warning('(%s) Got user@server message with invalid server ' 'name %r (full target: %r)', self.name, server_check, args[0]) return target = self._get_UID(raw_target) if server_check is not None: not_found = False if target not in self.users: # Most IRCds don't check locally if the target nick actually exists. # If it doesn't, send an error back. not_found = True else: # I guess we can technically leave this up to the IRCd to do the right # checks here, but maybe that ruins the point of this 'security feature' # in the first place. log.debug('(%s) Checking if target %s/%s exists on server %s', self.name, target, raw_target, server_check) sid = self._get_SID(server_check) if not sid: log.debug('(%s) Failed user@server server check: %s does not exist.', self.name, server_check) not_found = True elif sid != self.get_server(target): log.debug("(%s) Got user@server message for %s/%s, but they " "aren't on the server %s/%s. (full target: %r)", self.name, target, raw_target, server_check, sid, args[0]) not_found = True if not_found: self.numeric(self.sid, 401, source, '%s :No such nick' % args[0]) return # Coerse =#channel from Charybdis op moderated +z to @#channel. if target.startswith('='): target = '@' + target[1:] return {'target': target, 'text': args[1]} handle_notice = handle_privmsg def handle_quit(self, numeric, command, args): """Handles incoming QUIT commands.""" # TS6: # <- :1SRAAGB4T QUIT :Quit: quit message goes here # P10: # <- ABAAB Q :Killed (GL_ (bangbang)) userdata = self._remove_client(numeric) if userdata: return {'text': args[0], 'userdata': userdata} def handle_stats(self, numeric, command, args): """Handles the IRC STATS command.""" # IRCds are mostly consistent with this syntax, with the caller being the source, # the stats type as arg 0, and the target server (SID or hostname) as arg 1 # <- :42XAAAAAB STATS c :7PY return {'stats_type': args[0], 'target': self._get_SID(args[1])} def handle_topic(self, numeric, command, args): """Handles incoming TOPIC changes from clients.""" # <- :70MAAAAAA TOPIC #test :test channel = args[0] topic = args[1] oldtopic = self._channels[channel].topic self._channels[channel].topic = topic self._channels[channel].topicset = True return {'channel': channel, 'setter': numeric, 'text': topic, 'oldtopic': oldtopic} def handle_time(self, numeric, command, args): """Handles incoming /TIME requests.""" return {'target': args[0]} def handle_whois(self, numeric, command, args): """Handles incoming WHOIS commands..""" # TS6: # <- :42XAAAAAB WHOIS 5PYAAAAAA :pylink-devel # P10: # <- ABAAA W Ay :PyLink-devel # First argument is the server that should reply to the WHOIS request # or the server hosting the UID given. We can safely assume that any # WHOIS commands received are for us, since we don't host any real servers # to route it to. return {'target': self._get_UID(args[-1])} def handle_version(self, numeric, command, args): """Handles requests for the PyLink server version.""" return {} # See coremods/handlers.py for how this hook is used