# Erebus IRC bot - Author: John Runyon
# "Bot" and "BotConnection" classes (handling a specific "arm")
-import socket, sys, time, threading, os, random, struct
+import os, random, socket, struct, sys, threading, time, traceback, fcntl
from collections import deque
if sys.version_info.major < 3:
#bots = {'erebus': bot.Bot(nick='Erebus', user='erebus', bind='', server='irc.quakenet.org', port=6667, realname='Erebus')}
class Bot(object):
def __init__(self, parent, nick, user, bind, authname, authpass, server, port, realname):
+ self.maxlen = 510
+
self.parent = parent
self.nick = nick
self.permnick = nick
self.slowmsgqueue = deque()
self._makemsgtimer()
self._msgtimer.start()
+ self.joined_chans = False
def __del__(self):
try:
def watchdog(self):
if time.time() > int(self.parent.cfg.get('watchdog', 'maxtime', default=300))+self.lastreceived:
self.parse("ERROR :Fake-error from watchdog timer.")
- self.watchdogtimer = MyTimer(int(self.parent.cfg.get('watchdog', 'interval', default=30)), self.watchdog)
+ return
+ if self.conn.registered():
+ self.conn.send("PING :%s" % (time.time()))
+ self._checknick()
+ watchdogtimer = MyTimer(int(self.parent.cfg.get('watchdog', 'interval', default=30)), self.watchdog)
+ watchdogtimer.start()
def log(self, *args, **kwargs):
self.parent.log(self.nick, *args, **kwargs)
def connect(self):
self.log('!', "Connecting")
if self.conn.connect():
+ self.log('!', "Connected")
self.parent.newfd(self, self.conn.socket.fileno())
def getdata(self):
- self.lastreceived = time.time()
- return self.conn.read()
+ try:
+ recvd = self.conn.read()
+ self.lastreceived = time.time()
+ return recvd
+ except EOFError as e:
+ return [":%s ERROR :%s%r" % (self.nick, e.__class__.__name__, e.args)]
def _checknick(self): # check if we're using the right nick, try changing
if self.nick != self.permnick and self.conn.registered():
self.conn.send("NICK %s" % (self.permnick))
def parse(self, line):
- if self.parent.cfg.getboolean('debug', 'io'):
- self.log('I', line)
pieces = line.split()
+ if pieces[0][0] == ":":
+ numeric = pieces[1]
+ else:
+ numeric = pieces[0]
+
# dispatch dict
- zero = { #things to look for without source
- 'NOTICE': self._gotconnected,
- 'PING': self._gotping,
- 'ERROR': self._goterror,
- }
- one = { #things to look for after source
+ dispatch = {
'NOTICE': self._gotconnected,
'001': self._got001,
'004': self._got004,
'354': self._got354, #WHO
'396': self._gotHiddenHost, # hidden host has been set
'433': self._got433, #nick in use
+ '437': self._got433, #nick protected
'JOIN': self._gotjoin,
'PART': self._gotpart,
'KICK': self._gotkick,
'QUIT': self._gotquit,
'NICK': self._gotnick,
'MODE': self._gotmode,
+ 'PING': self._gotping,
+ 'ERROR': self._goterror,
}
- if self.parent.hasnumhook(pieces[1]):
- hooks = self.parent.getnumhook(pieces[1])
+ if self.parent.hasnumhook(numeric):
+ hooks = self.parent.getnumhook(numeric)
for callback in hooks:
try:
callback(self, line)
except Exception:
- self.__debug_cbexception("numhook", line)
+ self._cbexception("numhook", line)
- if pieces[0] in zero:
- zero[pieces[0]](pieces)
- elif pieces[1] in one:
- one[pieces[1]](pieces)
+ if numeric in dispatch:
+ dispatch[numeric](pieces)
def _gotconnected(self, pieces):
if not self.conn.registered():
self._checknick()
def _goterror(self, pieces):
# TODO: better handling, just reconnect that single bot
+ error = ' '.join(pieces)
+ try:
+ raise Exception(error)
+ except Exception as e:
+ self.parent.mustquit = e
try:
- self.quit("Error detected: %s" % ' '.join(pieces))
+ self.quit("Error detected: %s" % (error))
except: pass
try:
curs = self.parent.query("UPDATE bots SET connected = 0")
curs.close()
except: pass
- sys.exit(2)
- os._exit(2)
+ self.log('!', 'Bot exiting due to: %s' % (error))
def _got001(self, pieces):
# We wait until the end of MOTD instead to consider ourselves registered, but consider uptime as of 001
self.connecttime = time.time()
self.conn.send("MODE %s +x" % (pieces[2]))
if self.authname is not None and self.authpass is not None:
- self.conn.send("AUTH %s %s" % (self.authname, self.authpass))
+ self.conn.send(self.parent.cfg.get('erebus', 'auth_command', "AUTH %s %s") % (self.authname, self.authpass))
if not self.parent.cfg.getboolean('erebus', 'wait_for_hidden_host'):
for c in self.chans:
self.join(c.name)
+ self.joined_chans = True
def _gotHiddenHost(self, pieces):
- if self.parent.cfg.getboolean('erebus', 'wait_for_hidden_host'):
+ if not self.joined_chans and self.parent.cfg.getboolean('erebus', 'wait_for_hidden_host'):
for c in self.chans:
self.join(c.name)
+ self.joined_chans = True
def _gotprivmsg(self, pieces):
nick = pieces[0].split('!')[0][1:]
user = self.parent.user(nick)
if nick == self.nick:
self.conn.send("WHO %s c%%cant,3" % (chan))
else:
- user = self.parent.user(nick, justjoined=True)
+ user = self.parent.user(nick, send_who=True)
chan.userjoin(user)
user.join(chan)
def _clientLeft(self, nick, chan):
- if nick != self.nick:
- gone = self.parent.user(nick).part(chan)
- chan.userpart(self.parent.user(nick))
+ if nick == self.nick:
+ for u in chan.users:
+ if u.nick != self.nick:
+ self._clientLeft(u.nick, chan)
+ if chan.deleting:
+ chan.bot.chans.remove(chan)
+ del self.parent.chans[chan.name.lower()]
+ del chan
+ else:
+ user = self.parent.user(nick)
+ gone = user.part(chan)
+ chan.userpart(user)
if gone:
- self.parent.user(nick).quit()
+ user.quit()
del self.parent.users[nick.lower()]
def _gotpart(self, pieces):
nick = pieces[0].split('!')[0][1:]
else:
pass # don't care about other modes
- def __debug_cbexception(self, source, *args, **kwargs):
+ def _cbexception(self, source, *args, chained=False, **kwargs):
+ if not chained: # skip hooks if we were caused by a hook
+ exc = sys.exception()
+ if self.parent.hasexceptionhook(exc):
+ for callback in self.parent.getexceptionhook(exc):
+ try:
+ callback(self, exc, source, *args, **kwargs)
+ except Exception:
+ self._cbexception('exceptionhook', chained=True, module=callback.__module__, function=callback.__name__, underlying=(source, args, kwargs))
if self.parent.cfg.getboolean('debug', 'cbexc'):
self.conn.send("PRIVMSG %s :%09.3f \ 34\1f!!! CBEXC\1f\ 3 %s" % (self.parent.cfg.get('debug', 'owner'), time.time() % 100000, source))
- __import__('traceback').print_exc()
+ traceback.print_exc(chain=not chained)
self.log('!', "CBEXC %s %r %r" % (source, args, kwargs))
-# print "%09.3f %s [!] CBEXC %s %r %r" % (time.time() % 100000, self.nick, source, args, kwargs)
def parsemsg(self, user, target, msg):
if len(msg) == 0:
return
- if target == self.nick:
- if msg.startswith("\001"): #ctcp
- msg = msg.strip("\001")
- if msg == "VERSION":
- self.msg(user, "\001VERSION Erebus v%d.%d - http://github.com/zonidjan/erebus" % (self.parent.APIVERSION, self.parent.RELEASE))
- return
+ if target == self.nick and msg.startswith("\001"): #ctcp
+ msg = msg.strip("\001")
+ if msg:
+ pieces = msg.split()
+ if pieces[0] == "CLIENTINFO":
+ self.msg(user, "\001CLIENTINFO VERSION PING\001")
+ elif pieces[0] == "VERSION":
+ self.msg(user, "\001VERSION Erebus v%d.%d - http://jfr.im/git/erebus.git\001" % (self.parent.APIVERSION, self.parent.RELEASE))
+ elif pieces[0] == "PING":
+ if len(pieces) > 1:
+ self.msg(user, "\001PING %s\001" % (' '.join(pieces[1:])))
+ else:
+ self.msg(user, "\001PING\001")
+ return
triggerused = msg.startswith(self.parent.trigger)
if triggerused: msg = msg[len(self.parent.trigger):]
self.reply(target, user, cbret)
except:
self.msg(user, "Command failed. Code: CBEXC%09.3f" % (time.time() % 100000))
- self.__debug_cbexception("chanhook", user=user, target=target, msg=msg)
+ self._cbexception("chanhook", user=user, target=target, msg=msg)
return # not to bot, don't process!
cmd = pieces[0].lower()
self.reply(target, user, cbret)
except Exception:
self.msg(user, "Command failed. Code: CBEXC%09.3f" % (time.time() % 100000))
- self.__debug_cbexception("hook", user=user, target=target, msg=msg)
+ self._cbexception("hook", user=user, target=target, msg=msg)
except SystemExit as e:
+ self.parent.mustquit = e
try:
curs = self.parent.query("UPDATE bots SET connected = 0")
curs.close()
self.conn.send("PRIVMSG %s :%09.3f \ 34\1f!!! NOMSG\1f\ 3 %r, %r" % (self.parent.cfg.get('debug', 'owner'), time.time() % 100000, target, msg))
self.log('!', "!!! NOMSG")
# print "%09.3f %s [!] %s" % (time.time() % 100000, self.nick, "!!! NOMSG")
- __import__('traceback').print_stack()
+ traceback.print_stack()
def reply(self, chan, user, msg):
In the case of fastmsg, self.conn.exceeded may be True, however, in this case append_callback=self.conn.send, so it will still be sent immediately.
"""
- def _msg(self, target, msg, truncate, append_callback):
- if self.parent.cfg.getboolean('erebus', 'nofakelag'): return self.fastmsg(target, msg)
+ def _msg(self, target, msg, truncate, append_callback, msgtype):
+ if self.parent.cfg.getboolean('erebus', 'nofakelag'): append_callback = self.conn.send
- cmd = self._formatmsg(target, msg)
- # The max length is much shorter than recvq (510) because of the length the server adds on about the source (us).
+ cmd = self._formatmsg(target, msg, msgtype)
+ # The max length is much shorter than conn.maxlen (510) because of the length the server adds on about the source (us).
# If you know your hostmask, you can of course figure the exact length, but it's very difficult to reliably know your hostmask.
- maxlen = (
- self.conn.recvq
- - 63 # max hostname len
- - 11 # max ident len
- - 3 # the symbols in :nick!user@host
- - len(self.nick)
- )
+ maxlen = self.maxmsglen()
if len(cmd) > maxlen:
if not truncate:
return False
self.conn.exceeded = True
return True
- def msg(self, target, msg, truncate=False):
- return self._msg(target, msg, truncate, self.msgqueue.append)
+ def msg(self, target, msg, truncate=False, *, msgtype=None):
+ """msgtype must be a valid IRC command, i.e. NOTICE or PRIVMSG; or leave as None to use default"""
+ return self._msg(target, msg, truncate, self.msgqueue.append, msgtype)
- def slowmsg(self, target, msg, truncate=False):
- return self._msg(target, msg, truncate, self.slowmsgqueue.append)
+ def slowmsg(self, target, msg, truncate=False, *, msgtype=None):
+ return self._msg(target, msg, truncate, self.slowmsgqueue.append, msgtype)
- def fastmsg(self, target, msg, truncate=False):
- return self._msg(target, msg, truncate, self.conn.send)
+ def fastmsg(self, target, msg, truncate=False, *, msgtype=None):
+ return self._msg(target, msg, truncate, self.conn.send, msgtype)
- def _formatmsg(self, target, msg):
+ def _formatmsg(self, target, msg, msgtype):
if target is None or msg is None:
return self.__debug_nomsg(target, msg)
target = str(target)
- if target.startswith('#'): command = "PRIVMSG %s :%s" % (target, msg)
+ if msgtype is not None: command = "%s %s :%s" % (msgtype, target, msg)
+ elif target.startswith('#'): command = "PRIVMSG %s :%s" % (target, msg)
else: command = "NOTICE %s :%s" % (target, msg)
return command
def quit(self, reason="Shutdown"):
self.conn.send("QUIT :%s" % (reason))
+ def maxmsglen(self):
+ return (
+ self.maxlen
+ - 63 # max hostname len
+ - 11 # max ident len
+ - 3 # the symbols in :nick!user@host
+ - len(self.nick)
+ )
+
def __str__(self): return self.nick
def __repr__(self): return "<Bot %r>" % (self.nick)
self.state = 0 # 0=disconnected, 1=registering, 2=connected
self.bytessent = 0
- self.recvq = 510
+ self.recvq = 510 # How much we can send per period
self.exceeded = False
self._nowrite = False
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 0, 0))
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
self.socket.bind((self.bind, 0))
+ self._write_oidentd()
self.socket.connect((self.server, self.port))
return True
def register(self):
if self.state == 0:
+ pss = self.parent.parent.cfg.get('erebus', 'pass')
+ if pss:
+ self.send("PASS %s" % (pss))
self.send("NICK %s" % (self.parent.nick))
self.send("USER %s 0 * :%s" % (self.parent.user, self.parent.realname))
self.state = 1
return True
def registered(self, done=False):
- if done: self.state = 2
+ if done:
+ self.state = 2
+ self._unwrite_oidentd()
return self.state == 2
def send(self, line):
self.parent.log('X', line)
def _write(self, line):
- self.socket.sendall(line.encode('utf-8', 'backslashreplace')+b"\r\n")
+ self.socket.sendall(line.encode('utf-8', 'surrogateescape')+b"\r\n")
+
+ def _getsockerr(self):
+ try: # SO_ERROR might not exist on all platforms
+ return self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
+ except:
+ return None
def read(self):
- self.buffer += self.socket.recv(8192)
+ recvd = self.socket.recv(8192)
+ if recvd == b"":
+ raise EOFError("socket.recv returned empty", self.parent.nick, self._getsockerr())
+ self.buffer += recvd
lines = []
while b"\r\n" in self.buffer:
return lines
+ def _format_oidentd(self):
+ ident = self.parent.user
+ fport = self.parent.port
+ from_ = self.bind
+ lport = self.socket.getsockname()[1]
+ if from_:
+ return 'fport %s from %s lport %s { reply "%s" }\n' % (fport, from_, lport, ident)
+ else:
+ return 'fport %s lport %s { reply "%s" }\n' % (fport, lport, ident)
+ def _write_oidentd(self):
+ path = self.parent.parent.cfg.get('erebus', 'oidentd_path')
+ if path is not None:
+ with open(path, 'a') as fh:
+ fcntl.lockf(fh, fcntl.LOCK_EX)
+ fh.write(self._format_oidentd())
+ fcntl.lockf(fh, fcntl.LOCK_UN)
+ def _unwrite_oidentd(self):
+ path = self.parent.parent.cfg.get('erebus', 'oidentd_path')
+ if path is not None:
+ with open(path, 'r+') as fh:
+ fcntl.lockf(fh, fcntl.LOCK_EX)
+ data = fh.read()
+ newdata = data.replace(self._format_oidentd(), '')
+ fh.seek(0)
+ fh.write(newdata)
+ fh.truncate()
+ fcntl.lockf(fh, fcntl.LOCK_UN)
+
def __str__(self): return self.parent.nick
def __repr__(self): return "<BotConnection %r (%r)>" % (self.socket.fileno(), self.parent.nick)
projects / erebus.git / blobdiff