import asynchat import asyncore import socket import string import types import sys import traceback import time class IRCHandler(asynchat.async_chat): """IRC Server connection. This is the one you want to derive your connection classes from. """ debug = False heartbeat_interval = 1 # seconds per heartbeat def __init__(self, host=None, nick=None, gecos=None): asynchat.async_chat.__init__(self) self.line = '' self.timers = [] self.last_heartbeat = 0 self.set_terminator('\r\n') if host: self.open_connection(host, nick, gecos) def dbg(self, msg): if self.debug: print msg def open_connection(self, host, nick, gecos): self.nick = nick self.gecos = gecos self.host = host self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.connect(host) def handle_connect(self): self.write(['NICK', self.nick]) self.write(['USER', self.nick, '+iw', self.nick], self.gecos) def connect(self, host): self.waiting = False asynchat.async_chat.connect(self, host) def heartbeat(self): """Invoke all timers.""" if not self.timers: return timers, self.timers = self.timers, [] now = time.time() for t, cb in timers: if t > now: self.timers.append((t, cb)) else: cb() def add_timer(self, secs, callback): """After secs seconds, call callback""" self.timers.append((time.time() + secs, callback)) def readable(self): """Called by asynchat to see if we're readable. We hook our heartbeat in here. """ now = time.time() if now > self.last_heartbeat + self.heartbeat_interval: self.heartbeat() self.last_heartbeat = now if self.connected: return asynchat.async_chat.readable(self) else: return False def collect_incoming_data(self, data): """Called by asynchat when data arrives""" self.line += data def found_terminator(self): """Called by asynchat when it finds the terminating character. """ line = self.line self.line = '' self.parse_line(line) def write(self, args, *text): """Send out an IRC command This function helps to prevent you from shooting yourself in the foot, by forcing you to send commands that are in a valid format (although it doesn't check the validity of the actual commands). As we all know, IRC commands take the form :COMMAND ARG1 ARG2 ARG3 ... :text string where 'text string' is optional. Well, that's exactly how this function works. Args is a list of length at least one, and text string can be any number of strings. You can call the function like this: write(['PRIVMSG', nick], 'Hello 12') or like this: write(['PRIVMSG', nick], 'Hello', '12') or even like this: write(['PRIVMSG', nick], 'Hello', 12) And you'll get the same result with all three. """ if (type(args) == types.StringType): cmd = args else: cmd = u' '.join(args) cmdstr = cmd if (text): txt = '' for t in (text): if type(t) in (types.StringType, types.UnicodeType): txt = txt + ' ' + t elif type(t) in (types.ListType, types.TupleType): for i in (t): try: txt = ' '.join([txt, i]) except TypeError: txt = ' '.join([txt, repr(i)]) else: txt = ' '.join([txt, repr(t)]) txt = txt[1:] cmdstr = "%s :%s" % (cmdstr, txt) encstr = cmdstr.encode('utf8', 'replace') self.dbg("-> %s " % encstr) try: self.send(encstr + '\n') except socket.error: pass def parse_line(self, line): """Parse a server-provided line This does all the magic of parsing those ill-formatted IRC messages. It will also decide if a PRIVMSG or NOTICE is using CTCP (the client-to-client protocol, which by convention is any of the above messages with ^A on both ends of the text. This function goes on to invoke self.eval_triggers on the parsed data like this: self.eval_triggers(operation, arguments, text) where operation and text are strings, and arguments is a list. It returns the same tuple (op, args, text). """ line = line.decode('utf8', 'replace') if (line[0] == ':'): with_uname = 1 line = line [1:] else: with_uname = 0 try: [args, text] = line.split(' :', 1) args = args.split() except ValueError: args = line.split() text = '' if (with_uname != 1): op = args[0] elif ((args[1] in ["PRIVMSG", "NOTICE"]) and (text and (text[0] == '\001') and (text[-1] == '\001'))): op = "C" + args[1] text = text[1:-1] else: op = args[1] self.dbg("<- %s %s %s" % (op, args, text)) self.handle(op, args, text) return (op, args, text) def handle(self, op, args, text): """Take action on a server message Right now, just invokes self.do_[op](args, text) where [op] is the operation passed in. This is a good method to overload if you want a really advanced client supporting bindings. """ try: method = getattr(self, "do_" + lower(op)) except AttributeError: self.dbg("Unhandled: %s" % (op, args, text)) return method(args, text) class Recipient: """Abstract recipient object""" def __init__(self, interface, name): self._interface = interface self._name = name def __repr__(self): return 'Recipient(%s)' % self.name() def name(self): return self._name def is_channel(self): return False def write(self, cmd, addl): """Write a raw IRC command to our interface""" self._interface.write(cmd, addl) def cmd(self, cmd, text): """Send a command to ourself""" self.write([cmd, self._name], text) def msg(self, text): """Tell the recipient something""" self.cmd("PRIVMSG", text) def notice(self, text): """Send a notice to the recipient""" self.cmd("NOTICE", text) def ctcp(self, command, text): """Send a CTCP command to the recipient""" return self.msg("\001%s %s\001" % (upper(command), text)) def act(self, text): """Send an action to the recipient""" return self.ctcp("ACTION", text) def cnotice(self, command, text): """Send a CTCP notice to the recipient""" return self.notice("\001%s %s\001" % (upper(command), text)) class Channel(Recipient): def __repr__(self): return 'Channel(%s)' % self.name() def is_channel(self): return True class User(Recipient): def __init__(self, interface, name, user, host, op=False): Recipient.__init__(self, interface, name) self.user = user self.host = host self.op = op def __repr__(self): return 'User(%s, %s, %s)' % (self.name(), self.user, self.host) def recipient(interface, name): if name[0] in ["&", "#"]: return Channel(interface, name) else: return User(interface, name, None, None) class SmartIRCHandler(IRCHandler): """This is like the IRCHandler, except it creates Recipient objects for IRC messages. The intent is to make it easier to write stuff without knowledge of the IRC protocol. """ def recipient(self, name): return recipient(self, name) def err(self, exception): if self.debug: traceback.print_exception(*exception) def handle(self, op, args, text): """Parse more, creating objects and stuff makes a call to self.handle_op(sender, forum, addl) sender is always a Recipient object; if you want to reply privately, you can send your reply to sender. forum is a Recipient object corresponding with the forum over which the message was carried. For user-to-user PRIVMSG and NOTICE commands, this is the same as sender. For those same commands sent to a channel, it is the channel. Thus, you can always send a reply to forum, and it will be sent back in an appropriate manner (ie. the way you expect). addl is a tuple, containing additional information which might be relelvant. Here's what it will contain, based on the server operation: op | addl ---------+---------------- PRIVMSG | text of the message NOTICE | text of the notice CPRIVMSG | CTCP command, text of the command CNOTICE | CTCP response, text of the response KICK * | victim of kick, kick text MODE * | all mode args JOIN * | empty PART * | empty QUIT | quit message PING | ping text NICK ! | old nickname others | all arguments; text is last element * The forum in these items is the channel to which the action pertains. ! The sender for the NICK command is the *new* nickname. This is so you can send messages to the sender object and they'll go to the right place. """ try: sender = User(self, *unpack_nuhost(args)) except ValueError: sender = None forum = None addl = () if op in ("PRIVMSG", "NOTICE"): # PRIVMSG ['neale!~user@127.0.0.1', 'PRIVMSG', '#hydra'] firebot, foo # PRIVMSG ['neale!~user@127.0.0.1', 'PRIVMSG', 'firebot'] firebot, foo try: if args[2][0] in '#&': forum = self.recipient(args[2]) else: forum = sender addl = (text,) except IndexError: addl = (text, args[1]) elif op in ("CPRIVMSG", "CNOTICE"): forum = self.recipient(args[2]) splits = text.split(" ") if splits[0] == "DCC": op = "DC" + op addl = (splits[1],) + tuple(splits[2:]) else: addl = (splits[0],) + tuple(splits[1:]) elif op in ("KICK",): forum = self.recipient(args[2]) addl = (self.recipient(args[3]), text) elif op in ("MODE",): forum = self.recipient(args[2]) addl = args[3:] elif op in ("JOIN", "PART"): try: forum = self.recipient(args[2]) except IndexError: forum = self.recipient(text) elif op in ("QUIT",): addl = (text,) elif op in ("PING", "PONG"): # PING ['PING'] us.boogernet.org. # PONG ['irc.foonet.com', 'PONG', 'irc.foonet.com'] 1114199424 addl = (text,) elif op in ("NICK",): # NICK ['brad!~brad@10.168.2.33', 'NICK'] bradaway # # The sender is the new nickname here, in case you want to # send something to the sender. # Apparently there are two different standards for this # command. if text: sender = self.recipient(text) else: sender = self.recipient(args[2]) addl = (unpack_nuhost(args)[0],) elif op in ("INVITE",): forum = self.recipient(text) else: try: int(op) except ValueError: self.dbg("WARNING: unknown server code: %s" % op) addl = tuple(args[3:]) + (text,) try: self.handle_cooked(op, sender, forum, addl) except SystemExit: raise except: self.err(sys.exc_info()) def handle_cooked(self, op, sender, forum, addl): try: func = getattr(self, 'cmd_' + op.lower()) except AttributeError: self.unhandled(op, sender, forum, addl) return func(sender, forum, addl) def cmd_ping(self, sender, forum, addl): self.write('PONG', addl) def unhandled(self, op, sender, forum, addl): """Handle all the stuff that had no handler. This is a special handler in that it also gets the server code as the first argument. """ self.dbg("unhandled: %s" % ((op, sender, forum, addl),)) class Bot(SmartIRCHandler): """A simple bot. This automatically joins the channels you pass to the constructor, tries to use one of the nicks provided, and reconnects if it gets booted. You can use this as a base for more sophisticated bots. """ def __init__(self, host, nicks, gecos, channels): self.nicks = nicks self.channels = channels self.waiting = True self._spool = [] SmartIRCHandler.__init__(self, host, nicks[0], gecos) def despool(self, target, lines): """Slowly despool a bunch of lines to a target Since the IRC server will block all output if we send it too fast, use this to send large multi-line responses. """ self._spool.append((target, list(lines))) def heartbeat(self): SmartIRCHandler.heartbeat(self) # Despool data if self._spool: # Take the first one on the queue, and put it on the end which = self._spool[0] del self._spool[0] self._spool.append(which) # Despool a line target, lines = which line = lines[0] target.msg(line) del lines[0] if not lines: self._spool.remove((target, lines)) def announce(self, text): for c in self.channels: self.write(['PRIVMSG', c], text) def err(self, exception): SmartIRCHandler.err(self, exception) self.announce('*bzert*') def cmd_001(self, sender, forum, addl): for c in self.channels: self.write('JOIN', c) def writable(self): if not self.waiting: return asynchat.async_chat.writable(self) else: return False def write(self, *args): SmartIRCHandler.write(self, *args) def close(self, final=False): SmartIRCHandler.close(self) if not final: self.dbg("Connection closed, reconnecting...") self.waiting = True self.connected = 0 # Wait a bit and reconnect self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.add_timer(23, lambda : self.connect(self.host)) def handle_close(self): self.close() ## ## Miscellaneous IRC functions ## ucletters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ[]\\" lcletters = "abcdefghijklmnopqrstuvwxyz{}|" ultrans = string.maketrans(ucletters, lcletters) lutrans = string.maketrans(lcletters, ucletters) casetrans = string.maketrans(''.join([ucletters, lcletters]), ''.join([lcletters, ucletters])) def upper(s): """Convert a string to upper case. Because IRC was developed in a nordic country, there are three extra letters. In order to do case conversions properly, you need to use the IRC-specific functions. """ return string.translate(s, lutrans) def lower(s): """Convert a string to lower case Because IRC was developed in a nordic country, there are three extra letters. In order to do case conversions properly, you need to use the IRC-specific functions. """ return string.translate(s, ultrans) def swapcase(s): """Invert a string's case Because IRC was developed in a nordic country, there are three extra letters. In order to do case conversions properly, you need to use the IRC-specific functions. """ return string.translate(s, casetrans) def strcmp(s1, s2): """Case-insensitively compare two strings Because IRC was developed in a nordic country, there are three extra letters. In order to do case-insensitive comparisons properly, you need to use this IRC-specific function. """ return (lower(s1) == lower(s2)) def unpack_nuhost(nuhost): """Unpack nick!user@host Frequently, the first argument in a server message is in nick!user@host format. You can just pass your whole argument list to this function and get back a tuple containing: (nick, user, host) """ try: [nick, uhost] = string.split(nuhost[0], '!', 1) [user, host] = string.split(uhost, '@', 1) except ValueError: raise ValueError, "not in nick!user@host format" return (nick, user, host) def run_forever(timeout=2.0): """Run your clients forever. Just a handy front-end to asyncore.loop, so you don't have to import asyncore yourself. """ if False: map = asyncore.socket_map while map: print map asyncore.poll(timeout, map) else: asyncore.loop(timeout)