From 8234eb73044a1d0e3ef9e93c82418b5331c9e40f Mon Sep 17 00:00:00 2001 From: James Lu Date: Mon, 20 Jul 2015 17:36:43 -0700 Subject: [PATCH] Initial (incomplete and untested!!!) TS6 protocol stub (#40) --- protocols/ts6.py | 733 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 733 insertions(+) create mode 100644 protocols/ts6.py diff --git a/protocols/ts6.py b/protocols/ts6.py new file mode 100644 index 0000000..b912e4d --- /dev/null +++ b/protocols/ts6.py @@ -0,0 +1,733 @@ +import time +import sys +import os +import re +from copy import copy + +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import utils +from log import log + +from classes import * +# Shared with inspircd module because the output is the same. +from inspircd import nickClient, kickServer, kickClient, _sendKick, quitClient, \ + removeClient, partClient, messageClient, noticeClient, topicClient + +hook_map = {} + +def _send(irc, sid, msg): + irc.send(':%s %s' % (sid, msg)) + +def spawnClient(irc, nick, ident='null', host='null', realhost=None, modes=set(), + server=None, ip='0.0.0.0', realname=None): + server = server or irc.sid + if not utils.isInternalServer(irc, server): + raise ValueError('Server %r is not a PyLink internal PseudoServer!' % server) + # We need a separate UID generator instance for every PseudoServer + # we spawn. Otherwise, things won't wrap around properly. + if server not in irc.uidgen: + irc.uidgen[server] = utils.TS6UIDGenerator(server) + uid = irc.uidgen[server].next_uid() + # UID: + # parameters: nickname, hopcount, nickTS, umodes, username, + # visible hostname, IP address, UID, gecos + ts = int(time.time()) + realname = realname or irc.botdata['realname'] + realhost = realhost or host + raw_modes = utils.joinModes(modes) + u = irc.users[uid] = IrcUser(nick, ts, uid, ident=ident, host=host, realname=realname, + realhost=realhost, ip=ip, modes=modes) + irc.servers[server].users.append(uid) + _send(irc, server, "UID {nick} 1 {ts} {modes} {ident} {host} {ip} {uid}" + ":{realname}".format(ts=ts, host=host, + nick=nick, ident=ident, uid=uid, + modes=raw_modes, ip=ip, realname=realname)) + return u + +def joinClient(irc, client, channel): + channel = channel.lower() + server = utils.isInternalClient(irc, client) + # JOIN: + # parameters: channelTS, channel, '+' (a plus sign) + if not server: + log.error('(%s) Error trying to join client %r to %r (no such pseudoclient exists)', irc.name, client, channel) + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, client, "JOIN {ts} {channel} +".format( + ts=irc.channels[channel].ts, channel=channel)) + irc.channels[channel].users.add(client) + irc.users[client].channels.add(channel) + +def sjoinServer(irc, server, channel, users, ts=None): + # https://github.com/grawity/irc-docs/blob/master/server/ts6.txt#L821 + # parameters: channelTS, channel, simple modes, opt. mode parameters..., nicklist + + # Broadcasts a channel creation or bursts a channel. + + # The nicklist consists of users joining the channel, with status prefixes for + # their status ('@+', '@', '+' or ''), for example: + # '@+1JJAAAAAB +2JJAAAA4C 1JJAAAADS'. All users must be behind the source server + # so it is not possible to use this message to force users to join a channel. + channel = channel.lower() + server = server or irc.sid + assert users, "sjoinServer: No users sent?" + if not server: + raise LookupError('No such PyLink PseudoClient exists.') + if ts is None: + ts = irc.channels[channel].ts + log.debug("sending SJOIN to %s%s with ts %s (that's %r)", channel, irc.name, ts, + time.strftime("%c", time.localtime(ts))) + modes = irc.channels[channel].modes + uids = [] + changedmodes = [] + namelist = [] + # We take as a list of (prefixmodes, uid) pairs. + for userpair in users: + assert len(userpair) == 2, "Incorrect format of userpair: %r" % userpair + prefixes, user = userpair + prefixchars = ''.join([irc.prefixmodes[prefix] for prefix in prefixes]) + namelist.append(prefixchars+user) + uids.append(user) + for m in prefixes: + changedmodes.append(('+%s' % m, user)) + try: + irc.users[user].channels.add(channel) + except KeyError: # Not initialized yet? + log.debug("(%s) sjoinServer: KeyError trying to add %r to %r's channel list?", irc.name, channel, user) + utils.applyModes(irc, channel, changedmodes) + namelist = ' '.join(namelist) + _send(irc, server, "SJOIN {ts} {channel} {modes} :{users}".format( + ts=ts, users=namelist, channel=channel, + modes=utils.joinModes(modes))) + irc.channels[channel].users.update(uids) + +''' +def partClient(irc, client, channel, reason=None): + channel = channel.lower() + if not utils.isInternalClient(irc, client): + log.error('(%s) Error trying to part client %r to %r (no such pseudoclient exists)', irc.name, client, channel) + raise LookupError('No such PyLink PseudoClient exists.') + msg = "PART %s" % channel + if reason: + msg += " :%s" % reason + _send(irc, client, msg) + handle_part(irc, client, 'PART', [channel]) + +def removeClient(irc, numeric): + """ + + Removes a client from our internal databases, regardless + of whether it's one of our pseudoclients or not.""" + for v in irc.channels.values(): + v.removeuser(numeric) + sid = numeric[:3] + log.debug('Removing client %s from irc.users', numeric) + del irc.users[numeric] + log.debug('Removing client %s from irc.servers[%s]', numeric, sid) + irc.servers[sid].users.remove(numeric) + +def quitClient(irc, numeric, reason): + """ + + Quits a PyLink PseudoClient.""" + if utils.isInternalClient(irc, numeric): + _send(irc, numeric, "QUIT :%s" % reason) + removeClient(irc, numeric) + else: + raise LookupError("No such PyLink PseudoClient exists. If you're trying to remove " + "a user that's not a PyLink PseudoClient from " + "the internal state, use removeClient() instead.") + +def _sendKick(irc, numeric, channel, target, reason=None): + """ + + Sends a kick from a PyLink PseudoClient.""" + channel = channel.lower() + if not reason: + reason = 'No reason given' + _send(irc, numeric, 'KICK %s %s :%s' % (channel, 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. + handle_part(irc, target, 'KICK', [channel]) + +def kickClient(irc, numeric, channel, target, reason=None): + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _sendKick(irc, numeric, channel, target, reason=reason) + +def kickServer(irc, numeric, channel, target, reason=None): + if not utils.isInternalServer(irc, numeric): + raise LookupError('No such PyLink PseudoServer exists.') + _sendKick(irc, numeric, channel, target, reason=reason) + +def nickClient(irc, numeric, newnick): + """ + + Changes the nick of a PyLink PseudoClient.""" + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'NICK %s %s' % (newnick, int(time.time()))) + irc.users[numeric].nick = newnick +''' + +def _sendModes(irc, numeric, target, modes, ts=None): + utils.applyModes(irc, target, modes) + if utils.isChannel(target): + ts = ts or irc.channels[target.lower()].ts + # TMODE: + # parameters: channelTS, channel, cmode changes, opt. cmode parameters... + + # On output, at most ten cmode parameters should be sent; if there are more, + # multiple TMODE messages should be sent. + while modes[:10]: + joinedmodes = utils.joinModes(modes[:10]) + _send(irc, numeric, 'TMODE %s %s %s' % (target, ts, joinedmodes)) + else: + joinedmodes = utils.joinModes(modes) + _send(irc, numeric, 'MODE %s %s' % (target, joinedmodes)) + +def modeClient(irc, numeric, target, modes, ts=None): + """ + + Sends modes from a PyLink PseudoClient. should be + a list of (mode, arg) tuples, in the format of utils.parseModes() output. + """ + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _sendModes(irc, numeric, target, modes, ts=ts) + +def modeServer(irc, numeric, target, modes, ts=None): + """ + + Sends modes from a PyLink PseudoServer. should be + a list of (mode, arg) tuples, in the format of utils.parseModes() output. + """ + if not utils.isInternalServer(irc, numeric): + raise LookupError('No such PyLink PseudoServer exists.') + _sendModes(irc, numeric, target, modes, ts=ts) + +def killServer(irc, numeric, target, reason): + """ + + Sends a kill to from a PyLink PseudoServer. + """ + if not utils.isInternalServer(irc, numeric): + raise LookupError('No such PyLink PseudoServer exists.') + # KILL: + # parameters: target user, path + + # The format of the path parameter is some sort of description of the source of + # the kill followed by a space and a parenthesized reason. To avoid overflow, + # it is recommended not to add anything to the path. + + _send(irc, numeric, 'KILL %s :Killed (%s)' % (target, reason)) + removeClient(irc, target) + +def killClient(irc, numeric, target, reason): + """ + + Sends a kill to from a PyLink PseudoClient. + """ + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'KILL %s :Killed (%s)' % (target, reason)) + removeClient(irc, target) + +''' +def messageClient(irc, numeric, target, text): + """ + + Sends PRIVMSG from PyLink client .""" + # https://github.com/grawity/irc-docs/blob/master/server/ts6.txt#L649 + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'PRIVMSG %s :%s' % (target, text)) + +def noticeClient(irc, numeric, target, text): + """ + + Sends NOTICE from PyLink client .""" + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'NOTICE %s :%s' % (target, text)) + + +def topicClient(irc, numeric, target, text): + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'TOPIC %s :%s' % (target, text)) +''' +def topicServer(irc, numeric, target, text): + if not utils.isInternalServer(irc, numeric): + raise LookupError('No such PyLink PseudoServer exists.') + # TB + # capab: TB + # source: server + # propagation: broadcast + # parameters: channel, topicTS, opt. topic setter, topic + ts = int(time.time()) + servername = irc.servers[numeric].name + _send(irc, numeric, 'TB %s %s %s :%s' % (target, ts, servername, text)) + +def inviteClient(irc, numeric, target, channel): + """ + + Invites to to from PyLink client .""" + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + _send(irc, numeric, 'INVITE %s %s %s' % (target, channel, irc.channels[channel].ts)) + +def knockClient(irc, numeric, target, text): + """ + + Knocks on with from PyLink client .""" + if not utils.isInternalClient(irc, numeric): + raise LookupError('No such PyLink PseudoClient exists.') + # No text value is supported here; drop it. + _send(irc, numeric, 'KNOCK %s' % target) + +def updateClient(irc, numeric, field, text): + """ + + Changes the field of PyLink PseudoClient .""" + field = field.upper() + if field == 'HOST': + handle_chghost(irc, numeric, 'PYLINK_UPDATECLIENT_HOST', [text]) + _send(irc, irc.sid, 'CHGHOST %s :%s' % (numeric, text)) + else: + raise NotImplementedError("Changing field %r of a client is unsupported by this protocol." % field) + +def pingServer(irc, source=None, target=None): + source = source or irc.sid + if source is None: + return + if target is not None: + _send(irc, source, 'PING %s %s' % (source, target)) + else: + _send(irc, source, 'PING %s' % source) + +def connect(irc): + ts = irc.start_ts + irc.uidgen = {} + + f = irc.send + # https://github.com/grawity/irc-docs/blob/master/server/ts6.txt#L55 + f('PASS %s TS 6 %s' % (irc.serverdata["sendpass"], irc.sid)) + + # We request the following capabilities (for charybdis): + + # QS: SQUIT doesn't send recursive quits for each users; required + # by charybdis (Source: https://github.com/grawity/irc-docs/blob/master/server/ts-capab.txt) + + # ENCAP: message encapsulation for certain commands, only because + # charybdis requires it to link + + # EX: Support for ban exemptions (+e) + # IE: Support for invite exemptions (+e) + # KNOCK: support for /knock + # SAVE: support for SAVE (forces user to UID in nick collision) + # TB: topic burst command; we send this in topicServer + f('CAPAB :QS ENCAP EX CHW IE KNOCK SAVE SERVICES TB') + + f('SERVER {host} {Pass} 0 {sid} :PyLink Service'.format(host=irc.serverdata["hostname"], + Pass=, sid=irc.sid)) + f(':%s BURST %s' % (irc.sid, ts)) + f(':%s ENDBURST' % (irc.sid)) + +def handle_ping(irc, source, command, args): + # PING: + # source: any + # parameters: origin, opt. destination server + # PONG: + # source: server + # parameters: origin, destination + + # Sends a PING to the destination server, which will reply with a PONG. If the + # destination server parameter is not present, the server receiving the message + # must reply. + try: + destination = args[1] + except IndexError: + destination = irc.sid + if utils.isInternalServer(irc, destination): + _send(irc, destination, 'PONG %s %s' % (destination, source)) + +def handle_pong(irc, source, command, args): + if source == irc.uplink: + irc.lastping = time.time() + +from inspircd import handle_privmsg, handle_kill, handle_kick, handle_error + +''' +def handle_privmsg(irc, source, command, args): + return {'target': args[0], 'text': args[1]} + +def handle_kill(irc, source, command, args): + killed = args[0] + data = irc.users[killed] + removeClient(irc, killed) + return {'target': killed, 'text': args[1], 'userdata': data} + +def handle_kick(irc, source, command, args): + # :70MAAAAAA KICK #endlessvoid 70MAAAAAA :some reason + channel = args[0].lower() + kicked = args[1] + handle_part(irc, kicked, 'KICK', [channel, args[2]]) + return {'channel': channel, 'target': kicked, 'text': args[2]} +''' + +def handle_part(irc, source, command, args): + channels = args[0].lower().split(',') + # We should only get PART commands for channels that exist, right?? + for channel in channels: + irc.channels[channel].removeuser(source) + try: + irc.users[source].channels.discard(channel) + except KeyError: + log.debug("(%s) handle_part: KeyError trying to remove %r from %r's channel list?", irc.name, channel, source) + try: + reason = args[1] + except IndexError: + reason = '' + return {'channels': channels, 'text': reason} + +''' +def handle_error(irc, numeric, command, args): + irc.connected = False + raise ProtocolError('Received an ERROR, killing!') +''' + +# XXX This is where I left off. + +def handle_fjoin(irc, servernumeric, command, args): + # :70M FJOIN #chat 1423790411 +AFPfjnt 6:5 7:5 9:5 :o,1SRAABIT4 v,1IOAAF53R <...> + channel = args[0].lower() + # InspIRCd sends each user's channel data in the form of 'modeprefix(es),UID' + userlist = args[-1].split() + our_ts = irc.channels[channel].ts + their_ts = int(args[1]) + if their_ts < our_ts: + # Channel timestamp was reset on burst + log.debug('(%s) Setting channel TS of %s to %s from %s', + irc.name, channel, their_ts, our_ts) + irc.channels[channel].ts = their_ts + modestring = args[2:-1] or args[2] + parsedmodes = utils.parseModes(irc, channel, modestring) + utils.applyModes(irc, channel, parsedmodes) + namelist = [] + for user in userlist: + modeprefix, user = user.split(',', 1) + namelist.append(user) + irc.users[user].channels.add(channel) + utils.applyModes(irc, channel, [('+%s' % mode, user) for mode in modeprefix]) + irc.channels[channel].users.add(user) + return {'channel': channel, 'users': namelist, 'modes': parsedmodes, 'ts': their_ts} + +def handle_uid(irc, numeric, command, args): + # :70M UID 70MAAAAAB 1429934638 GL 0::1 hidden-7j810p.9mdf.lrek.0000.0000.IP gl 0::1 1429934638 +Wioswx +ACGKNOQXacfgklnoqvx :realname + uid, ts, nick, realhost, host, ident, ip = args[0:7] + realname = args[-1] + irc.users[uid] = IrcUser(nick, ts, uid, ident, host, realname, realhost, ip) + parsedmodes = utils.parseModes(irc, uid, [args[8], args[9]]) + log.debug('Applying modes %s for %s', parsedmodes, uid) + utils.applyModes(irc, uid, parsedmodes) + irc.servers[numeric].users.append(uid) + return {'uid': uid, 'ts': ts, 'nick': nick, 'realhost': realhost, 'host': host, 'ident': ident, 'ip': ip} + +def handle_quit(irc, numeric, command, args): + # <- :1SRAAGB4T QUIT :Quit: quit message goes here + removeClient(irc, numeric) + return {'text': args[0]} + +def handle_server(irc, numeric, command, args): + # SERVER is sent by our uplink or any other server to introduce others. + # <- :00A SERVER test.server * 1 00C :testing raw message syntax + # <- :70M SERVER millennium.overdrive.pw * 1 1ML :a relatively long period of time... (Fremont, California) + servername = args[0].lower() + sid = args[3] + sdesc = args[-1] + irc.servers[sid] = IrcServer(numeric, servername) + return {'name': servername, 'sid': args[3], 'text': sdesc} + +def handle_nick(irc, numeric, command, args): + # <- :70MAAAAAA NICK GL-devel 1434744242 + oldnick = irc.users[numeric].nick + newnick = irc.users[numeric].nick = args[0] + return {'newnick': newnick, 'oldnick': oldnick, 'ts': int(args[1])} + +def handle_save(irc, numeric, command, args): + # This is used to handle nick collisions. Here, the client Derp_ already exists, + # so trying to change nick to it will cause a nick collision. On InspIRCd, + # this will simply set the collided user's nick to its UID. + + # <- :70MAAAAAA PRIVMSG 0AL000001 :nickclient PyLink Derp_ + # -> :0AL000001 NICK Derp_ 1433728673 + # <- :70M SAVE 0AL000001 1433728673 + user = args[0] + irc.users[user].nick = user + return {'target': user, 'ts': int(args[1])} + +def handle_fmode(irc, numeric, command, args): + # <- :70MAAAAAA FMODE #chat 1433653462 +hhT 70MAAAAAA 70MAAAAAD + channel = args[0].lower() + modes = args[2:] + changedmodes = utils.parseModes(irc, channel, modes) + utils.applyModes(irc, channel, changedmodes) + ts = int(args[1]) + return {'target': channel, 'modes': changedmodes, 'ts': ts} + +def handle_mode(irc, numeric, command, args): + # In InspIRCd, MODE is used for setting user modes and + # FMODE is used for channel modes: + # <- :70MAAAAAA MODE 70MAAAAAA -i+xc + target = args[0] + modestrings = args[1:] + changedmodes = utils.parseModes(irc, numeric, modestrings) + utils.applyModes(irc, target, changedmodes) + return {'target': target, 'modes': changedmodes} + +def handle_squit(irc, numeric, command, args): + # :70M SQUIT 1ML :Server quit by GL!gl@0::1 + split_server = args[0] + affected_users = [] + log.info('(%s) Netsplit on server %s', irc.name, split_server) + # Prevent RuntimeError: dictionary changed size during iteration + old_servers = copy(irc.servers) + for sid, data in old_servers.items(): + if data.uplink == split_server: + log.debug('Server %s also hosts server %s, removing those users too...', split_server, sid) + args = handle_squit(irc, sid, 'SQUIT', [sid, "PyLink: Automatically splitting leaf servers of %s" % sid]) + affected_users += args['users'] + for user in copy(irc.servers[split_server].users): + affected_users.append(user) + log.debug('Removing client %s (%s)', user, irc.users[user].nick) + removeClient(irc, user) + del irc.servers[split_server] + log.debug('(%s) Netsplit affected users: %s', irc.name, affected_users) + return {'target': split_server, 'users': affected_users} + +def handle_rsquit(irc, numeric, command, args): + # <- :1MLAAAAIG RSQUIT :ayy.lmao + # <- :1MLAAAAIG RSQUIT ayy.lmao :some reason + # RSQUIT is sent by opers to squit remote servers. + # Strangely, it takes a server name instead of a SID, and is + # allowed to be ignored entirely. + # If we receive a remote SQUIT, split the target server + # ONLY if the sender is identified with us. + target = args[0] + for (sid, server) in irc.servers.items(): + if server.name == target: + target = sid + if utils.isInternalServer(irc, target): + if irc.users[numeric].identified: + uplink = irc.servers[target].uplink + reason = 'Requested by %s' % irc.users[numeric].nick + _send(irc, uplink, 'SQUIT %s :%s' % (target, reason)) + return handle_squit(irc, numeric, 'SQUIT', [target, reason]) + else: + utils.msg(irc, numeric, 'Error: you are not authorized to split servers!', notice=True) + +def handle_idle(irc, numeric, command, args): + """Handle the IDLE command, sent between servers in remote WHOIS queries.""" + # <- :70MAAAAAA IDLE 1MLAAAAIG + # -> :1MLAAAAIG IDLE 70MAAAAAA 1433036797 319 + sourceuser = numeric + targetuser = args[0] + _send(irc, targetuser, 'IDLE %s %s 0' % (sourceuser, irc.users[targetuser].ts)) + +def handle_events(irc, data): + # Each server message looks something like this: + # :70M FJOIN #chat 1423790411 +AFPfjnt 6:5 7:5 9:5 :v,1SRAAESWE + # : ... :final multi word argument + args = data.split() + if not args: + # No data?? + return + if args[0] == 'SERVER': + # <- SERVER whatever.net abcdefgh 0 10X :something + servername = args[1].lower() + numeric = args[4] + if args[2] != irc.serverdata['recvpass']: + # Check if recvpass is correct + raise ProtocolError('Error: recvpass from uplink server %s does not match configuration!' % servername) + irc.servers[numeric] = IrcServer(None, servername) + irc.uplink = numeric + return + elif args[0] == 'CAPAB': + # Capability negotiation with our uplink + if args[1] == 'CHANMODES': + # <- CAPAB CHANMODES :admin=&a allowinvite=A autoop=w ban=b banexception=e blockcolor=c c_registered=r exemptchanops=X filter=g flood=f halfop=%h history=H invex=I inviteonly=i joinflood=j key=k kicknorejoin=J limit=l moderated=m nickflood=F noctcp=C noextmsg=n nokick=Q noknock=K nonick=N nonotice=T official-join=!Y op=@o operonly=O opmoderated=U owner=~q permanent=P private=p redirect=L reginvite=R regmoderated=M secret=s sslonly=z stripcolor=S topiclock=t voice=+v + + # Named modes are essential for a cross-protocol IRC service. We + # can use InspIRCd as a model here and assign their mode map to our cmodes list. + for modepair in args[2:]: + name, char = modepair.split('=') + if name == 'reginvite': # Reginvite? That's a dumb name. + name = 'regonly' + # We don't really care about mode prefixes; just the mode char + irc.cmodes[name.lstrip(':')] = char[-1] + elif args[1] == 'USERMODES': + # <- CAPAB USERMODES :bot=B callerid=g cloak=x deaf_commonchan=c helpop=h hidechans=I hideoper=H invisible=i oper=o regdeaf=R servprotect=k showwhois=W snomask=s u_registered=r u_stripcolor=S wallops=w + # Ditto above. + for modepair in args[2:]: + name, char = modepair.split('=') + irc.umodes[name.lstrip(':')] = char + elif args[1] == 'CAPABILITIES': + # <- CAPAB CAPABILITIES :NICKMAX=21 CHANMAX=64 MAXMODES=20 IDENTMAX=11 MAXQUIT=255 MAXTOPIC=307 MAXKICK=255 MAXGECOS=128 MAXAWAY=200 IP6SUPPORT=1 PROTOCOL=1202 PREFIX=(Yqaohv)!~&@%+ CHANMODES=IXbegw,k,FHJLfjl,ACKMNOPQRSTUcimnprstz USERMODES=,,s,BHIRSWcghikorwx GLOBOPS=1 SVSPART=1 + caps = dict([x.lstrip(':').split('=') for x in args[2:]]) + protocol_version = int(caps['PROTOCOL']) + if protocol_version < 1202: + raise ProtocolError("Remote protocol version is too old! At least 1202 (InspIRCd 2.0.x) is needed. (got %s)" % protocol_version) + irc.maxnicklen = int(caps['NICKMAX']) + irc.maxchanlen = int(caps['CHANMAX']) + # Modes are divided into A, B, C, and D classes + # See http://www.irc.org/tech_docs/005.html + + # FIXME: Find a better way to assign/store this. + irc.cmodes['*A'], irc.cmodes['*B'], irc.cmodes['*C'], irc.cmodes['*D'] \ + = caps['CHANMODES'].split(',') + irc.umodes['*A'], irc.umodes['*B'], irc.umodes['*C'], irc.umodes['*D'] \ + = caps['USERMODES'].split(',') + irc.prefixmodes = re.search(r'\((.*?)\)', caps['PREFIX']).group(1) + # Sanity check: set this AFTER we fetch the capabilities for the network! + irc.connected.set() + try: + real_args = [] + for arg in args: + real_args.append(arg) + # If the argument starts with ':' and ISN'T the first argument. + # The first argument is used for denoting the source UID/SID. + if arg.startswith(':') and args.index(arg) != 0: + # : is used for multi-word arguments that last until the end + # of the message. We can use list splicing here to turn them all + # into one argument. + index = args.index(arg) # Get the array index of the multi-word arg + # Set the last arg to a joined version of the remaining args + arg = args[index:] + arg = ' '.join(arg)[1:] + # Cut the original argument list right before the multi-word arg, + # and then append the multi-word arg. + real_args = args[:index] + real_args.append(arg) + break + real_args[0] = real_args[0].split(':', 1)[1] + args = real_args + + numeric = args[0] + command = args[1] + args = args[2:] + except IndexError: + return + + # We will do wildcard event handling here. Unhandled events are just ignored. + try: + func = globals()['handle_'+command.lower()] + except KeyError: # unhandled event + pass + else: + parsed_args = func(irc, numeric, command, args) + if parsed_args is not None: + return [numeric, command, parsed_args] + +def spawnServer(irc, name, sid=None, uplink=None, desc='PyLink Server', endburst=True): + # -> :0AL SERVER test.server * 1 0AM :some silly pseudoserver + uplink = uplink or irc.sid + name = name.lower() + if sid is None: # No sid given; generate one! + irc.sidgen = utils.TS6SIDGenerator(irc.serverdata["sidrange"]) + sid = irc.sidgen.next_sid() + assert len(sid) == 3, "Incorrect SID length" + if sid in irc.servers: + raise ValueError('A server with SID %r already exists!' % sid) + for server in irc.servers.values(): + if name == server.name: + raise ValueError('A server named %r already exists!' % name) + if not utils.isInternalServer(irc, uplink): + raise ValueError('Server %r is not a PyLink internal PseudoServer!' % uplink) + if not utils.isServerName(name): + raise ValueError('Invalid server name %r' % name) + _send(irc, uplink, 'SERVER %s * 1 %s :%s' % (name, sid, desc)) + irc.servers[sid] = IrcServer(uplink, name, internal=True) + if endburst: + endburstServer(irc, sid) + return sid + +def endburstServer(irc, sid): + _send(irc, sid, 'ENDBURST') + irc.servers[sid].has_bursted = True + +def handle_ftopic(irc, numeric, command, args): + # <- :70M FTOPIC #channel 1434510754 GLo|o|!GLolol@escape.the.dreamland.ca :Some channel topic + channel = args[0].lower() + ts = args[1] + setter = args[2] + topic = args[-1] + irc.channels[channel].topic = topic + irc.channels[channel].topicset = True + return {'channel': channel, 'setter': setter, 'ts': ts, 'topic': topic} + +def handle_topic(irc, numeric, command, args): + # <- :70MAAAAAA TOPIC #test :test + channel = args[0].lower() + topic = args[1] + ts = int(time.time()) + irc.channels[channel].topic = topic + irc.channels[channel].topicset = True + return {'channel': channel, 'setter': numeric, 'ts': ts, 'topic': topic} + +def handle_invite(irc, numeric, command, args): + # <- :70MAAAAAC INVITE 0ALAAAAAA #blah 0 + target = args[0] + channel = args[1].lower() + # We don't actually need to process this; it's just something plugins/hooks can use + return {'target': target, 'channel': channel} + +def handle_encap(irc, numeric, command, args): + # <- :70MAAAAAA ENCAP * KNOCK #blah :agsdfas + # From charybdis TS6 docs: https://github.com/grawity/irc-docs/blob/03ba884a54f1cef2193cd62b6a86803d89c1ac41/server/ts6.txt + + # ENCAP + # source: any + # parameters: target server mask, subcommand, opt. parameters... + + # Sends a command to matching servers. Propagation is independent of + # understanding the subcommand. + + targetmask = args[0] + real_command = args[1] + if targetmask == '*' and real_command == 'KNOCK': + channel = args[2].lower() + text = args[3] + return {'encapcommand': real_command, 'channel': channel, + 'text': text} + +def handle_notice(irc, numeric, command, args): + # <- :70MAAAAAA NOTICE #dev :afasfsa + # <- :70MAAAAAA NOTICE 0ALAAAAAA :afasfsa + return {'target': args[0], 'text': args[1]} + +def handle_opertype(irc, numeric, command, args): + # This is used by InspIRCd to denote an oper up; there is no MODE + # command sent for it. + # <- :70MAAAAAB OPERTYPE Network_Owner + omode = [('+o', None)] + utils.applyModes(irc, numeric, omode) + return {'target': numeric, 'modes': omode} + +def handle_fident(irc, numeric, command, args): + # :70MAAAAAB FHOST test + # :70MAAAAAB FNAME :afdsafasf + # :70MAAAAAB FIDENT test + irc.users[numeric].ident = newident = args[0] + return {'target': numeric, 'newident': newident} + +def handle_fhost(irc, numeric, command, args): + irc.users[numeric].host = newhost = args[0] + return {'target': numeric, 'newhost': newhost} + +def handle_fname(irc, numeric, command, args): + irc.users[numeric].realname = newgecos = args[0] + return {'target': numeric, 'newgecos': newgecos} + +def handle_endburst(irc, numeric, command, args): + return {}