#!/usr/bin/python import socket import ssl import os import re import time import sys import string import hashlib import traceback import irc import getpass from threading import Thread from threading import RLock as Lock import Queue import chardet import modjson dec = modjson.ModJSONDecoder() enc = modjson.ModJSONEncoder(indent=3) # TODO: Rewrite this *entire* module and make more efficient. _listnumerics = dict(b=(367, 368, "channel ban list"), e=(348, 349, "Channel Exception List"), I=(346, 347, "Channel Invite Exception List"), w=(910, 911, "Channel Access List"), g=(941, 940, "chanel spamfilter list"), X=(954, 953, "channel exemptchanops list")) def BouncerReload(BNC): networks, configs = zip(*BNC.conf.items()) json = enc.encode([BNC, configs]) if BNC.isAlive(): BNC.stop() newBNC, newconfs = dec.decode(json) for network, newconf in zip(networks, newconfs): network.rmAddon(BNC) network.addAddon(**newconf) return newBNC class Bouncer (Thread): __name__ = "Bouncer for pyIRC" __version__ = "2.0" __author__ = "Brian Sherson" __date__ = "February 21, 2014" def __init__(self, addr="", port=16667, secure=False, ipv6=False, certfile=None, keyfile=None, ignore=None, debug=False, timeout=300, autoaway=None, servname="bouncer.site"): self.addr = addr self.port = port self.conf = {} self.passwd = {} self.socket = None self.secure = secure self.ipv6 = ipv6 self.certfile = certfile self.keyfile = keyfile self.clients = [] self.ignore = ignore self.debug = debug self.timeout = timeout self.autoaway = autoaway self.servname = servname self._stopexpected = False # Keep track of what extensions/clients are requesting WHO, WHOIS, and LIST, because we don't want to spam every bouncer connection with the server's replies. # In the future, MAY implement this idea in the irc module. self._whoexpected = {} self._whoisexpected = {} self._listexpected = {} self.lock = Lock() self.starttime = int(time.time()) Thread.__init__(self) self.daemon = True self.start() def __repr__(self): h = hash(self) return "".format(**vars()) def run(self): self.socket = socket.socket( socket.AF_INET6 if self.ipv6 else socket.AF_INET) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind((self.addr, self.port)) self.socket.listen(5) #print ((self,"Now listening on port "+str(self.port))) while True: try: (connection, addr) = self.socket.accept() if self.secure: connection = ssl.wrap_socket( connection, server_side=True, certfile=self.certfile, keyfile=self.keyfile, ssl_version=ssl.PROTOCOL_SSLv23) #print ((self,"New client connecting from %s:%s"%addr)) except socket.error: # print "Shutting down Listener" self.socket.close() if not self._stopexpected: raise sys.exit() except: tb = traceback.format_exc() print >>sys.stderr, tb continue connection.settimeout(self.timeout) bouncer = BouncerConnection( self, connection, addr, debug=self.debug) time.sleep(0.5) try: self.socket.close() except: pass self.socket = None Thread.__init__(self) self.daemon = True def onAddonAdd(self, context, label, passwd=None, hashtype="sha512", ignore=None, autoaway=None, translations=[], hidden=[]): for (context2, conf2) in self.conf.items(): if context == context2: raise ValueError, "Context already exists in config." if label == conf2.label: raise ValueError, "Unique label required." if passwd == None: while True: passwd = getpass.getpass("Enter new password: ") if passwd == getpass.getpass("Confirm new password: "): break print "Passwords do not match!" passwd = hashlib.new(hashtype, passwd).hexdigest() conf = irc.Config(self, label=label, passwd=passwd, hashtype=hashtype, ignore=ignore, autoaway=autoaway, translations=[ (key if type(key) == irc.Channel else context[key], value) for key, value in translations], hidden=irc.ChanList(hidden, context=context)) self.conf[context] = conf self._whoexpected[context] = [] if self.debug: context.logwrite( "dbg [Bouncer.onAddonAdd] Clearing WHO expected list." % vars()) self._whoisexpected[context] = [] self._listexpected[context] = [] return conf def onAddonRem(self, context): for client in self.clients: if client.context == context: client.quit(quitmsg="Bouncer extension removed") del self.conf[context] del self._whoexpected[context], self._whoisexpected[ context], self._listexpected[context] def stop(self, disconnectall=False): self._stopexpected = True self.socket.shutdown(0) if disconnectall: self.disconnectall() def disconnectall(self, quitmsg="Disconnecting all sessions"): for client in self.clients: client.quit(quitmsg=quitmsg) def onDisconnect(self, context, expected=False): self._whoexpected[context] = [] self._whoisexpected[context] = [] self._listexpected[context] = [] if context.identity: for channel in context.identity.channels: self.broadcast(context, origin=context.identity, cmd="PART", target=channel, extinfo="Bouncer Connection Lost", clients=[ client for client in self.clients if channel not in client.hidden]) self.broadcast(context, origin=context.identity, cmd="QUIT", extinfo="Bouncer Connection Lost") self.broadcast( context, origin=self.servname, cmd="NOTICE", target=context.identity, extinfo=":Connection to %s:%s has been lost." % (context.server, context.port)) def onQuit(self, context, user, quitmsg): # For some odd reason, certain networks (*cough*Freenode*cough*) will send a quit message for the user, causing context.identity.channels to be cleared # before onDisconnect can be executed. This is the remedy. if user == context.identity: for channel in context.identity.channels: self.broadcast(context, origin=user, cmd="PART", target=channel, extinfo="Bouncer Connection Lost", clients=[ client for client in self.clients if channel not in client.hidden]) self.broadcast(context, origin=user, cmd="QUIT", extinfo=quitmsg, clients=[ client for client in self.clients if any([user in channel for channel in context.channels if channel not in client.hidden])]) def onConnectAttempt(self, context): self.broadcast( context, origin=self.servname, cmd="NOTICE", target=context.identity, extinfo="Attempting connection to %s:%s." % (context.server, context.port)) def onConnect(self, context): self.broadcast( context, origin=self.servname, cmd="NOTICE", target=context.identity, extinfo="Connection to %s:%s established." % (context.server, context.port)) def onMeNickChange(self, context, newnick): for client in self.clients: if client.context == context: client.send( origin=context.identity, cmd="NICK", target=newnick) client.nick = newnick def onNickChange(self, context, user, newnick): self.broadcast(context, origin=user, cmd="NICK", target=newnick, clients=[ client for client in self.clients if any([user in channel for channel in context.channels if channel not in client.hidden])]) def onRegistered(self, context): for client in self.clients: if client.context == context: if client.nick != context.identity.nick: client.send(origin="%s!%s@%s" % (client.nick, client.username, client.host), cmd="NICK", target=context.identity.nick) client.nick = context.identity.nick def onConnectFail(self, context, exc, excmsg, tb): for client in self.clients: if client.context == context: client.send( origin=self.servname, cmd="NOTICE", target=client.nick, extinfo="Connection to %s:%s failed: %s." % (context.server, context.port, excmsg)) def onSendChanMsg(self, context, origin, channel, targetprefix, msg): # Called when bot sends a PRIVMSG to channel. # The variable origin refers to a class instance voluntarily # identifying itself as that which requested data be sent. self.broadcast( context, origin=context.identity, cmd="PRIVMSG", targetprefix=targetprefix, target=channel, extinfo=msg, clients=[client for client in self.clients if client != origin]) def onSendChanAction(self, context, origin, channel, targetprefix, action): self.onSendChanMsg( context, origin, channel, targetprefix, u"\x01ACTION {action}\x01".format(**vars())) def onSendChanNotice(self, context, origin, channel, targetprefix, msg): # Called when bot sends a NOTICE to channel. # The variable origin refers to a class instance voluntarily # identifying itself as that which requested data be sent. self.broadcast( context, origin=context.identity, cmd="NOTICE", targetprefix=targetprefix, target=channel, extinfo=msg, clients=[client for client in self.clients if client != origin]) def onSend(self, context, origin, line, cmd, target, targetprefix, params, extinfo): if cmd.upper() == "WHO": self._whoexpected[context].append(origin) if self.debug: if issubclass(type(origin), Thread): name = origin.name context.logwrite( "dbg [Bouncer.onSend] Adding {origin} ({name}) to WHO expected list.".format(**vars())) else: context.logwrite( "dbg [Bouncer.onSend] Adding %(origin)s to WHO expected list." % vars()) context.logwrite( "dbg [Bouncer.onSend] WHO expected list size: %d" % len(self._whoexpected[context])) elif cmd.upper() == "WHOIS": self._whoisexpected[context].append(origin) elif cmd.upper() == "LIST": self._listexpected[context].append(origin) def onWhoEntry(self, context, origin, channel, user, channame, username, host, serv, nick, flags, hops, realname): # Called when a WHO list is received. if len(self._whoexpected[context]): client = self._whoexpected[context][0] if client in self.clients: client.send(origin=origin, cmd=352, target=context.identity, params=u"{channame} {username} {host} {serv} {nick} {flags}".format( **vars()), extinfo=u"{hops} {realname}".format(**vars())) # client.send(":%s 352 %s %s %s %s %s %s %s :%s %s\n"%(origin, context.identity.nick, channame, username, host, serv, nick, flags, hops, realname)) def onWhoEnd(self, context, origin, param, endmsg): # Called when a WHO list is received. if len(self._whoexpected[context]) and self._whoexpected[context][0] in self.clients: client = self._whoexpected[context][0] client.send( origin=origin, cmd=315, target=context.identity, params=param, extinfo=endmsg) #client.send(":%s 315 %s %s :%s\n"%(origin, context.identity.nick, param, endmsg)) if self.debug: if issubclass(type(self._whoexpected[context][0]), Thread): name = self._whoexpected[context][0].name context.logwrite( "dbg [Bouncer.onWhoEnd] Removing %s (%s) from WHO expected list." % (self._whoexpected[context][0], name)) else: context.logwrite( "dbg [Bouncer.onWhoEnd] Removing %s from WHO expected list." % self._whoexpected[context][0]) del self._whoexpected[context][0] if self.debug: context.logwrite( "dbg [Bouncer.onWhoEnd] WHO expected list size: %d" % len(self._whoexpected[context])) def onListStart(self, context, origin, params, extinfo): # Called when a WHO list is received. if len(self._listexpected[context]) and self._listexpected[context][0] in self.clients: client = self._listexpected[context][0] client.send(origin=origin, cmd=321, target=context.identity, params=params, extinfo=extinfo) #client.send(":%s 321 %s %s :%s\n"%(origin, context.identity.nick, params, extinfo)) def onListEntry(self, context, origin, channel, population, extinfo): # Called when a WHO list is received. if len(self._listexpected[context]) and self._listexpected[context][0] in self.clients: client = self._listexpected[context][0] client.send(origin=origin, cmd=322, target=context.identity, params=u"{channel.name} {population}".format(**vars()), extinfo=extinfo) # client.send(":%s 322 %s %s %d :%s\n"%(origin, context.identity.nick, channame, population, extinfo)) def onListEnd(self, context, origin, endmsg): # Called when a WHO list is received. if len(self._listexpected[context]) and self._listexpected[context][0] in self.clients: client = self._listexpected[context][0] client.send( origin=origin, cmd=323, target=context.identity, extinfo=endmsg) # client.send(":%s 323 %s :%s\n"%(origin, context.identity.nick, endmsg)) del self._listexpected[context][0] def onWhoisStart(self, context, origin, user, nickname, username, host, realname): # Called when a WHOIS reply is received. if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=311, target=context.identity, params=u"{nickname} {username} {host} *".format(**vars()), extinfo=realname) # client.send(":%s 311 %s %s %s %s * :%s\n" % (origin, context.identity.nick, nickname, username, host, realname)) def onWhoisRegisteredNick(self, context, origin, user, nickname, msg): # Called when a WHOIS reply is received. if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send( origin=origin, cmd=307, target=context.identity, params=nickname, extinfo=msg) # client.send(":%s 307 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisConnectingFrom(self, context, origin, user, nickname, msg): # Called when a WHOIS reply is received. if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=378, target=context.identity, params=nickname, extinfo=msg) # client.send(":%s 378 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisChannels(self, context, origin, user, nickname, chanlist): # Called when a WHOIS reply is received. # TODO: Translations implementation if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=319, target=context.identity, params=nickname, extinfo=" ".join(chanlist)) # client.send(":%s 319 %s %s :%s\n" % (origin, context.identity.nick, nickname, " ".join(chanlist))) def onWhoisAvailability(self, context, origin, user, nickname, msg): # Called when a WHOIS reply is received. if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send( origin=origin, cmd=310, target=context.identity, params=nickname, extinfo=msg) # client.send(":%s 310 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisServer(self, context, origin, user, nickname, server, servername): # Called when a WHOIS reply is received. if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=312, target=context.identity, params=u"{nickname} {server}".format(**vars()), extinfo=servername) # client.send(":%s 312 %s %s %s :%s\n" % (origin, context.identity.nick, nickname, server, servername)) def onWhoisOp(self, context, origin, user, nickname, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send( origin=origin, cmd=313, target=context.identity, params=nickname, extinfo=msg) # client.send(":%s 313 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisAway(self, context, origin, user, nickname, awaymsg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=301, target=context.identity, params=u"{nickname} {idletime} {signontime}".format(**vars()), extinfo=awaymsg) # client.send(":%s 301 %s %s :%s\n" % (origin, context.identity.nick, nickname, awaymsg)) def onWhoisTimes(self, context, origin, user, nickname, idletime, signontime, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=317, target=context.identity, params=u"{nickname} {idletime} {signontime}".format(**vars()), extinfo=msg) # client.send(":%s 317 %s %s %d %d :%s\n" % (origin, context.identity.nick, nickname, idletime, signontime, msg)) def onWhoisSSL(self, context, origin, user, nickname, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=671, target=context.identity, params=nickname, extinfo=msg) # client.send(":%s 671 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisModes(self, context, origin, user, nickname, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send( origin=origin, cmd=339, target=context.identity, params=nickname, extinfo=msg) # ":%s 339 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg)) def onWhoisLoggedInAs(self, context, origin, user, nickname, loggedinas, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=330, target=context.identity, params=" ".join((nickname, loggedinas)), extinfo=msg) # ":%s 330 %s %s %s :%s\n" % (origin, context.identity.nick, nickname, loggedinas, msg)) def onWhoisEnd(self, context, origin, user, nickname, msg): if len(self._whoisexpected[context]) and self._whoisexpected[context][0] in self.clients: client = self._whoisexpected[context][0] client.send(origin=origin, cmd=318, target=context.identity, params=nickname, extinfo=msg) # ":%s 318 %s %s :%s\n" % (origin, context.identity.nick, nickname, msg) del self._whoisexpected[context][0] def onJoin(self, context, user, channel): self.broadcast(context, origin=user, cmd="JOIN", target=channel, clients=[ client for client in self.clients if channel not in client.hidden]) def onOther(self, context, line, origin, cmd, target, params, extinfo, targetprefix): conf = self.conf[context] self.broadcast( context, origin=origin, cmd=cmd, target=target, params=params, extinfo=extinfo, targetprefix=targetprefix, clients=[client for client in self.clients if target not in client.hidden]) def broadcast(self, context, origin=None, cmd=None, target=None, params=None, extinfo=None, targetprefix=None, clients=None): if clients == None: clients = self.clients for client in clients: with client.lock: if client.context == context and not client.quitting: client.send( origin, cmd, target, params, extinfo, targetprefix) class BouncerConnection (Thread): def __init__(self, bouncer, connection, addr, debug=False): # print "Initializing ListenThread..." self.bouncer = bouncer self.connection = connection self.host, self.port = self.addr = addr[:2] self.context = None self.pwd = None self.nick = None self.label = None self.username = None self.realname = None self.addr = addr self.debug = debug self.lock = Lock() self.quitmsg = "Connection Closed" self.quitting = False self.hidden = irc.ChanList() self.translations = {} self.namesx = False self.uhnames = False Thread.__init__(self) self.daemon = True self.start() def sendstr(self, data, flags=0): with self.lock: try: self.connection.send(data.encode("utf8")) except socket.error: exc, excmsg, tb = sys.exc_info() print >>self.context.logwrite(*["!!! [BouncerConnection.send] Exception in thread %(self)s" % vars()] + [ "!!! [BouncerConnection.send] %(tbline)s" % vars() for tbline in traceback.format_exc().split("\n")]) self.quit(quitmsg=excmsg.message) # Format and send a string to the client def send(self, origin=None, cmd=None, target=None, params=None, extinfo=None, targetprefix=None, flags=0): if type(target) == irc.Channel: if targetprefix == None: targetprefix = "" # if target in self.translations.keys(): # target=targetprefix+self.translations[target] # else: # target=targetprefix+target.name target = targetprefix + target.name elif type(target) == irc.User: target = target.nick if type(cmd) == int: cmd = "%03d" % cmd # translated=[] # if params: # for param in params.split(" "): #chantypes=self.context.supports.get("CHANTYPES", irc._defaultchantypes) # if re.match(irc._chanmatch % re.escape(chantypes), param) and self.context[param] in self.translations.keys(): # translated.append(self.translations[self.context[param]]) # else: # translated.append(param) #params=" ".join(translated) if params: line = u"{cmd} {target} {params}".format(**vars()) elif target: line = u"{cmd} {target}".format(**vars()) else: line = cmd if extinfo != None: line = u"{line} :{extinfo}".format(**vars()) if type(origin) == irc.User: line = u":{origin:full} {line}".format(**vars()) elif origin: line = u":{origin} {line}".format(**vars()) self.sendstr(u"{line}\n".format(**vars())) #server=self.context.server if self.context else "*" #port=self.context.port if self.context else "*" # if self.context and self.context.identity: # nick=self.context.identity.nick #ident=self.context.identity.username if self.context.identity.username else "*" #host=self.context.identity.host if self.context.identity.host else "*" # else: # nick="*" # ident="*" # host="*" # if self.context.ssl and self.context.ipv6: # protocol="ircs6" # elif self.context.ssl: # protocol="ircs" # elif self.context.ipv6: # protocol="irc6" # else: # protocol="irc" # addr=self.host def __repr__(self): return "".format(**vars()) def quit(self, quitmsg="Disconnected"): with self.lock: if not self.quitting: self.quitmsg = quitmsg try: self.send(cmd="ERROR", extinfo="Closing link: (%s@%s) [%s]\n" % ( self.context.identity.nick if self.context else "*", self.host, quitmsg)) except: pass try: self.connection.shutdown(socket.SHUT_WR) self.connection.close() except: pass self.quitting = True def showchannel(self, channel): with self.context.lock, self.lock: if channel in self.hidden: self.hidden.remove(channel) if self.context.identity in channel.users: self.send( origin=self.context.identity, cmd="JOIN", target=channel) self.sendchanneltopic(channel) self.sendchannelnames(channel) def sendchanneltopic(self, channel): with self.context.lock, self.lock: if channel.topic and channel.topictime: self.send(origin=self.bouncer.servname, cmd=332, target=self.context.identity, params=channel.name, extinfo=channel.topic) # u":{self.context.serv} 332 {self.context.identity.nick} {self.name} :{self.topic}".format(**vars()) self.send( origin=self.bouncer.servname, cmd=333, target=self.context.identity, params="{channel.name} {channel.topicsetby} {channel.topictime}".format(**vars())) # u":{self.context.serv} 333 {self.context.identity.nick} {self.name} {self.topicsetby.nick} {self.topictime}".format(**vars()) else: self.send(origin=self.bouncer.servname, cmd=331, target=self.context.identity, params=channel.name, extinfo="No topic is set") # u":{self.context.serv} 331 {self.context.identity.nick} # {self.name} :No topic is set".format(**vars())] def sendchannelnames(self, channel): with self.context.lock, self.lock: secret = "s" in channel.modes.keys() and channel.modes["s"] private = "p" in channel.modes.keys() and channel.modes["p"] flag = "@" if secret else ("*" if private else "=") modes, symbols = supports = self.context.supports.get( "PREFIX", irc._defaultprefix) users = list(channel.users) users.sort(key=lambda user: ([user not in channel.modes.get(mode, []) for mode, char in zip(*supports)], user.nick.lower())) if self.uhnames: template = u"{prefixes}{user:full}" else: template = u"{prefixes}{user}" nameslist = [] for user in users: prefixes = u"".join( [prefix if mode in channel.modes.keys() and user in channel.modes[mode] else "" for prefix, mode in zip(symbols, modes)]) if not self.namesx: prefixes = prefixes[:1] nameslist.append(template.format(**vars())) names = " ".join(nameslist) lines = [] while len(names) > 196: index = names.rfind(" ", 0, 196) slice = names[:index] self.send( origin=self.bouncer.servname, cmd=353, target=self.context.identity, params="{flag} {channel.name}".format(**vars()), extinfo=slice) #u":{channel.context.serv} 353 {channel.context.identity.nick} {flag} {channel.name} :{slice}".format(**vars()) names = names[index + 1:] if len(names): self.send( origin=self.bouncer.servname, cmd=353, target=self.context.identity, params="{flag} {channel.name}".format(**vars()), extinfo=names) #u":{channel.context.serv} 353 {channel.context.identity.nick} {flag} {channel.name} :{names}".format(**vars()) self.send( origin=self.bouncer.servname, cmd=366, target=self.context.identity, params=channel.name, extinfo="End of /NAMES list.") # u":{channel.context.serv} 366 {channel.context.identity.nick} {channel.name} :End of /NAMES list.".format(**vars()) def sendchannelmodes(self, channel, modechars=None): with self.context.lock, self.lock: if modechars: for mode in modechars: if mode not in _listnumerics.keys(): continue i, e, l = _listnumerics[mode] if mode in channel.modes.keys(): for (mask, setby, settime) in channel.modes[mode]: self.send( origin=self.bouncer.servname, cmd=i, target=self.context.identity, params=u"{channel.name} {mask} {setby} {settime}".format(**vars())) self.send(origin=self.bouncer.servname, cmd=e, target=self.context.identity, params=u"{channel.name} {l}".format(**vars())) else: items = channel.modes.items() chanmodes = self.context.supports.get( "CHANMODES", irc._defaultchanmodes) prefix = self.context.supports.get( "PREFIX", irc._defaultprefix) modes = "".join( [mode for (mode, val) in items if mode not in chanmodes[0] + prefix[0] and val]) params = " ".join( [val for (mode, val) in items if mode in chanmodes[1] + chanmodes[2] and val]) if modes and params: self.send( origin=self.bouncer.servname, cmd=324, target=self.context.identity, params="{channel.name} +{modes} {params}".format(**vars())) # u":{channel.context.identity.server} 324 {channel.context.identity.nick} {channel.name} +{modes} {params}".format(**vars()) elif modes: self.send( origin=self.bouncer.servname, cmd=324, target=self.context.identity, params="{channel.name} +{modes}".format(**vars())) # u":{channel.context.identity.server} 324 {channel.context.identity.nick} {channel.name} +{modes}".format(**vars()) def sendsupports(self): with self.context.lock, self.lock: supports = [ "CHANMODES=%s" % (",".join(value)) if name == "CHANMODES" else "PREFIX=(%s)%s" % value if name == "PREFIX" else "%s=%s" % (name, value) if value else name for name, value in self.context.supports.items()] if "UHNAMES" not in supports: supports.append("UHNAMES") if "NAMESX" not in supports: supports.append("NAMESX") supports.sort() supports = " ".join(supports) lines = [] while len(supports) > 196: index = supports.rfind(" ", 0, 196) slice = supports[:index] self.send( origin=self.bouncer.servname, cmd=5, target=self.context.identity, params=slice, extinfo="are supported by this server") # u":{self.context.serv} 005 {self.context.identity.nick} {slice} :are supported by this server".format(**vars()) supports = supports[index + 1:] if supports: self.send( origin=self.bouncer.servname, cmd=5, target=self.context.identity, params=supports, extinfo="are supported by this server") # u":{self.context.serv} 005 {self.context.identity.nick} {supports} :are supported by this server".format(**vars()) def sendgreeting(self): with self.context.lock, self.lock: if self.context.welcome: self.send(origin=self.bouncer.servname, cmd=1, target=self.context.identity, extinfo=self.context.welcome) # u":{self.context.serv} 001 {self.context.identity.nick} :{self.context.welcome}".format(**vars()) if self.context.hostinfo: self.send(origin=self.bouncer.servname, cmd=2, target=self.context.identity, extinfo=self.context.hostinfo) # u":{self.context.serv} 002 {self.context.identity.nick} :{self.context.hostinfo}".format(**vars()) if self.context.servcreated: self.send(origin=self.bouncer.servname, cmd=3, target=self.context.identity, extinfo=self.context.servcreated) # u":{self.context.serv} 003 {self.context.identity.nick} :{self.context.servcreated}".format(**vars()) if self.context.servinfo: self.send(origin=self.bouncer.servname, cmd=4, target=self.context.identity, params=self.context.servinfo) # u":{self.context.serv} 004 {self.context.identity.nick} {self.context.servinfo}".format(**vars()) def sendmotd(self): with self.context.lock, self.lock: if self.context.motdgreet and self.context.motd and self.context.motdend: self.send(origin=self.bouncer.servname, cmd=375, target=self.context.identity, extinfo=self.context.motdgreet) # u":{server} 375 {self.identity.nick} :{self.motdgreet}".format(**vars()) for motdline in self.context.motd: self.send(origin=self.bouncer.servname, cmd=372, target=self.context.identity, extinfo=motdline) # u":{server} 372 {self.identity.nick} :{motdline}".format(**vars()) self.send(origin=self.bouncer.servname, cmd=376, target=self.context.identity, extinfo=self.context.motdend) # u":{server} 376 {self.identity.nick} :{self.motdend}".format(**vars()) else: self.send(origin=self.bouncer.servname, cmd=422, target=self.context.identity, extinfo="MOTD File is missing") # u":{server} 422 {self.identity.nick} :MOTD File is missing".format(**vars()) def sendusermodes(self): with self.context.lock, self.lock: self.send( origin=self.bouncer.servname, cmd=221, target=self.context.identity, params="+{self.context.identity.modes}".format(**vars())) if "s" in self.context.identity.modes: self.send( origin=self.bouncer.servname, cmd=8, target=self.context.identity, params="+{self.context.identity.snomask}".format(**vars()), extinfo="Server notice mask") def run(self): # Name loopup should happen here instead ipv4match = re.findall( r"^::ffff:((\d+)\.(\d+)\.(\d+)\.(\d+))$", self.host) if self.bouncer.ipv6 and ipv4match: addr, a, b, c, d = ipv4match[0] if max(int(a), int(b), int(c), int(d)) < 256: self.host = addr self.ipv6 = False elif self.bouncer.ipv6: self.ipv6 = True try: self.host, aliaslist, addresslist = socket.gethostbyaddr(self.host) self.addr = (self.host, addr[1]) except: pass # Add connection to connection list. passwd = None nick = None user = None addr = self.host readbuf = "" linebuf = [] try: while True: # Read data (appending) into readbuf, then break lines and # append lines to linebuf while len(linebuf) == 0: timestamp = irc.timestamp() try: read = self.connection.recv(512) except socket.error, msg: self.quit(msg) sys.exit() except ssl.SSLError, msg: self.quit(msg) sys.exit() if read == "" and len(linebuf) == 0: # No more data to process. #self.quitmsg="Connection Closed" sys.exit() readbuf += read lastlf = readbuf.rfind("\n") if lastlf >= 0: linebuf.extend(string.split(readbuf[0:lastlf], "\n")) readbuf = readbuf[lastlf + 1:] line = string.rstrip(linebuf.pop(0)) try: line = line.decode("utf8") except UnicodeDecodeError: # Attempt to figure encoding charset = chardet.detect(line)['encoding'] line = line.decode(charset) match = re.findall( "^(.+?)(?:\\s+(.+?)(?:\\s+(.+?))??)??(?:\\s+:(.*))?$", line, re.I) # print match if len(match) == 0: continue (cmd, target, params, extinfo) = match[0] if not passwd: # Bouncer expects a password if cmd.upper() == "PASS": passwd = target if target else extinfo else: self.quit("Access Denied") print "*** [BouncerConnection] Incoming connection from %s failed: Expected PASS." % (self.host) break elif not self.nick: # Bouncer expects a NICK command if cmd.upper() == "NICK": self.nick = target if target else extinfo else: self.quit("Access Denied") print "*** [BouncerConnection] Incoming connection from %s failed: Expected NICK." % (self.host) break elif not self.username: # Bouncer expects a USER command to finish registration if cmd.upper() == "USER": self.username = target contextfound = False for self.context, conf in self.bouncer.conf.items(): # print conf.label, self.username if conf.label == self.username: contextfound = True break if not contextfound: self.quit("Access Denied") print >>sys.stderr, "*** [BouncerConnection] Incoming connection from %s denied: Context not found." % ( self.host) break passmatch = hashlib.new( conf.hashtype, passwd).hexdigest() == conf.passwd with self.context.lock: if not passmatch: self.quit("Access Denied") self.context.logwrite( "*** [BouncerConnection] Incoming connection from %s to %s denied: Invalid password." % (self.host, self.context)) self.bouncer.broadcast( self.context, origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="Incoming connection from %s to %s denied: Invalid password." % (self.host, self.context)) # for client in self.bouncer.clients: # if client.context!=self.context: # continue # if not client.quitting: #client.send(origin=self.bouncer.servname, cmd="NOTICE", target=client.context.identity, extinfo="Incoming connection from %s to %s dened: Invalid password.\n" % (self.host, self.context)) break self.context.logwrite( "*** [BouncerConnection] Incoming connection from %s to %s established." % (self.host, self.context)) with self.bouncer.lock: self.translations = dict( self.bouncer.conf[self.context].translations) # Announce connection to all other bouncer # clients. self.bouncer.broadcast( self.context, origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="Incoming connection from %s to %s established." % (self.host, self.context)) # for client in self.bouncer.clients: # if client.context!=self.context: # continue # if not client.quitting: #client.send(":*Bouncer* NOTICE %s :Incoming connection from %s to %s\n" % (client.context.identity.nick, self.host, self.context)) if len([client for client in self.bouncer.clients if client.context == self.context]) == 0 and self.context.registered and type(self.context.identity) == irc.User and self.context.identity.away: # Bouncer connection should # automatically return from away # status. self.context.raw("AWAY") self.hidden = irc.ChanList( self.bouncer.conf[self.context].hidden, context=self.context) self.bouncer.clients.append(self) if self.context.registered: # Send Greeting. with self.lock: self.sendgreeting() self.sendsupports() self.sendmotd() self.sendusermodes() # Join user to channels. for channel in self.context.identity.channels: if channel not in self.hidden: self.showchannel(channel) else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.nick, extinfo="Not connected to server. Type /bncconnect to attempt connection.") #self.send(u":%s 001 %s :Welcome to the Bouncer context Network %s!%s@%s\n" % ("*Bouncer*", self.nick, self.nick, self.username, self.host)) else: # Client did not send USER command when expected self.quit("Access Denied") print "*** [BouncerConnection] Incoming connection from %s failed: Expected USER." % (self.host) break else: chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) # Disable translating for now. if False and cmd.upper() not in ("SETTRANSLATE", "RMTRANSLATE"): translated = [] for targ in target.split(","): translatefound = False if re.match(irc._chanmatch % re.escape(chantypes), targ): for channel, translate in self.translations.items(): if targ.lower() == translate.lower(): translated.append(channel.name) translatefound = True break if not translatefound: translated.append(targ) target = ",".join(translated) translated = [] for param in params.split(" "): translatefound = False if re.match(irc._chanmatch % re.escape(chantypes), param): for channel, translate in self.translations.items(): if param.lower() == translate.lower(): translated.append(channel.name) translatefound = True break if not translatefound: translated.append(param) params = " ".join(translated) if params: line = u"{cmd} {target} {params}".format(**vars()) elif target: line = u"{cmd} {target}".format(**vars()) else: line = cmd if extinfo: line = u"{line} :{extinfo}".format(**vars()) cmdmethod = "cmd%s" % cmd.upper() if hasattr(self, cmdmethod): method = getattr(self, cmdmethod) try: method(line, target, params, extinfo) except SystemExit: sys.exit() except: if self.context: exc, excmsg, tb = sys.exc_info() self.context.logwrite(*[u"!!! [BouncerConnection] Exception in thread %(self)s" % vars()] + [ u"!!! [BouncerConnection] %(tbline)s" % vars() for tbline in traceback.format_exc().split("\n")]) print >>sys.stderr, "Exception in thread %(self)s" % vars( ) print >>sys.stderr, traceback.format_exc() elif not self.context.connected: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.nick, extinfo="Not connected to server. Type /bncconnect to attempt connection.") continue elif not self.context.registered: self.send(origin=self.bouncer.servname, cmd="NOTICE", target=self.nick, extinfo="Not registered.") continue else: self.context.raw(line, origin=self) except SystemExit: pass # No need to pass error message if break resulted from sys.exit() except: exc, excmsg, tb = sys.exc_info() self.quitmsg = str(excmsg) if self.context: exc, excmsg, tb = sys.exc_info() self.context.logwrite(*["!!! [BouncerConnection] Exception in thread %(self)s" % vars()] + [ "!!! [BouncerConnection] %(tbline)s" % vars() for tbline in traceback.format_exc().split("\n")]) print >>sys.stderr, "Exception in thread %(self)s" % vars() print >>sys.stderr, traceback.format_exc() finally: # Juuuuuuust in case. with self.lock: try: self.connection.shutdown(1) self.connection.close() except: pass if self.context: self.context.logwrite( "*** [BouncerConnection] Connection from %s terminated (%s)." % (self.host, self.quitmsg)) with self.bouncer.lock: if self in self.bouncer.clients: self.bouncer.clients.remove(self) if self.context.connected and self.context.identity and len([client for client in self.bouncer.clients if client.context == self.context]) == 0 and self.context.registered and type(self.context.identity) == irc.User and not self.context.identity.away and self.bouncer.autoaway: # Bouncer automatically sets away status. self.context.raw("AWAY :%s" % self.bouncer.autoaway) self.bouncer.broadcast( self.context, origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="Connection from %s to %s terminated (%s)\n" % (self.host, self.context, self.quitmsg)) # ":*Bouncer* NOTICE %s :Connection from %s to %s terminated (%s)\n" % (client.context.identity.nick, self.host, self.context, self.quitmsg)) def cmdQUIT(self, line, target, params, extinfo): self.quit(extinfo) sys.exit() def cmdPROTOCTL(self, line, target, params, extinfo): protoparams = [target.upper()] + params.upper().split() if "NAMESX" in protoparams: self.namesx = True if "UHNAMES" in protoparams: self.uhnames = True def cmdPING(self, line, target, params, extinfo): with self.context.lock: if True or (self.context.identity and type(self.context.identity) == irc.User): self.send(origin=self.bouncer.servname, cmd="PONG", target=params, extinfo=target) # u":{self.context.identity.server} PONG {params} # :{target}\n".format(**vars()).encode("utf8")) else: self.send(origin=self.bouncer.servname, cmd="PONG", params=params, extinfo=target) self.send( u":{self.context.server} PONG {params} :{target}\n".format(**vars()).encode("utf8")) def cmdPRIVMSG(self, line, target, params, extinfo): # Check if CTCP ctcp = re.findall("^\x01(.*?)(?:\\s+(.*?)\\s*)?\x01$", extinfo) if ctcp: (ctcptype, ext) = ctcp[0] # Unpack CTCP info if ctcptype == "LAGCHECK": # Client is doing a lag check. No need to send to context network, just reply back. self.send( u":{self.context.identity:full} {line}\n".format(**vars()).encode("utf8")) else: self.context.raw(line, origin=self) else: self.context.raw(line, origin=self) def cmdMODE(self, line, target, params, extinfo): # Will want to determine is requesting modes, or attempting to modify modes. # if target and "CHANTYPES" in self.context.supports.keys() and # target[0] in self.context.supports["CHANTYPES"]: chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) chanmodes = self.context.supports.get( "CHANMODES", irc._defaultchanmodes) prefix = self.context.supports.get("PREFIX", irc._defaultprefix) if re.match(irc._chanmatch % re.escape(chantypes), target): channel = self.context[target] if params == "": # We are requesting the modes for the channel if self.context.identity in channel.users: # We are in the channel, and we know the channel modes self.sendchannelmodes(channel) else: # We are NOT in the channel, so we will forward the request # to the server. self.context.raw( u"MODE {channel.name}".format(**vars()), origin=self) elif re.match("^\\+?[%s]+$" % chanmodes[0], params) and extinfo == "": # We are requesting one or more mode lists. modechars = "" for mode in params.lstrip("+"): if mode not in modechars: modechars += mode if self.context.identity in channel.users: self.sendchannelmodes(channel, modechars) else: self.context.raw( u"MODE {channel.name} {params}".format(**vars()), origin=self) else: self.context.raw(line, origin=self) elif params == "" and target.lower() == self.context.identity.nick.lower(): self.sendusermodes() else: self.context.raw( u"MODE {target} {params}".format(**vars()), origin=self) def cmdNAMES(self, line, target, params, extinfo): chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) chanmodes = self.context.supports.get( "CHANMODES", irc._defaultchanmodes) prefix = self.context.supports.get("PREFIX", irc._defaultprefix) fallback = [] with self.lock: for channame in target.split(): if re.match(irc._chanmatch % re.escape(chantypes), channame): channel = self.context[channame] with self.lock: if self.context.identity in channel: self.sendchannelnames(channel) else: fallback.append(channame) else: fallback.append(channame) if fallback: self.context.raw("NAMES %s" % (",".join(fallback)), origin=self) def cmdSHOW(self, line, target, params, extinfo): chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) with self.context.lock, self.lock: for channame in target.split(): if re.match(irc._chanmatch % re.escape(chantypes), channame): channel = self.context[channame] if channel in self.hidden: if self.context.identity in channel: self.showchannel(channel) else: self.hidden.remove(channel) self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channel.name} removed from hidden list, but not joined.".format(**vars())) else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channel.name} not in hidden list.".format(**vars())) else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channame}: invalid channel name.".format(**vars())) def cmdHIDE(self, line, target, params, extinfo): chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) with self.context.lock, self.lock: for channame in target.split(): if re.match(irc._chanmatch % re.escape(chantypes), channame): channel = self.context[channame] if channel not in self.hidden: if self.context.identity in channel: self.send( origin=self.context.identity, cmd="PART", target=channel, extinfo="Hiding channel") else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channel.name} added to the hidden list, but not joined.".format(**vars())) self.hidden.append(channel) else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channel.name} already in hidden list.".format(**vars())) else: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="{channame}: invalid channel name.".format(**vars())) def cmdSETTRANSLATE(self, line, target, params, extinfo): chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) with self.context.lock, self.lock: if re.match(irc._chanmatch % re.escape(chantypes), target) and re.match(irc._chanmatch % re.escape(chantypes), target): channel = self.context[target] if self.context.supports.get("CASEMAPPING", "rfc1459") == "ascii": translations_lower = [translation.translate(irc._rfc1459casemapping) for translation in self.translations.values()] params_lower = params.translate(irc._rfc1459casemapping) else: translations_lower = [translation.lower() for translation in self.translations.values()] params_lower = params.lower() if params_lower in translations_lower: self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="Cannot set translation for {channel.name} to {param}.".format(**vars())) else: self.send(origin=self.context.identity, cmd="PART", target=channel, extinfo="Translating...") self.translations[channel] = params self.showchannel(channel) def cmdRMTRANSLATE(self, line, target, params, extinfo): chantypes = self.context.supports.get( "CHANTYPES", irc._defaultchantypes) with self.context.lock, self.lock: if re.match(irc._chanmatch % re.escape(chantypes), target): channel = self.context[target] if channel not in self.translations.keys(): self.send( origin=self.bouncer.servname, cmd="NOTICE", target=self.context.identity, extinfo="Cannot remove translation for {channel.name}.".format(**vars())) else: self.send(origin=self.context.identity, cmd="PART", target=channel, extinfo="Translating...") del self.translations[channel] self.showchannel(channel)