diff --git a/ircbot.py b/ircbot.py deleted file mode 100644 index 6463396d6fe9667eea2c05e864d88fbdbd5514d0..0000000000000000000000000000000000000000 --- a/ircbot.py +++ /dev/null @@ -1,462 +0,0 @@ -# Copyright (C) 1999--2002 Joel Rosdahl -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# Joel Rosdahl -# -# $Id: ircbot.py,v 1.21 2005/12/23 18:44:43 keltus Exp $ - -"""ircbot -- Simple IRC bot library. - -This module contains a single-server IRC bot class that can be used to -write simpler bots. -""" - -import sys -from UserDict import UserDict - -from irclib import SimpleIRCClient -from irclib import nm_to_n, irc_lower, all_events -from irclib import parse_channel_modes, is_channel -from irclib import ServerConnectionError -import threading -import time - -class OutputManager(threading.Thread): - def __init__(self, connection, delay=.5): - threading.Thread.__init__(self) - self.setDaemon(1) - self.connection = connection - self.delay = delay - self.event = threading.Event() - self.queue = [] - - def run(self): - while 1: - self.event.wait() - while self.queue: - msg,target = self.queue.pop(0) - self.connection.privmsg(target, msg) - time.sleep(self.delay) - self.event.clear() - - def send(self, msg, target): - self.queue.append((msg.strip(),target)) - self.event.set() - -class SingleServerIRCBot(SimpleIRCClient): - """A single-server IRC bot class. - - The bot tries to reconnect if it is disconnected. - - The bot keeps track of the channels it has joined, the other - clients that are present in the channels and which of those that - have operator or voice modes. The "database" is kept in the - self.channels attribute, which is an IRCDict of Channels. - """ - def __init__(self, server_list, nickname, realname, reconnection_interval=60): - """Constructor for SingleServerIRCBot objects. - - Arguments: - - server_list -- A list of tuples (server, port) that - defines which servers the bot should try to - connect to. - - nickname -- The bot's nickname. - - realname -- The bot's realname. - - reconnection_interval -- How long the bot should wait - before trying to reconnect. - - dcc_connections -- A list of initiated/accepted DCC - connections. - """ - - SimpleIRCClient.__init__(self) - self.channels = IRCDict() - self.server_list = server_list - if not reconnection_interval or reconnection_interval < 0: - reconnection_interval = 2**31 - self.reconnection_interval = reconnection_interval - - self._nickname = nickname - self._realname = realname - for i in ["disconnect", "join", "kick", "mode", - "namreply", "nick", "part", "quit"]: - self.connection.add_global_handler(i, - getattr(self, "_on_" + i), - -10) - def _connected_checker(self): - """[Internal]""" - if not self.connection.is_connected(): - self.connection.execute_delayed(self.reconnection_interval, - self._connected_checker) - self.jump_server() - - def _connect(self): - """[Internal]""" - password = None - if len(self.server_list[0]) > 2: - password = self.server_list[0][2] - try: - self.connect(self.server_list[0][0], - self.server_list[0][1], - self._nickname, - password, - ircname=self._realname) - except ServerConnectionError: - pass - - def _on_disconnect(self, c, e): - """[Internal]""" - self.channels = IRCDict() - self.connection.execute_delayed(self.reconnection_interval, - self._connected_checker) - - def _on_join(self, c, e): - """[Internal]""" - ch = e.target() - nick = nm_to_n(e.source()) - if nick == c.get_nickname(): - self.channels[ch] = Channel() - self.channels[ch].add_user(nick) - - def _on_kick(self, c, e): - """[Internal]""" - nick = e.arguments()[0] - channel = e.target() - - if nick == c.get_nickname(): - del self.channels[channel] - else: - self.channels[channel].remove_user(nick) - - def _on_mode(self, c, e): - """[Internal]""" - modes = parse_channel_modes(" ".join(e.arguments())) - t = e.target() - if is_channel(t): - ch = self.channels[t] - for mode in modes: - if mode[0] == "+": - f = ch.set_mode - else: - f = ch.clear_mode - f(mode[1], mode[2]) - else: - # Mode on self... XXX - pass - - def _on_namreply(self, c, e): - """[Internal]""" - - # e.arguments()[0] == "@" for secret channels, - # "*" for private channels, - # "=" for others (public channels) - # e.arguments()[1] == channel - # e.arguments()[2] == nick list - - ch = e.arguments()[1] - for nick in e.arguments()[2].split(): - if nick[0] == "@": - nick = nick[1:] - self.channels[ch].set_mode("o", nick) - elif nick[0] == "+": - nick = nick[1:] - self.channels[ch].set_mode("v", nick) - self.channels[ch].add_user(nick) - - def _on_nick(self, c, e): - """[Internal]""" - before = nm_to_n(e.source()) - after = e.target() - for ch in self.channels.values(): - if ch.has_user(before): - ch.change_nick(before, after) - - def _on_part(self, c, e): - """[Internal]""" - nick = nm_to_n(e.source()) - channel = e.target() - - if nick == c.get_nickname(): - del self.channels[channel] - else: - self.channels[channel].remove_user(nick) - - def _on_quit(self, c, e): - """[Internal]""" - nick = nm_to_n(e.source()) - for ch in self.channels.values(): - if ch.has_user(nick): - ch.remove_user(nick) - - def die(self, msg="Bye, cruel world!"): - """Let the bot die. - - Arguments: - - msg -- Quit message. - """ - - self.connection.disconnect(msg) - sys.exit(0) - - def disconnect(self, msg="I'll be back!"): - """Disconnect the bot. - - The bot will try to reconnect after a while. - - Arguments: - - msg -- Quit message. - """ - self.connection.disconnect(msg) - - def get_version(self): - """Returns the bot version. - - Used when answering a CTCP VERSION request. - """ - return "ircbot.py by Joel Rosdahl " - - def jump_server(self, msg="Changing servers"): - """Connect to a new server, possibly disconnecting from the current. - - The bot will skip to next server in the server_list each time - jump_server is called. - """ - if self.connection.is_connected(): - self.connection.disconnect(msg) - - self.server_list.append(self.server_list.pop(0)) - self._connect() - - def on_ctcp(self, c, e): - """Default handler for ctcp events. - - Replies to VERSION and PING requests and relays DCC requests - to the on_dccchat method. - """ - if e.arguments()[0] == "VERSION": - c.ctcp_reply(nm_to_n(e.source()), - "VERSION " + self.get_version()) - elif e.arguments()[0] == "PING": - if len(e.arguments()) > 1: - c.ctcp_reply(nm_to_n(e.source()), - "PING " + e.arguments()[1]) - elif e.arguments()[0] == "DCC" and e.arguments()[1].split(" ", 1)[0] == "CHAT": - self.on_dccchat(c, e) - - def on_dccchat(self, c, e): - pass - - def start(self): - """Start the bot.""" - self._connect() - SimpleIRCClient.start(self) - - -class IRCDict: - """A dictionary suitable for storing IRC-related things. - - Dictionary keys a and b are considered equal if and only if - irc_lower(a) == irc_lower(b) - - Otherwise, it should behave exactly as a normal dictionary. - """ - - def __init__(self, dict=None): - self.data = {} - self.canon_keys = {} # Canonical keys - if dict is not None: - self.update(dict) - def __repr__(self): - return repr(self.data) - def __cmp__(self, dict): - if isinstance(dict, IRCDict): - return cmp(self.data, dict.data) - else: - return cmp(self.data, dict) - def __len__(self): - return len(self.data) - def __getitem__(self, key): - return self.data[self.canon_keys[irc_lower(key)]] - def __setitem__(self, key, item): - if key in self: - del self[key] - self.data[key] = item - self.canon_keys[irc_lower(key)] = key - def __delitem__(self, key): - ck = irc_lower(key) - del self.data[self.canon_keys[ck]] - del self.canon_keys[ck] - def __iter__(self): - return iter(self.data) - def __contains__(self, key): - return self.has_key(key) - def clear(self): - self.data.clear() - self.canon_keys.clear() - def copy(self): - if self.__class__ is UserDict: - return UserDict(self.data) - import copy - return copy.copy(self) - def keys(self): - return self.data.keys() - def items(self): - return self.data.items() - def values(self): - return self.data.values() - def has_key(self, key): - return irc_lower(key) in self.canon_keys - def update(self, dict): - for k, v in dict.items(): - self.data[k] = v - def get(self, key, failobj=None): - return self.data.get(key, failobj) - - -class Channel: - """A class for keeping information about an IRC channel. - - This class can be improved a lot. - """ - - def __init__(self): - self.userdict = IRCDict() - self.operdict = IRCDict() - self.voiceddict = IRCDict() - self.modes = {} - - def users(self): - """Returns an unsorted list of the channel's users.""" - return self.userdict.keys() - - def opers(self): - """Returns an unsorted list of the channel's operators.""" - return self.operdict.keys() - - def voiced(self): - """Returns an unsorted list of the persons that have voice - mode set in the channel.""" - return self.voiceddict.keys() - - def has_user(self, nick): - """Check whether the channel has a user.""" - return nick in self.userdict - - def is_oper(self, nick): - """Check whether a user has operator status in the channel.""" - return nick in self.operdict - - def is_voiced(self, nick): - """Check whether a user has voice mode set in the channel.""" - return nick in self.voiceddict - - def add_user(self, nick): - self.userdict[nick] = 1 - - def remove_user(self, nick): - for d in self.userdict, self.operdict, self.voiceddict: - if nick in d: - del d[nick] - - def change_nick(self, before, after): - self.userdict[after] = 1 - del self.userdict[before] - if before in self.operdict: - self.operdict[after] = 1 - del self.operdict[before] - if before in self.voiceddict: - self.voiceddict[after] = 1 - del self.voiceddict[before] - - def set_mode(self, mode, value=None): - """Set mode on the channel. - - Arguments: - - mode -- The mode (a single-character string). - - value -- Value - """ - if mode == "o": - self.operdict[value] = 1 - elif mode == "v": - self.voiceddict[value] = 1 - else: - self.modes[mode] = value - - def clear_mode(self, mode, value=None): - """Clear mode on the channel. - - Arguments: - - mode -- The mode (a single-character string). - - value -- Value - """ - try: - if mode == "o": - del self.operdict[value] - elif mode == "v": - del self.voiceddict[value] - else: - del self.modes[mode] - except KeyError: - pass - - def has_mode(self, mode): - return mode in self.modes - - def is_moderated(self): - return self.has_mode("m") - - def is_secret(self): - return self.has_mode("s") - - def is_protected(self): - return self.has_mode("p") - - def has_topic_lock(self): - return self.has_mode("t") - - def is_invite_only(self): - return self.has_mode("i") - - def has_allow_external_messages(self): - return self.has_mode("n") - - def has_limit(self): - return self.has_mode("l") - - def limit(self): - if self.has_limit(): - return self.modes[l] - else: - return None - - def has_key(self): - return self.has_mode("k") - - def key(self): - if self.has_key(): - return self.modes["k"] - else: - return None diff --git a/irclib.py b/irclib.py deleted file mode 100644 index c072ecc754e0ca8fa831f61d71108ebd0e5038af..0000000000000000000000000000000000000000 --- a/irclib.py +++ /dev/null @@ -1,1550 +0,0 @@ -# Copyright (C) 1999--2002 Joel Rosdahl -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# keltus -# -# $Id: irclib.py,v 1.43 2005/12/24 22:12:40 keltus Exp $ - -"""irclib -- Internet Relay Chat (IRC) protocol client library. - -This library is intended to encapsulate the IRC protocol at a quite -low level. It provides an event-driven IRC client framework. It has -a fairly thorough support for the basic IRC protocol, CTCP, DCC chat, -but DCC file transfers is not yet supported. - -In order to understand how to make an IRC client, I'm afraid you more -or less must understand the IRC specifications. They are available -here: [IRC specifications]. - -The main features of the IRC client framework are: - - * Abstraction of the IRC protocol. - * Handles multiple simultaneous IRC server connections. - * Handles server PONGing transparently. - * Messages to the IRC server are done by calling methods on an IRC - connection object. - * Messages from an IRC server triggers events, which can be caught - by event handlers. - * Reading from and writing to IRC server sockets are normally done - by an internal select() loop, but the select()ing may be done by - an external main loop. - * Functions can be registered to execute at specified times by the - event-loop. - * Decodes CTCP tagging correctly (hopefully); I haven't seen any - other IRC client implementation that handles the CTCP - specification subtilties. - * A kind of simple, single-server, object-oriented IRC client class - that dispatches events to instance methods is included. - -Current limitations: - - * The IRC protocol shines through the abstraction a bit too much. - * Data is not written asynchronously to the server, i.e. the write() - may block if the TCP buffers are stuffed. - * There are no support for DCC file transfers. - * The author haven't even read RFC 2810, 2811, 2812 and 2813. - * Like most projects, documentation is lacking... - -.. [IRC specifications] http://www.irchelp.org/irchelp/rfc/ -""" - -import bisect -import re -import select -import socket -import string -import sys -import time -import types - -VERSION = 0, 4, 6 -DEBUG = 0 - -# TODO -# ---- -# (maybe) thread safety -# (maybe) color parser convenience functions -# documentation (including all event types) -# (maybe) add awareness of different types of ircds -# send data asynchronously to the server (and DCC connections) -# (maybe) automatically close unused, passive DCC connections after a while - -# NOTES -# ----- -# connection.quit() only sends QUIT to the server. -# ERROR from the server triggers the error event and the disconnect event. -# dropping of the connection triggers the disconnect event. - -class IRCError(Exception): - """Represents an IRC exception.""" - pass - - -class IRC: - """Class that handles one or several IRC server connections. - - When an IRC object has been instantiated, it can be used to create - Connection objects that represent the IRC connections. The - responsibility of the IRC object is to provide an event-driven - framework for the connections and to keep the connections alive. - It runs a select loop to poll each connection's TCP socket and - hands over the sockets with incoming data for processing by the - corresponding connection. - - The methods of most interest for an IRC client writer are server, - add_global_handler, remove_global_handler, execute_at, - execute_delayed, process_once and process_forever. - - Here is an example: - - irc = irclib.IRC() - server = irc.server() - server.connect(\"irc.some.where\", 6667, \"my_nickname\") - server.privmsg(\"a_nickname\", \"Hi there!\") - irc.process_forever() - - This will connect to the IRC server irc.some.where on port 6667 - using the nickname my_nickname and send the message \"Hi there!\" - to the nickname a_nickname. - """ - - def __init__(self, fn_to_add_socket=None, - fn_to_remove_socket=None, - fn_to_add_timeout=None): - """Constructor for IRC objects. - - Optional arguments are fn_to_add_socket, fn_to_remove_socket - and fn_to_add_timeout. The first two specify functions that - will be called with a socket object as argument when the IRC - object wants to be notified (or stop being notified) of data - coming on a new socket. When new data arrives, the method - process_data should be called. Similarly, fn_to_add_timeout - is called with a number of seconds (a floating point number) - as first argument when the IRC object wants to receive a - notification (by calling the process_timeout method). So, if - e.g. the argument is 42.17, the object wants the - process_timeout method to be called after 42 seconds and 170 - milliseconds. - - The three arguments mainly exist to be able to use an external - main loop (for example Tkinter's or PyGTK's main app loop) - instead of calling the process_forever method. - - An alternative is to just call ServerConnection.process_once() - once in a while. - """ - - if fn_to_add_socket and fn_to_remove_socket: - self.fn_to_add_socket = fn_to_add_socket - self.fn_to_remove_socket = fn_to_remove_socket - else: - self.fn_to_add_socket = None - self.fn_to_remove_socket = None - - self.fn_to_add_timeout = fn_to_add_timeout - self.connections = [] - self.handlers = {} - self.delayed_commands = [] # list of tuples in the format (time, function, arguments) - - self.add_global_handler("ping", _ping_ponger, -42) - - def server(self): - """Creates and returns a ServerConnection object.""" - - c = ServerConnection(self) - self.connections.append(c) - return c - - def process_data(self, sockets): - """Called when there is more data to read on connection sockets. - - Arguments: - - sockets -- A list of socket objects. - - See documentation for IRC.__init__. - """ - for s in sockets: - for c in self.connections: - if s == c._get_socket(): - c.process_data() - - def process_timeout(self): - """Called when a timeout notification is due. - - See documentation for IRC.__init__. - """ - t = time.time() - while self.delayed_commands: - if t >= self.delayed_commands[0][0]: - self.delayed_commands[0][1](*self.delayed_commands[0][2]) - del self.delayed_commands[0] - else: - break - - def process_once(self, timeout=0): - """Process data from connections once. - - Arguments: - - timeout -- How long the select() call should wait if no - data is available. - - This method should be called periodically to check and process - incoming data, if there are any. If that seems boring, look - at the process_forever method. - """ - sockets = map(lambda x: x._get_socket(), self.connections) - sockets = filter(lambda x: x != None, sockets) - if sockets: - (i, o, e) = select.select(sockets, [], [], timeout) - self.process_data(i) - else: - time.sleep(timeout) - self.process_timeout() - - def process_forever(self, timeout=0.2): - """Run an infinite loop, processing data from connections. - - This method repeatedly calls process_once. - - Arguments: - - timeout -- Parameter to pass to process_once. - """ - while 1: - self.process_once(timeout) - - def disconnect_all(self, message=""): - """Disconnects all connections.""" - for c in self.connections: - c.disconnect(message) - - def add_global_handler(self, event, handler, priority=0): - """Adds a global handler function for a specific event type. - - Arguments: - - event -- Event type (a string). Check the values of the - numeric_events dictionary in irclib.py for possible event - types. - - handler -- Callback function. - - priority -- A number (the lower number, the higher priority). - - The handler function is called whenever the specified event is - triggered in any of the connections. See documentation for - the Event class. - - The handler functions are called in priority order (lowest - number is highest priority). If a handler function returns - \"NO MORE\", no more handlers will be called. - """ - - if not event in self.handlers: - self.handlers[event] = [] - bisect.insort(self.handlers[event], ((priority, handler))) - - def remove_global_handler(self, event, handler): - """Removes a global handler function. - - Arguments: - - event -- Event type (a string). - - handler -- Callback function. - - Returns 1 on success, otherwise 0. - """ - if not event in self.handlers: - return 0 - for h in self.handlers[event]: - if handler == h[1]: - self.handlers[event].remove(h) - return 1 - - def execute_at(self, at, function, arguments=()): - """Execute a function at a specified time. - - Arguments: - - at -- Execute at this time (standard \"time_t\" time). - - function -- Function to call. - - arguments -- Arguments to give the function. - """ - self.execute_delayed(at-time.time(), function, arguments) - - def execute_delayed(self, delay, function, arguments=()): - """Execute a function after a specified time. - - Arguments: - - delay -- How many seconds to wait. - - function -- Function to call. - - arguments -- Arguments to give the function. - """ - bisect.insort(self.delayed_commands, (delay+time.time(), function, arguments)) - if self.fn_to_add_timeout: - self.fn_to_add_timeout(delay) - - def dcc(self, dcctype="chat"): - """Creates and returns a DCCConnection object. - - Arguments: - - dcctype -- "chat" for DCC CHAT connections or "raw" for - DCC SEND (or other DCC types). If "chat", - incoming data will be split in newline-separated - chunks. If "raw", incoming data is not touched. - """ - c = DCCConnection(self, dcctype) - self.connections.append(c) - return c - - def _handle_event(self, connection, event): - """[Internal]""" - h = self.handlers - for handler in h.get("all_events", []) + h.get(event.eventtype(), []): - if handler[1](connection, event) == "NO MORE": - return - - def _remove_connection(self, connection): - """[Internal]""" - self.connections.remove(connection) - if self.fn_to_remove_socket: - self.fn_to_remove_socket(connection._get_socket()) - -_rfc_1459_command_regexp = re.compile("^(:(?P[^ ]+) +)?(?P[^ ]+)( *(?P .+))?") - - -class Connection: - """Base class for IRC connections. - - Must be overridden. - """ - def __init__(self, irclibobj): - self.irclibobj = irclibobj - - def _get_socket(): - raise IRCError, "Not overridden" - - ############################## - ### Convenience wrappers. - - def execute_at(self, at, function, arguments=()): - self.irclibobj.execute_at(at, function, arguments) - - def execute_delayed(self, delay, function, arguments=()): - self.irclibobj.execute_delayed(delay, function, arguments) - - -class ServerConnectionError(IRCError): - pass - -class ServerNotConnectedError(ServerConnectionError): - pass - - -# Huh!? Crrrrazy EFNet doesn't follow the RFC: their ircd seems to -# use \n as message separator! :P -_linesep_regexp = re.compile("\r?\n") - -class ServerConnection(Connection): - """This class represents an IRC server connection. - - ServerConnection objects are instantiated by calling the server - method on an IRC object. - """ - - def __init__(self, irclibobj): - Connection.__init__(self, irclibobj) - self.connected = 0 # Not connected yet. - self.socket = None - - def connect(self, server, port, nickname, password=None, username=None, - ircname=None, localaddress="", localport=0): - """Connect/reconnect to a server. - - Arguments: - - server -- Server name. - - port -- Port number. - - nickname -- The nickname. - - password -- Password (if any). - - username -- The username. - - ircname -- The IRC name ("realname"). - - localaddress -- Bind the connection to a specific local IP address. - - localport -- Bind the connection to a specific local port. - - This function can be called to reconnect a closed connection. - - Returns the ServerConnection object. - """ - if self.connected: - self.disconnect("Changing servers") - - self.previous_buffer = "" - self.handlers = {} - self.real_server_name = "" - self.real_nickname = nickname - self.server = server - self.port = port - self.nickname = nickname - self.username = username or nickname - self.ircname = ircname or nickname - self.password = password - self.localaddress = localaddress - self.localport = localport - self.localhost = socket.gethostname() - self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - try: - self.socket.bind((self.localaddress, self.localport)) - self.socket.connect((self.server, self.port)) - except socket.error, x: - self.socket.close() - self.socket = None - raise ServerConnectionError, "Couldn't connect to socket: %s" % x - self.connected = 1 - if self.irclibobj.fn_to_add_socket: - self.irclibobj.fn_to_add_socket(self.socket) - - # Log on... - if self.password: - self.pass_(self.password) - self.nick(self.nickname) - self.user(self.username, self.ircname) - return self - - def close(self): - """Close the connection. - - This method closes the connection permanently; after it has - been called, the object is unusable. - """ - - self.disconnect("Closing object") - self.irclibobj._remove_connection(self) - - def _get_socket(self): - """[Internal]""" - return self.socket - - def get_server_name(self): - """Get the (real) server name. - - This method returns the (real) server name, or, more - specifically, what the server calls itself. - """ - - if self.real_server_name: - return self.real_server_name - else: - return "" - - def get_nickname(self): - """Get the (real) nick name. - - This method returns the (real) nickname. The library keeps - track of nick changes, so it might not be the nick name that - was passed to the connect() method. """ - - return self.real_nickname - - def process_data(self): - """[Internal]""" - - try: - new_data = self.socket.recv(2**14) - except socket.error, x: - # The server hung up. - self.disconnect("Connection reset by peer") - return - if not new_data: - # Read nothing: connection must be down. - self.disconnect("Connection reset by peer") - return - - lines = _linesep_regexp.split(self.previous_buffer + new_data) - - # Save the last, unfinished line. - self.previous_buffer = lines[-1] - lines = lines[:-1] - - for line in lines: - if DEBUG: - print "FROM SERVER:", line - - if not line: - continue - - prefix = None - command = None - arguments = None - self._handle_event(Event("all_raw_messages", - self.get_server_name(), - None, - [line])) - - m = _rfc_1459_command_regexp.match(line) - if m.group("prefix"): - prefix = m.group("prefix") - if not self.real_server_name: - self.real_server_name = prefix - - if m.group("command"): - command = m.group("command").lower() - - if m.group("argument"): - a = m.group("argument").split(" :", 1) - arguments = a[0].split() - if len(a) == 2: - arguments.append(a[1]) - - # Translate numerics into more readable strings. - if command in numeric_events: - command = numeric_events[command] - - if command == "nick": - if nm_to_n(prefix) == self.real_nickname: - self.real_nickname = arguments[0] - elif command == "welcome": - # Record the nickname in case the client changed nick - # in a nicknameinuse callback. - self.real_nickname = arguments[0] - - if command in ["privmsg", "notice"]: - target, message = arguments[0], arguments[1] - messages = _ctcp_dequote(message) - - if command == "privmsg": - if is_channel(target): - command = "pubmsg" - else: - if is_channel(target): - command = "pubnotice" - else: - command = "privnotice" - - for m in messages: - if type(m) is types.TupleType: - if command in ["privmsg", "pubmsg"]: - command = "ctcp" - else: - command = "ctcpreply" - - m = list(m) - if DEBUG: - print "command: %s, source: %s, target: %s, arguments: %s" % ( - command, prefix, target, m) - self._handle_event(Event(command, prefix, target, m)) - if command == "ctcp" and m[0] == "ACTION": - self._handle_event(Event("action", prefix, target, m[1:])) - else: - if DEBUG: - print "command: %s, source: %s, target: %s, arguments: %s" % ( - command, prefix, target, [m]) - self._handle_event(Event(command, prefix, target, [m])) - else: - target = None - - if command == "quit": - arguments = [arguments[0]] - elif command == "ping": - target = arguments[0] - else: - target = arguments[0] - arguments = arguments[1:] - - if command == "mode": - if not is_channel(target): - command = "umode" - - if DEBUG: - print "command: %s, source: %s, target: %s, arguments: %s" % ( - command, prefix, target, arguments) - self._handle_event(Event(command, prefix, target, arguments)) - - def _handle_event(self, event): - """[Internal]""" - self.irclibobj._handle_event(self, event) - if event.eventtype() in self.handlers: - for fn in self.handlers[event.eventtype()]: - fn(self, event) - - def is_connected(self): - """Return connection status. - - Returns true if connected, otherwise false. - """ - return self.connected - - def add_global_handler(self, *args): - """Add global handler. - - See documentation for IRC.add_global_handler. - """ - self.irclibobj.add_global_handler(*args) - - def remove_global_handler(self, *args): - """Remove global handler. - - See documentation for IRC.remove_global_handler. - """ - self.irclibobj.remove_global_handler(*args) - - def action(self, target, action): - """Send a CTCP ACTION command.""" - self.ctcp("ACTION", target, action) - - def admin(self, server=""): - """Send an ADMIN command.""" - self.send_raw(" ".join(["ADMIN", server]).strip()) - - def ctcp(self, ctcptype, target, parameter=""): - """Send a CTCP command.""" - ctcptype = ctcptype.upper() - self.privmsg(target, "\001%s%s\001" % (ctcptype, parameter and (" " + parameter) or "")) - - def ctcp_reply(self, target, parameter): - """Send a CTCP REPLY command.""" - self.notice(target, "\001%s\001" % parameter) - - def disconnect(self, message=""): - """Hang up the connection. - - Arguments: - - message -- Quit message. - """ - if not self.connected: - return - - self.connected = 0 - - self.quit(message) - - try: - self.socket.close() - except socket.error, x: - pass - self.socket = None - self._handle_event(Event("disconnect", self.server, "", [message])) - - def globops(self, text): - """Send a GLOBOPS command.""" - self.send_raw("GLOBOPS :" + text) - - def info(self, server=""): - """Send an INFO command.""" - self.send_raw(" ".join(["INFO", server]).strip()) - - def invite(self, nick, channel): - """Send an INVITE command.""" - self.send_raw(" ".join(["INVITE", nick, channel]).strip()) - - def ison(self, nicks): - """Send an ISON command. - - Arguments: - - nicks -- List of nicks. - """ - self.send_raw("ISON " + " ".join(nicks)) - - def join(self, channel, key=""): - """Send a JOIN command.""" - self.send_raw("JOIN %s%s" % (channel, (key and (" " + key)))) - - def kick(self, channel, nick, comment=""): - """Send a KICK command.""" - self.send_raw("KICK %s %s%s" % (channel, nick, (comment and (" :" + comment)))) - - def links(self, remote_server="", server_mask=""): - """Send a LINKS command.""" - command = "LINKS" - if remote_server: - command = command + " " + remote_server - if server_mask: - command = command + " " + server_mask - self.send_raw(command) - - def list(self, channels=None, server=""): - """Send a LIST command.""" - command = "LIST" - if channels: - command = command + " " + ",".join(channels) - if server: - command = command + " " + server - self.send_raw(command) - - def lusers(self, server=""): - """Send a LUSERS command.""" - self.send_raw("LUSERS" + (server and (" " + server))) - - def mode(self, target, command): - """Send a MODE command.""" - self.send_raw("MODE %s %s" % (target, command)) - - def motd(self, server=""): - """Send an MOTD command.""" - self.send_raw("MOTD" + (server and (" " + server))) - - def names(self, channels=None): - """Send a NAMES command.""" - self.send_raw("NAMES" + (channels and (" " + ",".join(channels)) or "")) - - def nick(self, newnick): - """Send a NICK command.""" - self.send_raw("NICK " + newnick) - - def notice(self, target, text): - """Send a NOTICE command.""" - # Should limit len(text) here! - self.send_raw("NOTICE %s :%s" % (target, text)) - - def oper(self, nick, password): - """Send an OPER command.""" - self.send_raw("OPER %s %s" % (nick, password)) - - def part(self, channels, message=""): - """Send a PART command.""" - if type(channels) == types.StringType: - self.send_raw("PART " + channels + (message and (" " + message))) - else: - self.send_raw("PART " + ",".join(channels) + (message and (" " + message))) - - def pass_(self, password): - """Send a PASS command.""" - self.send_raw("PASS " + password) - - def ping(self, target, target2=""): - """Send a PING command.""" - self.send_raw("PING %s%s" % (target, target2 and (" " + target2))) - - def pong(self, target, target2=""): - """Send a PONG command.""" - self.send_raw("PONG %s%s" % (target, target2 and (" " + target2))) - - def privmsg(self, target, text): - """Send a PRIVMSG command.""" - # Should limit len(text) here! - self.send_raw("PRIVMSG %s :%s" % (target, text)) - - def privmsg_many(self, targets, text): - """Send a PRIVMSG command to multiple targets.""" - # Should limit len(text) here! - self.send_raw("PRIVMSG %s :%s" % (",".join(targets), text)) - - def quit(self, message=""): - """Send a QUIT command.""" - # Note that many IRC servers don't use your QUIT message - # unless you've been connected for at least 5 minutes! - self.send_raw("QUIT" + (message and (" :" + message))) - - def sconnect(self, target, port="", server=""): - """Send an SCONNECT command.""" - self.send_raw("CONNECT %s%s%s" % (target, - port and (" " + port), - server and (" " + server))) - - def send_raw(self, string): - """Send raw string to the server. - - The string will be padded with appropriate CR LF. - """ - if self.socket is None: - raise ServerNotConnectedError, "Not connected." - try: - self.socket.send(string + "\r\n") - if DEBUG: - print "TO SERVER:", string - except socket.error, x: - # Ouch! - self.disconnect("Connection reset by peer.") - - def squit(self, server, comment=""): - """Send an SQUIT command.""" - self.send_raw("SQUIT %s%s" % (server, comment and (" :" + comment))) - - def stats(self, statstype, server=""): - """Send a STATS command.""" - self.send_raw("STATS %s%s" % (statstype, server and (" " + server))) - - def time(self, server=""): - """Send a TIME command.""" - self.send_raw("TIME" + (server and (" " + server))) - - def topic(self, channel, new_topic=None): - """Send a TOPIC command.""" - if new_topic is None: - self.send_raw("TOPIC " + channel) - else: - self.send_raw("TOPIC %s :%s" % (channel, new_topic)) - - def trace(self, target=""): - """Send a TRACE command.""" - self.send_raw("TRACE" + (target and (" " + target))) - - def user(self, username, realname): - """Send a USER command.""" - self.send_raw("USER %s 0 * :%s" % (username, realname)) - - def userhost(self, nicks): - """Send a USERHOST command.""" - self.send_raw("USERHOST " + ",".join(nicks)) - - def users(self, server=""): - """Send a USERS command.""" - self.send_raw("USERS" + (server and (" " + server))) - - def version(self, server=""): - """Send a VERSION command.""" - self.send_raw("VERSION" + (server and (" " + server))) - - def wallops(self, text): - """Send a WALLOPS command.""" - self.send_raw("WALLOPS :" + text) - - def who(self, target="", op=""): - """Send a WHO command.""" - self.send_raw("WHO%s%s" % (target and (" " + target), op and (" o"))) - - def whois(self, targets): - """Send a WHOIS command.""" - self.send_raw("WHOIS " + ",".join(targets)) - - def whowas(self, nick, max="", server=""): - """Send a WHOWAS command.""" - self.send_raw("WHOWAS %s%s%s" % (nick, - max and (" " + max), - server and (" " + server))) - - -class DCCConnectionError(IRCError): - pass - - -class DCCConnection(Connection): - """This class represents a DCC connection. - - DCCConnection objects are instantiated by calling the dcc - method on an IRC object. - """ - def __init__(self, irclibobj, dcctype): - Connection.__init__(self, irclibobj) - self.connected = 0 - self.passive = 0 - self.dcctype = dcctype - self.peeraddress = None - self.peerport = None - - def connect(self, address, port): - """Connect/reconnect to a DCC peer. - - Arguments: - address -- Host/IP address of the peer. - - port -- The port number to connect to. - - Returns the DCCConnection object. - """ - self.peeraddress = socket.gethostbyname(address) - self.peerport = port - self.socket = None - self.previous_buffer = "" - self.handlers = {} - self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - self.passive = 0 - try: - self.socket.connect((self.peeraddress, self.peerport)) - except socket.error, x: - raise DCCConnectionError, "Couldn't connect to socket: %s" % x - self.connected = 1 - if self.irclibobj.fn_to_add_socket: - self.irclibobj.fn_to_add_socket(self.socket) - return self - - def listen(self): - """Wait for a connection/reconnection from a DCC peer. - - Returns the DCCConnection object. - - The local IP address and port are available as - self.localaddress and self.localport. After connection from a - peer, the peer address and port are available as - self.peeraddress and self.peerport. - """ - self.previous_buffer = "" - self.handlers = {} - self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - self.passive = 1 - try: - self.socket.bind((socket.gethostbyname(socket.gethostname()), 0)) - self.localaddress, self.localport = self.socket.getsockname() - self.socket.listen(10) - except socket.error, x: - raise DCCConnectionError, "Couldn't bind socket: %s" % x - return self - - def disconnect(self, message=""): - """Hang up the connection and close the object. - - Arguments: - - message -- Quit message. - """ - if not self.connected: - return - - self.connected = 0 - try: - self.socket.close() - except socket.error, x: - pass - self.socket = None - self.irclibobj._handle_event( - self, - Event("dcc_disconnect", self.peeraddress, "", [message])) - self.irclibobj._remove_connection(self) - - def process_data(self): - """[Internal]""" - - if self.passive and not self.connected: - conn, (self.peeraddress, self.peerport) = self.socket.accept() - self.socket.close() - self.socket = conn - self.connected = 1 - if DEBUG: - print "DCC connection from %s:%d" % ( - self.peeraddress, self.peerport) - self.irclibobj._handle_event( - self, - Event("dcc_connect", self.peeraddress, None, None)) - return - - try: - new_data = self.socket.recv(2**14) - except socket.error, x: - # The server hung up. - self.disconnect("Connection reset by peer") - return - if not new_data: - # Read nothing: connection must be down. - self.disconnect("Connection reset by peer") - return - - if self.dcctype == "chat": - # The specification says lines are terminated with LF, but - # it seems safer to handle CR LF terminations too. - chunks = _linesep_regexp.split(self.previous_buffer + new_data) - - # Save the last, unfinished line. - self.previous_buffer = chunks[-1] - if len(self.previous_buffer) > 2**14: - # Bad peer! Naughty peer! - self.disconnect() - return - chunks = chunks[:-1] - else: - chunks = [new_data] - - command = "dccmsg" - prefix = self.peeraddress - target = None - for chunk in chunks: - if DEBUG: - print "FROM PEER:", chunk - arguments = [chunk] - if DEBUG: - print "command: %s, source: %s, target: %s, arguments: %s" % ( - command, prefix, target, arguments) - self.irclibobj._handle_event( - self, - Event(command, prefix, target, arguments)) - - def _get_socket(self): - """[Internal]""" - return self.socket - - def privmsg(self, string): - """Send data to DCC peer. - - The string will be padded with appropriate LF if it's a DCC - CHAT session. - """ - try: - self.socket.send(string) - if self.dcctype == "chat": - self.socket.send("\n") - if DEBUG: - print "TO PEER: %s\n" % string - except socket.error, x: - # Ouch! - self.disconnect("Connection reset by peer.") - -class SimpleIRCClient: - """A simple single-server IRC client class. - - This is an example of an object-oriented wrapper of the IRC - framework. A real IRC client can be made by subclassing this - class and adding appropriate methods. - - The method on_join will be called when a "join" event is created - (which is done when the server sends a JOIN messsage/command), - on_privmsg will be called for "privmsg" events, and so on. The - handler methods get two arguments: the connection object (same as - self.connection) and the event object. - - Instance attributes that can be used by sub classes: - - ircobj -- The IRC instance. - - connection -- The ServerConnection instance. - - dcc_connections -- A list of DCCConnection instances. - """ - def __init__(self): - self.ircobj = IRC() - self.connection = self.ircobj.server() - self.dcc_connections = [] - self.ircobj.add_global_handler("all_events", self._dispatcher, -10) - self.ircobj.add_global_handler("dcc_disconnect", self._dcc_disconnect, -10) - - def _dispatcher(self, c, e): - """[Internal]""" - m = "on_" + e.eventtype() - if hasattr(self, m): - getattr(self, m)(c, e) - - def _dcc_disconnect(self, c, e): - self.dcc_connections.remove(c) - - def connect(self, server, port, nickname, password=None, username=None, - ircname=None, localaddress="", localport=0): - """Connect/reconnect to a server. - - Arguments: - - server -- Server name. - - port -- Port number. - - nickname -- The nickname. - - password -- Password (if any). - - username -- The username. - - ircname -- The IRC name. - - localaddress -- Bind the connection to a specific local IP address. - - localport -- Bind the connection to a specific local port. - - This function can be called to reconnect a closed connection. - """ - self.connection.connect(server, port, nickname, - password, username, ircname, - localaddress, localport) - - def dcc_connect(self, address, port, dcctype="chat"): - """Connect to a DCC peer. - - Arguments: - - address -- IP address of the peer. - - port -- Port to connect to. - - Returns a DCCConnection instance. - """ - dcc = self.ircobj.dcc(dcctype) - self.dcc_connections.append(dcc) - dcc.connect(address, port) - return dcc - - def dcc_listen(self, dcctype="chat"): - """Listen for connections from a DCC peer. - - Returns a DCCConnection instance. - """ - dcc = self.ircobj.dcc(dcctype) - self.dcc_connections.append(dcc) - dcc.listen() - return dcc - - def start(self): - """Start the IRC client.""" - self.ircobj.process_forever() - - -class Event: - """Class representing an IRC event.""" - def __init__(self, eventtype, source, target, arguments=None): - """Constructor of Event objects. - - Arguments: - - eventtype -- A string describing the event. - - source -- The originator of the event (a nick mask or a server). - - target -- The target of the event (a nick or a channel). - - arguments -- Any event specific arguments. - """ - self._eventtype = eventtype - self._source = source - self._target = target - if arguments: - self._arguments = arguments - else: - self._arguments = [] - - def eventtype(self): - """Get the event type.""" - return self._eventtype - - def source(self): - """Get the event source.""" - return self._source - - def target(self): - """Get the event target.""" - return self._target - - def arguments(self): - """Get the event arguments.""" - return self._arguments - -_LOW_LEVEL_QUOTE = "\020" -_CTCP_LEVEL_QUOTE = "\134" -_CTCP_DELIMITER = "\001" - -_low_level_mapping = { - "0": "\000", - "n": "\n", - "r": "\r", - _LOW_LEVEL_QUOTE: _LOW_LEVEL_QUOTE -} - -_low_level_regexp = re.compile(_LOW_LEVEL_QUOTE + "(.)") - -def mask_matches(nick, mask): - """Check if a nick matches a mask. - - Returns true if the nick matches, otherwise false. - """ - nick = irc_lower(nick) - mask = irc_lower(mask) - mask = mask.replace("\\", "\\\\") - for ch in ".$|[](){}+": - mask = mask.replace(ch, "\\" + ch) - mask = mask.replace("?", ".") - mask = mask.replace("*", ".*") - r = re.compile(mask, re.IGNORECASE) - return r.match(nick) - -_special = "-[]\\`^{}" -nick_characters = string.ascii_letters + string.digits + _special -_ircstring_translation = string.maketrans(string.ascii_uppercase + "[]\\^", - string.ascii_lowercase + "{}|~") - -def irc_lower(s): - """Returns a lowercased string. - - The definition of lowercased comes from the IRC specification (RFC - 1459). - """ - return s.translate(_ircstring_translation) - -def _ctcp_dequote(message): - """[Internal] Dequote a message according to CTCP specifications. - - The function returns a list where each element can be either a - string (normal message) or a tuple of one or two strings (tagged - messages). If a tuple has only one element (ie is a singleton), - that element is the tag; otherwise the tuple has two elements: the - tag and the data. - - Arguments: - - message -- The message to be decoded. - """ - - def _low_level_replace(match_obj): - ch = match_obj.group(1) - - # If low_level_mapping doesn't have the character as key, we - # should just return the character. - return _low_level_mapping.get(ch, ch) - - if _LOW_LEVEL_QUOTE in message: - # Yup, there was a quote. Release the dequoter, man! - message = _low_level_regexp.sub(_low_level_replace, message) - - if _CTCP_DELIMITER not in message: - return [message] - else: - # Split it into parts. (Does any IRC client actually *use* - # CTCP stacking like this?) - chunks = message.split(_CTCP_DELIMITER) - - messages = [] - i = 0 - while i < len(chunks)-1: - # Add message if it's non-empty. - if len(chunks[i]) > 0: - messages.append(chunks[i]) - - if i < len(chunks)-2: - # Aye! CTCP tagged data ahead! - messages.append(tuple(chunks[i+1].split(" ", 1))) - - i = i + 2 - - if len(chunks) % 2 == 0: - # Hey, a lonely _CTCP_DELIMITER at the end! This means - # that the last chunk, including the delimiter, is a - # normal message! (This is according to the CTCP - # specification.) - messages.append(_CTCP_DELIMITER + chunks[-1]) - - return messages - -def is_channel(string): - """Check if a string is a channel name. - - Returns true if the argument is a channel name, otherwise false. - """ - return string and string[0] in "#&+!" - -def ip_numstr_to_quad(num): - """Convert an IP number as an integer given in ASCII - representation (e.g. '3232235521') to an IP address string - (e.g. '192.168.0.1').""" - n = long(num) - p = map(str, map(int, [n >> 24 & 0xFF, n >> 16 & 0xFF, - n >> 8 & 0xFF, n & 0xFF])) - return ".".join(p) - -def ip_quad_to_numstr(quad): - """Convert an IP address string (e.g. '192.168.0.1') to an IP - number as an integer given in ASCII representation - (e.g. '3232235521').""" - p = map(long, quad.split(".")) - s = str((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]) - if s[-1] == "L": - s = s[:-1] - return s - -def nm_to_n(s): - """Get the nick part of a nickmask. - - (The source of an Event is a nickmask.) - """ - return s.split("!")[0] - -def nm_to_uh(s): - """Get the userhost part of a nickmask. - - (The source of an Event is a nickmask.) - """ - return s.split("!")[1] - -def nm_to_h(s): - """Get the host part of a nickmask. - - (The source of an Event is a nickmask.) - """ - return s.split("@")[1] - -def nm_to_u(s): - """Get the user part of a nickmask. - - (The source of an Event is a nickmask.) - """ - s = s.split("!")[1] - return s.split("@")[0] - -def parse_nick_modes(mode_string): - """Parse a nick mode string. - - The function returns a list of lists with three members: sign, - mode and argument. The sign is \"+\" or \"-\". The argument is - always None. - - Example: - - >>> irclib.parse_nick_modes(\"+ab-c\") - [['+', 'a', None], ['+', 'b', None], ['-', 'c', None]] - """ - - return _parse_modes(mode_string, "") - -def parse_channel_modes(mode_string): - """Parse a channel mode string. - - The function returns a list of lists with three members: sign, - mode and argument. The sign is \"+\" or \"-\". The argument is - None if mode isn't one of \"b\", \"k\", \"l\", \"v\" or \"o\". - - Example: - - >>> irclib.parse_channel_modes(\"+ab-c foo\") - [['+', 'a', None], ['+', 'b', 'foo'], ['-', 'c', None]] - """ - - return _parse_modes(mode_string, "bklvo") - -def _parse_modes(mode_string, unary_modes=""): - """[Internal]""" - modes = [] - arg_count = 0 - - # State variable. - sign = "" - - a = mode_string.split() - if len(a) == 0: - return [] - else: - mode_part, args = a[0], a[1:] - - if mode_part[0] not in "+-": - return [] - for ch in mode_part: - if ch in "+-": - sign = ch - elif ch == " ": - collecting_arguments = 1 - elif ch in unary_modes: - if len(args) >= arg_count + 1: - modes.append([sign, ch, args[arg_count]]) - arg_count = arg_count + 1 - else: - modes.append([sign, ch, None]) - else: - modes.append([sign, ch, None]) - return modes - -def _ping_ponger(connection, event): - """[Internal]""" - connection.pong(event.target()) - -# Numeric table mostly stolen from the Perl IRC module (Net::IRC). -numeric_events = { - "001": "welcome", - "002": "yourhost", - "003": "created", - "004": "myinfo", - "005": "featurelist", # XXX - "200": "tracelink", - "201": "traceconnecting", - "202": "tracehandshake", - "203": "traceunknown", - "204": "traceoperator", - "205": "traceuser", - "206": "traceserver", - "207": "traceservice", - "208": "tracenewtype", - "209": "traceclass", - "210": "tracereconnect", - "211": "statslinkinfo", - "212": "statscommands", - "213": "statscline", - "214": "statsnline", - "215": "statsiline", - "216": "statskline", - "217": "statsqline", - "218": "statsyline", - "219": "endofstats", - "221": "umodeis", - "231": "serviceinfo", - "232": "endofservices", - "233": "service", - "234": "servlist", - "235": "servlistend", - "241": "statslline", - "242": "statsuptime", - "243": "statsoline", - "244": "statshline", - "250": "luserconns", - "251": "luserclient", - "252": "luserop", - "253": "luserunknown", - "254": "luserchannels", - "255": "luserme", - "256": "adminme", - "257": "adminloc1", - "258": "adminloc2", - "259": "adminemail", - "261": "tracelog", - "262": "endoftrace", - "263": "tryagain", - "265": "n_local", - "266": "n_global", - "300": "none", - "301": "away", - "302": "userhost", - "303": "ison", - "305": "unaway", - "306": "nowaway", - "311": "whoisuser", - "312": "whoisserver", - "313": "whoisoperator", - "314": "whowasuser", - "315": "endofwho", - "316": "whoischanop", - "317": "whoisidle", - "318": "endofwhois", - "319": "whoischannels", - "321": "liststart", - "322": "list", - "323": "listend", - "324": "channelmodeis", - "329": "channelcreate", - "331": "notopic", - "332": "currenttopic", - "333": "topicinfo", - "341": "inviting", - "342": "summoning", - "346": "invitelist", - "347": "endofinvitelist", - "348": "exceptlist", - "349": "endofexceptlist", - "351": "version", - "352": "whoreply", - "353": "namreply", - "361": "killdone", - "362": "closing", - "363": "closeend", - "364": "links", - "365": "endoflinks", - "366": "endofnames", - "367": "banlist", - "368": "endofbanlist", - "369": "endofwhowas", - "371": "info", - "372": "motd", - "373": "infostart", - "374": "endofinfo", - "375": "motdstart", - "376": "endofmotd", - "377": "motd2", # 1997-10-16 -- tkil - "381": "youreoper", - "382": "rehashing", - "384": "myportis", - "391": "time", - "392": "usersstart", - "393": "users", - "394": "endofusers", - "395": "nousers", - "401": "nosuchnick", - "402": "nosuchserver", - "403": "nosuchchannel", - "404": "cannotsendtochan", - "405": "toomanychannels", - "406": "wasnosuchnick", - "407": "toomanytargets", - "409": "noorigin", - "411": "norecipient", - "412": "notexttosend", - "413": "notoplevel", - "414": "wildtoplevel", - "421": "unknowncommand", - "422": "nomotd", - "423": "noadmininfo", - "424": "fileerror", - "431": "nonicknamegiven", - "432": "erroneusnickname", # Thiss iz how its speld in thee RFC. - "433": "nicknameinuse", - "436": "nickcollision", - "437": "unavailresource", # "Nick temporally unavailable" - "441": "usernotinchannel", - "442": "notonchannel", - "443": "useronchannel", - "444": "nologin", - "445": "summondisabled", - "446": "usersdisabled", - "451": "notregistered", - "461": "needmoreparams", - "462": "alreadyregistered", - "463": "nopermforhost", - "464": "passwdmismatch", - "465": "yourebannedcreep", # I love this one... - "466": "youwillbebanned", - "467": "keyset", - "471": "channelisfull", - "472": "unknownmode", - "473": "inviteonlychan", - "474": "bannedfromchan", - "475": "badchannelkey", - "476": "badchanmask", - "477": "nochanmodes", # "Channel doesn't support modes" - "478": "banlistfull", - "481": "noprivileges", - "482": "chanoprivsneeded", - "483": "cantkillserver", - "484": "restricted", # Connection is restricted - "485": "uniqopprivsneeded", - "491": "nooperhost", - "492": "noservicehost", - "501": "umodeunknownflag", - "502": "usersdontmatch", -} - -generated_events = [ - # Generated events - "dcc_connect", - "dcc_disconnect", - "dccmsg", - "disconnect", - "ctcp", - "ctcpreply", -] - -protocol_events = [ - # IRC protocol events - "error", - "join", - "kick", - "mode", - "part", - "ping", - "privmsg", - "privnotice", - "pubmsg", - "pubnotice", - "quit", - "invite", - "pong", -] - -all_events = generated_events + protocol_events + numeric_events.values() diff --git a/lolbot.py b/lolbot.py index 8b0606acdf07b798f2e98c707723b0b265874482..b2c8e12120d12f3446bf80255d2ff5f5990ea843 100755 --- a/lolbot.py +++ b/lolbot.py @@ -2,8 +2,7 @@ # # LolBot # -# Code originally based on example bot and irc-bot class from -# Joel Rosdahl , author of included python-irclib. +# New version based on Twisted IRC. """ Useful bot for folks stuck behind censor walls at work @@ -11,20 +10,22 @@ Logs a channel and collects URLs for later. """ try: - import sys, string, random, time - from ircbot import SingleServerIRCBot, OutputManager - from irclib import nm_to_n, nm_to_h, irc_lower + import sys import os - + import string + import random + import time + import getopt + from twisted.words.protocols import irc + from twisted.internet import protocol + from twisted.internet import reactor from datetime import datetime from mechanize import Browser - - import getopt from sqlalchemy import MetaData, Table, Column, String, Text, Integer, DateTime, engine_from_config from sqlalchemy.orm import sessionmaker from sqlalchemy.ext.declarative import declarative_base except ImportError: - print "Some modules could not be loaded: Lolbot relies on Mechanize and SQLAlchemy.\n" + print "Some modules missing: Lolbot relies on Twisted IRC, Mechanize and SQLAlchemy.\n" sys.exit # Exclamations - wrong input @@ -48,310 +49,341 @@ ponderings = [ SqlBase = declarative_base() class Log(SqlBase): - """ - This class represents an event in the log table and inherits from a SQLAlchemy - convenience ORM class. - """ + """ + This class represents an event in the log table and inherits from a SQLAlchemy + convenience ORM class. + """ - __tablename__ = "log" + __tablename__ = "log" - id = Column(Integer, primary_key=True) - timestamp = Column(DateTime) - nickname = Column(String(20)) - text = Column(Text) + id = Column(Integer, primary_key=True) + timestamp = Column(DateTime) + nickname = Column(String(20)) + text = Column(Text) - def __init__(self, nickname, text, timestamp=None): - if timestamp is None: - timestamp = datetime.now() - self.timestamp = timestamp - self.nickname = nickname - self.text = text + def __init__(self, nickname, text, timestamp=None): + """ + Creates an event log for the IRC logger. + """ + if timestamp is None: + timestamp = datetime.now() + self.timestamp = timestamp + self.nickname = nickname + self.text = text - def __repr__(self): - return "(%s) %s: %s" % (self.timestamp.strftime("%Y-%m-%d %H:%M:%S"), self.nickname, self.text) + def __repr__(self): + return "(%s) %s: %s" % (self.timestamp.strftime("%Y-%m-%d %H:%M:%S"), self.nickname, self.text) class Url(SqlBase): - """ - This class represents a saved URL and inherits from a SQLAlchemy convenience - ORM class. - """ - - __tablename__ = "url" - - id = Column(Integer, primary_key=True) - timestamp = Column(DateTime) - nickname = Column(String(20)) - url = Column(String(200), unique=True) - title = Column(Text) - - def __init__(self, nickname, url, title=None, timestamp=None): - if timestamp is None: - timestamp = datetime.now() - self.timestamp = timestamp - self.nickname = nickname - self.url = url - self.title = title - - # populate the title from the URL if not given. - if title is None: - try: - br = Browser() - br.open(self.url) - self.title = br.title() - except Exception as ex: - self.title = '' - - def __repr__(self): - if not self.title: - return "%s: %s" % (self.nickname, self.url) - else: - return "%s: %s - %s" % (self.nickname, self.url, self.title) - -class LolBot(SingleServerIRCBot): - """ - The Lolbot itself. - """ - - def __init__(self, config_path=''): - self.get_config(config_path) - SingleServerIRCBot.__init__(self, [(self.server, self.port)], self.nickname, self.nickname) - - # connect to the database - self.dbengine = engine_from_config(self.config, prefix="db.") - SqlBase.metadata.bind = self.dbengine - SqlBase.metadata.create_all() - self.get_session = sessionmaker(bind=self.dbengine) - - self.helptext = "Keeps a list of URLs. Commands: list [n|x-y] - prints the last 10 URLs (or n URLs, or x through y); clear - clears the list; lol - say something funny; - adds the URL to the list; help - this message." - - self.queue = OutputManager(self.connection) - self.queue.start() - self.start() - - def get_config(self, config_path): + """ + This class represents a saved URL and inherits from a SQLAlchemy convenience + ORM class. + """ + + __tablename__ = "url" + + id = Column(Integer, primary_key=True) + timestamp = Column(DateTime) + nickname = Column(String(20)) + url = Column(String(200), unique=True) + title = Column(Text) + + def __init__(self, nickname, url, title=None, timestamp=None): + if timestamp is None: + timestamp = datetime.now() + self.timestamp = timestamp + self.nickname = nickname + self.url = url + self.title = title + + # populate the title from the URL if not given. + if title is None: + try: + br = Browser() + br.open(self.url) + self.title = br.title() + except Exception as ex: + self.title = '' + + def __repr__(self): + if not self.title: + return "%s: %s" % (self.nickname, self.url) + else: + return "%s: %s - %s" % (self.nickname, self.url, self.title) + +class LolBot(irc.IRCClient): + """ + The Lolbot itself. + """ + + def created(self, when): + # connect to the database + self.dbengine = engine_from_config(self.config, prefix="db.") + SqlBase.metadata.bind = self.dbengine + SqlBase.metadata.create_all() + self.get_session = sessionmaker(bind=self.dbengine) + + self.helptext = "Keeps a list of URLs. Commands: list [n|x-y] - prints the last 10 URLs (or n URLs, or x through y); clear - clears the list; lol - say something funny; - adds the URL to the list; help - this message." + + def now(self): + return datetime.today().strftime("%Y-%m-%d %H:%M:%S") + + def save_url(self, nickname, url): + title = False + try: + db = self.get_session() + if not db.query(Url).filter(Url.url == url).count(): + theurl = Url(nickname, url) + db.add(theurl) + db.commit() + else: + theurl = db.query(Url).filter(Url.url == url).one() + print theurl + title = theurl.title + except Exception, ex: + print "Exception caught saving URL: %s" % ex + return title + + def log_event(self, nick, text): + try: + entry = Log(nick, text) + db = self.get_session() + db.add(entry) + db.commit() + print entry + except Exception, ex: + print "Exception caught logging event: %s" % ex + + def _get_nickname(self): + return self.factory.nickname + nickname = property(_get_nickname) + + def _get_channel(self): + return self.factory.channel + channel = property(_get_channel) + + def _get_config(self): + return self.factory.config + config = property(_get_config) + + def signedOn(self): + self.join(self.channel) + print "Signed on as %s." % (self.nickname,) + + def joined(self, channel): + print "Joined %s." % (channel,) + + def privmsg(self, user, channel, msg): + if channel != self.channel: + # Private /msg from a user + self.do_command(msg, user) + else: + # log it + self.log_event(user, msg) + + args = string.split(msg, ":", 1) + if len(args) > 1 and args[0] == self.nickname: + self.do_command(string.strip(args[1])) + else: + # parse it for links, add URLs to the list + words = msg.split(" ") + for w in words: + if w.startswith('http://') or w.startswith('https://'): + title = self.save_url(user, w) + if title == False: + self.say_public("Sorry, I'm useless at UTF-8.") + else: + self.say_public("URL added. %s" % title) + + def say_public(self, text): + "Print TEXT into public channel, for all to see." + self.msg(self.channel, text) + self.log_event(self.nickname, text) + + def say_private(self, nick, text): + "Send private message of TEXT to NICK." + self.msg(nick, text) + + def reply(self, text, to_private=None): + "Send TEXT to either public channel or TO_PRIVATE nick (if defined)." + if to_private is not None: + self.say_private(to_private, text) + else: + self.say_public(text) + + def ponder(self): + "Return a random pondering." + return random.choice(ponderings) + + def exclaim(self): + "Return a random exclamation string." + return random.choice(exclamations) + + def do_command(self, cmd, target=None): + """ + This is the function called whenever someone sends a public or + private message addressed to the bot. (e.g. "bot: blah"). + """ + + target = target.strip() + + try: + if cmd == 'help': + self.reply(self.helptext, target) + + elif cmd == 'lol': + self.reply(self.ponder(), target) + + elif cmd == 'urls' or cmd == 'list': + db = self.get_session() + for url in db.query(Url).order_by(Url.timestamp.desc())[:10]: + line = "%s %s" % (url.url, url.title) + self.reply(line, target) + time.sleep(1) + + elif cmd.startswith('urls ') or cmd.startswith('list '): + db = self.get_session() + (listcmd, n) = cmd.split(" ", 1) + n = n.strip() + if n == "all": + rows = db.query(Url).order_by(Url.timestamp.desc()) + elif n.find("-") > 0: + (x, y) = n.split("-", 1) + try: + x = abs(int(x)) + y = abs(int(y)) + if y < x: + x, y = y, x + except ValueError, ex: + self.reply("Give me a number or a range of numbers, e.g. list 5 or list 11-20", target) + raise ex + rows = db.query(Url).order_by(Url.timestamp.desc())[x-1:y] + else: + try: + n = abs(int(n)) + except ValueError, ex: + self.reply("Give me a number or a range of numbers, e.g. list 5 or list 11-20", target) + raise ex + rows = db.query(Url).order_by(Url.timestamp.desc())[:n] + + for url in rows: + line = "%s %s" % (url.url, url.title) + self.reply(line, target) + time.sleep(1) + + elif cmd.startswith('http:') or cmd.startswith('https:'): + title = self.save_url(from_private, cmd) + if title == False: + self.say_public("Sorry, I'm useless at UTF-8.") + else: + self.reply('URL added. %s' % title, target) + + else: + self.reply(self.exclaim(), target) + + except Exception, ex: + print "Exception caught processing command: %s" % ex + print " command was '%s' from %s" % (cmd, target) + self.reply("Sorry, I didn't understand: %s" % cmd, target) + self.reply(self.helptext, target) + +class LolBotFactory(protocol.ClientFactory): + protocol = LolBot + + def __init__(self, config_path): + self.config = get_config(config_path) + self.server = self.config['irc.server'] + self.port = self.config['irc.port'] + self.nickname = self.config['irc.nickname'] + self.channel = self.config['irc.channel'] + + def clientConnectionLost(self, connector, reason): + print "Lost connection (%s), reconnecting." % (reason,) + connector.connect() + + def clientConnectionFailed(self, connector, reason): + print "Could not connect: %s" % (reason,) + +def get_options(): + try: + (options, args) = getopt.getopt(sys.argv[1:], "hc:", ["help", "config=", ]) + except getopt.GetoptError, err: + print str(err) + usage() + sys.exit(2) + + config_path = "" + for option,value in options: + if option in ("-h", "--help"): + usage() + sys.exit(2) + if option in ("-c", "--config"): + config_path = value + return { 'config_path': config_path } + +def get_config(config_path): """ This method loads configuration options from a lolbot.conf file. The file should look like this: - irc.server = irc.freenode.net - irc.port = 6667 - irc.channel = #lolbottest - irc.nickname = lolbot - db.url = sqlite:///lolbot.db + irc.server = irc.freenode.net + irc.port = 6667 + irc.channel = #lolbottest + irc.nickname = lolbot + db.url = sqlite:///lolbot.db """ if not config_path: - config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lolbot.conf") + config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lolbot.conf") if not os.path.exists(config_path): - print "Error: configuration file not found. By default lolbot will look for a lolbot.conf file in the same directory as the lolbot script, but you can override this by specifying a path on the command line with the --config option." - usage() - sys.exit(1) + print "Error: configuration file not found. By default lolbot will look for a lolbot.conf file in the same directory as the lolbot script, but you can override this by specifying a path on the command line with the --config option." + usage() + sys.exit(1) # open the configuration file and grab all param=value declarations. config = {} with open(config_path) as f: - for line in f: - # skip comments - if line.strip().startswith("#") or line.strip() == "": - continue - - # collect up param = value - try: - (param, value) = line.strip().split("=", 1) - if param.strip() != "": - config[param.strip()] = value.strip() - except ValueError: - continue + for line in f: + # skip comments + if line.strip().startswith("#") or line.strip() == "": + continue + + # collect up param = value + try: + (param, value) = line.strip().split("=", 1) + if param.strip() != "": + config[param.strip()] = value.strip() + except ValueError: + continue # validate IRC host if "irc.server" not in config.keys(): - print "Error: the IRC server was not specified. Use --help for more information." - sys.exit(1) - self.server = config["irc.server"] + print "Error: the IRC server was not specified. Use --help for more information." + sys.exit(1) # validate IRC port if "irc.port" not in config.keys(): - config["irc.port"] = "6667" + config["irc.port"] = "6667" try: - self.port = int(config["irc.port"]) + config["irc.port"] = int(config["irc.port"]) except ValueError: - print "Error: the IRC port must be an integer. If not specified, lolbot will use the default IRC port value 6667. Use --help for more information." - sys.exit(1) + print "Error: the IRC port must be an integer. If not specified, lolbot will use the default IRC port value 6667. Use --help for more information." + sys.exit(1) # validate IRC channel if "irc.channel" not in config.keys() or not config["irc.channel"].startswith("#"): - print "Error: the IRC channel is not specified or incorrect. It must begin with a # - e.g. #mychatchannel. Use --help for more information." - sys.exit(1) - self.channel = config["irc.channel"] + print "Error: the IRC channel is not specified or incorrect. It must begin with a # - e.g. #mychatchannel. Use --help for more information." + sys.exit(1) # validate bot nickname if "irc.nickname" not in config.keys(): - config["irc.nickname"] = "lolbot" - self.nickname = config["irc.nickname"] - - self.config = config - - def now(self): - return datetime.today().strftime("%Y-%m-%d %H:%M:%S") - - def save_url(self, nickname, url): - title = False - try: - db = self.get_session() - if not db.query(Url).filter(Url.url == url).count(): - theurl = Url(nickname, url) - db.add(theurl) - db.commit() - else: - theurl = db.query(Url).filter(Url.url == url).one() - print theurl - title = theurl.title - except Exception, ex: - print "Exception caught saving URL: %s" % ex - return title - - def log_event(self, nick, text): - try: - entry = Log(nick, text) - db = self.get_session() - db.add(entry) - db.commit() - print entry - except Exception, ex: - print "Exception caught logging event: %s" % ex - - def on_nicknameinuse(self, connection, event): - self.nickname = connection.get_nickname() + "_" - connection.nick(self.nickname) - - def on_welcome(self, connection, event): - connection.join(self.channel) - - def on_privmsg(self, connection, event): - "Deal with a /msg private message." - from_nick = nm_to_n(event.source()) - self.do_command(event, event.arguments()[0], from_nick) - - def on_pubmsg(self, connection, event): - "Deal with a public message in a channel." - - # log it - from_nick = nm_to_n(event.source()) - self.log_event(from_nick, event.arguments()[0]) - - args = string.split(event.arguments()[0], ":", 1) - if len(args) > 1 and irc_lower(args[0]) == irc_lower(self.nickname): - self.do_command(event, string.strip(args[1]), from_nick) - else: - # parse it for links, add URLs to the list - words = event.arguments()[0].split(" ") - for w in words: - if w.startswith('http://') or w.startswith('https://'): - title = self.save_url(from_nick, w) - if title == False: - self.say_public("Sorry, I'm useless at UTF-8.") - else: - self.say_public("URL added. %s" % title) - - def say_public(self, text): - "Print TEXT into public channel, for all to see." - self.queue.send(text, self.channel) - self.log_event(self.nickname, text) - - def say_private(self, nick, text): - "Send private message of TEXT to NICK." - self.queue.send(text, nick) - - def reply(self, text, to_private=None): - "Send TEXT to either public channel or TO_PRIVATE nick (if defined)." - if to_private is not None: - self.say_private(to_private, text) - else: - self.say_public(text) - - def ponder(self): - "Return a random pondering." - return random.choice(ponderings) - - def exclaim(self): - "Return a random exclamation string." - return random.choice(exclamations) - - def do_command(self, event, cmd, from_private): - """ - This is the function called whenever someone sends a public or - private message addressed to the bot. (e.g. "bot: blah"). - """ - - if event.eventtype() == "pubmsg": - target = None - else: - target = from_private.strip() - - try: - if cmd == 'help': - self.reply(self.helptext, target) - - elif cmd == 'lol': - self.reply(self.ponder(), target) - - elif cmd == 'urls' or cmd == 'list': - db = self.get_session() - for url in db.query(Url).order_by(Url.timestamp.desc())[:10]: - line = "%s %s" % (url.url, url.title) - self.reply(line, target) - time.sleep(1) - - elif cmd.startswith('urls ') or cmd.startswith('list '): - db = self.get_session() - (listcmd, n) = cmd.split(" ", 1) - n = n.strip() - if n == "all": - rows = db.query(Url).order_by(Url.timestamp.desc()) - elif n.find("-") > 0: - (x, y) = n.split("-", 1) - try: - x = abs(int(x)) - y = abs(int(y)) - if y < x: - x, y = y, x - except ValueError, ex: - self.reply("Give me a number or a range of numbers, e.g. list 5 or list 11-20", target) - raise ex - rows = db.query(Url).order_by(Url.timestamp.desc())[x-1:y] - else: - try: - n = abs(int(n)) - except ValueError, ex: - self.reply("Give me a number or a range of numbers, e.g. list 5 or list 11-20", target) - raise ex - rows = db.query(Url).order_by(Url.timestamp.desc())[:n] - - for url in rows: - line = "%s %s" % (url.url, url.title) - self.reply(line, target) - time.sleep(1) - - elif cmd.startswith('http:') or cmd.startswith('https:'): - title = self.save_url(from_private, cmd) - if title == False: - self.say_public("Sorry, I'm useless at UTF-8.") - else: - self.reply('URL added. %s' % title, target) - - else: - self.reply(self.exclaim(), target) - - except Exception, ex: - print "Exception caught processing command: %s" % ex - print " command was '%s' from %s" % (cmd, target) - self.reply("Sorry, I didn't understand: %s" % cmd, target) - self.reply(self.helptext, target) + config["irc.nickname"] = "lolbot" + return config def usage(): - print """Run a lolbot. + print """Run a lolbot. -h, --help This message. @@ -382,23 +414,11 @@ Configuration: """ if __name__ == "__main__": - try: - (options, args) = getopt.getopt(sys.argv[1:], "hc:", ["help", "config=", ]) - except getopt.GetoptError, err: - print str(err) - usage() - sys.exit(2) - - config_path = "" - for option,value in options: - if option in ("-h", "--help"): - usage() - sys.exit(2) - if option in ("-c", "--config"): - config_path = value - - try: - LolBot(config_path).start() - except KeyboardInterrupt: - print "Shutting down." + args = get_options() + config = get_config(args['config_path']) + try: + reactor.connectTCP(config['irc.server'], config['irc.port'], LolBotFactory(args['config_path'])) + reactor.run() + except KeyboardInterrupt: + print "Shutting down."