707 lines
27 KiB
Python
707 lines
27 KiB
Python
from twisted.internet.protocol import ReconnectingClientFactory
|
|
from twisted.words.protocols.irc import IRCClient
|
|
from twisted.internet.defer import Deferred
|
|
from twisted.internet.task import LoopingCall
|
|
from twisted.internet import reactor, task
|
|
from twisted.words.protocols.irc import symbolic_to_numeric, numeric_to_symbolic, lowDequote, IRCBadMessage
|
|
|
|
import sys
|
|
from string import digits
|
|
from random import randint
|
|
from copy import deepcopy
|
|
|
|
from modules import userinfo
|
|
from modules import counters
|
|
from modules import monitor
|
|
from modules import chankeep
|
|
|
|
from core.relay import sendRelayNotification
|
|
from utils.dedup import dedup
|
|
from utils.get import getRelay
|
|
|
|
import main
|
|
from utils.logging.log import *
|
|
from utils.logging.debug import *
|
|
from utils.logging.send import *
|
|
from utils.parsing import parsen
|
|
|
|
from twisted.internet.ssl import DefaultOpenSSLContextFactory
|
|
|
|
def deliverRelayCommands(num, relayCommands, user=None, stage2=None):
|
|
keyFN = main.certPath+main.config["Key"]
|
|
certFN = main.certPath+main.config["Certificate"]
|
|
contextFactory = DefaultOpenSSLContextFactory(keyFN.encode("utf-8", "replace"),
|
|
certFN.encode("utf-8", "replace"))
|
|
bot = IRCBotFactory(net=None, num=num, relayCommands=relayCommands, user=user, stage2=stage2)
|
|
host, port = getRelay(num)
|
|
rct = reactor.connectSSL(host,
|
|
port,
|
|
bot, contextFactory)
|
|
|
|
def parsemsg(s):
|
|
"""
|
|
Breaks a message from an IRC server into its prefix, command, and
|
|
arguments.
|
|
@param s: The message to break.
|
|
@type s: L{bytes}
|
|
@return: A tuple of (prefix, command, args).
|
|
@rtype: L{tuple}
|
|
"""
|
|
prefix = ''
|
|
trailing = []
|
|
if not s:
|
|
raise IRCBadMessage("Empty line.")
|
|
if s[0:1] == ':':
|
|
prefix, s = s[1:].split(' ', 1)
|
|
if s.find(' :') != -1:
|
|
s, trailing = s.split(' :', 1)
|
|
args = s.split(' ')
|
|
args.append(trailing)
|
|
else:
|
|
args = s.split(' ')
|
|
command = args.pop(0)
|
|
return prefix, command, args
|
|
|
|
class IRCRelay(IRCClient):
|
|
def __init__(self, num, relayCommands, user, stage2):
|
|
self.isconnected = False
|
|
self.buffer = ""
|
|
if user == None:
|
|
self.user = main.config["Relay"]["User"]
|
|
else:
|
|
self.user = user
|
|
password = main.config["Relay"]["Password"]
|
|
self.nickname = "relay"
|
|
self.realname = "relay"
|
|
self.username = self.user
|
|
self.password = self.user+":"+password
|
|
|
|
self.relayCommands = relayCommands
|
|
self.num = num
|
|
self.stage2 = stage2
|
|
self.loop = None
|
|
|
|
def privmsg(self, user, channel, msg):
|
|
nick, ident, host = parsen(user)
|
|
for i in main.ZNCErrors:
|
|
if i in msg:
|
|
error("ZNC issue:", msg)
|
|
if nick[0] == main.config["Tweaks"]["ZNC"]["Prefix"]:
|
|
nick = nick[1:]
|
|
if nick in self.relayCommands.keys():
|
|
sendAll("[%s] %s -> %s" % (self.num, nick, msg))
|
|
|
|
def irc_ERR_PASSWDMISMATCH(self, prefix, params):
|
|
log("%s: relay password mismatch" % self.num)
|
|
sendAll("%s: relay password mismatch" % self.num)
|
|
|
|
def sendStage2(self):
|
|
if not self.stage2 == None: # [["user", {"sasl": ["message1", "message2"]}], []]
|
|
if not len(self.stage2) == 0:
|
|
user = self.stage2[0].pop(0)
|
|
commands = self.stage2[0].pop(0)
|
|
del self.stage2[0]
|
|
deliverRelayCommands(self.num, commands, user, self.stage2)
|
|
|
|
def signedOn(self):
|
|
if not self.isconnected:
|
|
self.isconnected = True
|
|
log("signed on as a relay: %s" % self.num)
|
|
#sendRelayNotification("Relay", {"type": "conn", "status": "connected"}) nobody actually cares
|
|
sleeptime = 0
|
|
increment = 0.8
|
|
for i in self.relayCommands.keys():
|
|
for x in self.relayCommands[i]:
|
|
reactor.callLater(sleeptime, self.msg, main.config["Tweaks"]["ZNC"]["Prefix"]+i, x)
|
|
sleeptime += increment
|
|
increment += 0.8
|
|
reactor.callLater(sleeptime, self.sendStage2)
|
|
reactor.callLater(sleeptime+5, self.transport.loseConnection)
|
|
return
|
|
|
|
class IRCBot(IRCClient):
|
|
def __init__(self, net, num):
|
|
self.isconnected = False
|
|
self.channels = []
|
|
self.net = net
|
|
self.num = num
|
|
self.buffer = ""
|
|
self.name = net + str(num)
|
|
alias = main.alias[num]
|
|
relay = main.network[self.net].relays[num]
|
|
self.nickname = alias["nick"]
|
|
self.realname = alias["realname"]
|
|
self.username = alias["nick"]+"/"+relay["net"]
|
|
self.password = main.config["Relay"]["Password"]
|
|
self.userinfo = None #
|
|
self.fingerReply = None #
|
|
self.versionName = None # don't tell anyone information about us
|
|
self.versionNum = None #
|
|
self.versionEnv = None #
|
|
self.sourceURL = None #
|
|
|
|
self._getWho = {} # LoopingCall objects -- needed to be able to stop them
|
|
|
|
self._tempWho = {} # temporary storage for gathering WHO info
|
|
self._tempNames = {} # temporary storage for gathering NAMES info
|
|
self._tempList = ([], []) # temporary storage for gathering LIST info
|
|
self.listOngoing = False # we are currently receiving a LIST
|
|
self.listRetried = False # we asked and got nothing so asked again
|
|
self.listAttempted = False # we asked for a list
|
|
self.listSimple = False # after asking again we got the list, so use the simple
|
|
# syntax from now on
|
|
self.wantList = False # we want to send a LIST, but not all relays are active yet
|
|
self.chanlimit = 0
|
|
self.servername = None
|
|
|
|
def lineReceived(self, line):
|
|
if bytes != str and isinstance(line, bytes):
|
|
# decode bytes from transport to unicode
|
|
line = line.decode("utf-8", "replace")
|
|
|
|
line = lowDequote(line)
|
|
try:
|
|
prefix, command, params = parsemsg(line)
|
|
if command in numeric_to_symbolic:
|
|
command = numeric_to_symbolic[command]
|
|
self.handleCommand(command, prefix, params)
|
|
except IRCBadMessage:
|
|
self.badMessage(line, *sys.exc_info())
|
|
|
|
def joinChannels(self, channels):
|
|
sleeptime = 0.0
|
|
increment = 0.8
|
|
for i in channels:
|
|
if not i in self.channels:
|
|
debug(self.net, "-", self.num, ": joining", i, "in", sleeptime, "seconds")
|
|
reactor.callLater(sleeptime, self.join, i)
|
|
sleeptime += increment
|
|
if sleeptime == 10:
|
|
sleeptime = 0.0
|
|
increment = 0.7
|
|
increment += 0.1
|
|
else:
|
|
error("%s - %i - Cannot join channel we are already on - %s" % (self.net, self.num, i))
|
|
|
|
def checkChannels(self):
|
|
if self.net in main.TempChan.keys():
|
|
if self.num in main.TempChan[self.net].keys():
|
|
self.joinChannels(main.TempChan[self.net][self.num])
|
|
del main.TempChan[self.net][self.num]
|
|
if not main.TempChan[self.net]:
|
|
del main.TempChan[self.net]
|
|
|
|
def event(self, **cast):
|
|
for i in list(cast.keys()): # Make a copy of the .keys() as Python 3 cannot handle iterating over
|
|
if cast[i] == "": # a dictionary that changes length with each iteration
|
|
del cast[i]
|
|
if "muser" in cast.keys():
|
|
if cast["muser"] == self.servername:
|
|
return
|
|
if "channel" in cast.keys():
|
|
if cast["channel"] == "*":
|
|
return
|
|
if not {"nick", "ident", "host"}.issubset(set(cast.keys())):
|
|
cast["nick"], cast["ident"], cast["host"] = parsen(cast["muser"])
|
|
if set(["nick", "ident", "host", "msg"]).issubset(set(cast)):
|
|
if "msg" in cast.keys():
|
|
if cast["ident"] == "znc" and cast["host"] == "znc.in":
|
|
cast["type"] = "znc"
|
|
cast["num"] = self.num
|
|
del cast["nick"]
|
|
del cast["ident"]
|
|
del cast["host"]
|
|
del cast["channel"]
|
|
if "Disconnected from IRC" in cast["msg"]:
|
|
log("ZNC disconnected on %s - %i" % (self.net, self.num))
|
|
self.isconnected = False
|
|
if "Connected!" in cast["msg"]:
|
|
log("ZNC connected on %s - %i" % (self.net, self.num))
|
|
self.isconnected = True
|
|
if not cast["type"] in ["query", "self", "highlight", "znc", "who"]:
|
|
if "channel" in cast.keys() and not cast["type"] == "mode": # don't handle modes here
|
|
if cast["channel"].lower() == self.nickname.lower(): # as they are channel == nickname
|
|
#castDup = deepcopy(cast) # however modes are not queries!
|
|
cast["mtype"] = cast["type"]
|
|
cast["type"] = "query"
|
|
cast["num"] = self.num
|
|
#self.event(**castDup)
|
|
# Don't call self.event for this one because queries are not events on a
|
|
# channel, but we still want to see them
|
|
if "user" in cast.keys():
|
|
if cast["user"].lower() == self.nickname.lower():
|
|
castDup = deepcopy(cast)
|
|
castDup["mtype"] = cast["type"]
|
|
castDup["type"] = "self"
|
|
cast["num"] = self.num
|
|
self.event(**castDup)
|
|
if "nick" in cast.keys():
|
|
if cast["nick"].lower() == self.nickname.lower():
|
|
castDup = deepcopy(cast)
|
|
castDup["mtype"] = cast["type"]
|
|
castDup["type"] = "self"
|
|
cast["num"] = self.num
|
|
if not cast["channel"].lower() == self.nickname.lower(): # modes has been set on us directly
|
|
self.event(**castDup) # don't tell anyone else
|
|
if "msg" in cast.keys() and not cast["type"] == "query": # Don't highlight queries
|
|
if not cast["msg"] == None:
|
|
if self.nickname.lower() in cast["msg"].lower():
|
|
castDup = deepcopy(cast)
|
|
castDup["mtype"] = cast["type"]
|
|
castDup["type"] = "highlight"
|
|
cast["num"] = self.num
|
|
self.event(**castDup)
|
|
|
|
if not "net" in cast.keys():
|
|
cast["net"] = self.net
|
|
counters.event(self.net, cast["type"])
|
|
monitor.event(self.net, cast)
|
|
|
|
def privmsg(self, user, channel, msg):
|
|
self.event(type="msg", muser=user, channel=channel, msg=msg)
|
|
|
|
def noticed(self, user, channel, msg):
|
|
self.event(type="notice", muser=user, channel=channel, msg=msg)
|
|
|
|
def action(self, user, channel, msg):
|
|
self.event(type="action", muser=user, channel=channel, msg=msg)
|
|
|
|
def get(self, var):
|
|
try:
|
|
result = getattr(self, var)
|
|
except AttributeError:
|
|
result = None
|
|
return result
|
|
|
|
def setNick(self, nickname):
|
|
self._attemptedNick = nickname
|
|
self.sendLine("NICK %s" % nickname)
|
|
self.nickname = nickname
|
|
|
|
def alterCollidedNick(self, nickname):
|
|
newnick = nickname + "_"
|
|
return newnick
|
|
|
|
def nickChanged(self, olduser, newnick):
|
|
self.nickname = newnick
|
|
self.event(type="self", mtype="nick", muser=olduser, user=newnick)
|
|
|
|
def irc_ERR_NICKNAMEINUSE(self, prefix, params):
|
|
self._attemptedNick = self.alterCollidedNick(self._attemptedNick)
|
|
self.setNick(self._attemptedNick)
|
|
|
|
def irc_ERR_PASSWDMISMATCH(self, prefix, params):
|
|
log("%s - %i: password mismatch" % (self.net, self.num))
|
|
sendAll("%s - %i: password mismatch" % (self.net, self.num))
|
|
|
|
def _who(self, channel):
|
|
d = Deferred()
|
|
if channel not in self._tempWho:
|
|
self._tempWho[channel] = ([], [])
|
|
self._tempWho[channel][0].append(d)
|
|
self.sendLine("WHO %s" % channel)
|
|
return d
|
|
|
|
def who(self, channel):
|
|
self._who(channel).addCallback(self.got_who)
|
|
|
|
def irc_RPL_WHOREPLY(self, prefix, params):
|
|
channel = params[1]
|
|
ident = params[2]
|
|
host = params[3]
|
|
server = params[4]
|
|
nick = params[5]
|
|
status = params[6]
|
|
realname = params[7]
|
|
if channel not in self._tempWho:
|
|
return
|
|
n = self._tempWho[channel][1]
|
|
n.append([nick, nick, host, server, status, realname])
|
|
self.event(type="who", nick=nick, ident=ident, host=host, realname=realname, channel=channel, server=server, status=status)
|
|
|
|
def irc_RPL_ENDOFWHO(self, prefix, params):
|
|
channel = params[1]
|
|
if channel not in self._tempWho:
|
|
return
|
|
callbacks, info = self._tempWho[channel]
|
|
for cb in callbacks:
|
|
cb.callback((channel, info))
|
|
del self._tempWho[channel]
|
|
|
|
def got_who(self, whoinfo):
|
|
userinfo.initialUsers(self.net, whoinfo[0], whoinfo[1])
|
|
|
|
def sanit(self, data):
|
|
if len(data) >= 1:
|
|
if data[0] in ["!", "~", "&", "@", "%", "+"]:
|
|
data = data[1:]
|
|
return data
|
|
return data
|
|
else:
|
|
return False
|
|
|
|
def names(self, channel):
|
|
d = Deferred()
|
|
if channel not in self._tempNames:
|
|
self._tempNames[channel] = ([], [])
|
|
self._tempNames[channel][0].append(d)
|
|
self.sendLine("NAMES %s" % channel)
|
|
return d
|
|
|
|
def irc_RPL_NAMREPLY(self, prefix, params):
|
|
channel = params[2]
|
|
nicklist = params[3].split(' ')
|
|
if channel not in self._tempNames:
|
|
return
|
|
n = self._tempNames[channel][1]
|
|
n.append(nicklist)
|
|
|
|
def irc_RPL_ENDOFNAMES(self, prefix, params):
|
|
channel = params[1]
|
|
if channel not in self._tempNames:
|
|
return
|
|
callbacks, namelist = self._tempNames[channel]
|
|
for cb in callbacks:
|
|
cb.callback((channel, namelist))
|
|
del self._tempNames[channel]
|
|
|
|
def got_names(self, nicklist):
|
|
newNicklist = []
|
|
for i in nicklist[1]:
|
|
for x in i:
|
|
f = self.sanit(x) # need to store this as well, or potentially just do not remove it...
|
|
if f:
|
|
newNicklist.append(f)
|
|
userinfo.initialNames(self.net, nicklist[0], newNicklist)
|
|
|
|
def myInfo(self, servername, version, umodes, cmodes):
|
|
self.servername = servername
|
|
|
|
def _list(self, noargs):
|
|
d = Deferred()
|
|
self._tempList = ([], [])
|
|
self._tempList[0].append(d)
|
|
if self.listSimple:
|
|
self.sendLine("LIST")
|
|
return d # return early if we know what to do
|
|
|
|
if noargs:
|
|
self.sendLine("LIST")
|
|
else:
|
|
self.sendLine("LIST >0")
|
|
return d
|
|
|
|
def list(self, noargs=False, nocheck=False):
|
|
if self.listAttempted:
|
|
debug("List request dropped, already asked for LIST - %s - %i" % (self.net, self.num))
|
|
return
|
|
else:
|
|
self.listAttempted = True
|
|
if self.listOngoing:
|
|
debug("LIST request dropped, already ongoing - %s - %i" % (self.net, self.num))
|
|
return
|
|
else:
|
|
if nocheck:
|
|
allRelays = True # override the system - if this is
|
|
else: # specified, we already did this
|
|
allRelays = chankeep.allRelaysActive(self.net)
|
|
if not allRelays:
|
|
self.wantList = True
|
|
debug("Not all relays were active for LIST request")
|
|
return
|
|
self._list(noargs).addCallback(self.got_list)
|
|
|
|
def irc_RPL_LISTSTART(self, prefix, params):
|
|
self.listAttempted = False
|
|
self.listOngoing = True
|
|
self.wantList = False
|
|
|
|
def irc_RPL_LIST(self, prefix, params):
|
|
channel = params[1]
|
|
users = params[2]
|
|
topic = params[3]
|
|
self._tempList[1].append([channel, users, topic])
|
|
|
|
def irc_RPL_LISTEND(self, prefix, params):
|
|
if not len(self._tempList[0]) > 0: # there are no callbacks, can't do anything there
|
|
debug("We didn't ask for this LIST, discarding")
|
|
self._tempList[0].clear()
|
|
self._tempList[1].clear()
|
|
return
|
|
callbacks, info = self._tempList
|
|
self.listOngoing = False
|
|
for cb in callbacks:
|
|
cb.callback((info))
|
|
noResults = False
|
|
if len(self._tempList[1]) == 0:
|
|
noResults = True
|
|
self._tempList[0].clear()
|
|
self._tempList[1].clear()
|
|
if noResults:
|
|
if self.listRetried:
|
|
warn("LIST still empty after retry: %s - %i" % (net, num))
|
|
self.listRetried = False
|
|
return
|
|
else:
|
|
self.list(True)
|
|
self.listRetried = True
|
|
else:
|
|
if self.listRetried:
|
|
self.listRetried = False
|
|
debug("List received after retry - defaulting to simple list syntax")
|
|
self.listSimple = True
|
|
|
|
def got_list(self, listinfo):
|
|
if len(listinfo) == 0: # probably ngircd not supporting LIST >0
|
|
return
|
|
chankeep.initialList(self.net, self.num, listinfo, self.chanlimit)
|
|
|
|
def isupport(self, options):
|
|
interested = ("CHANLIMIT", "MAXCHANNELS")
|
|
if not any((x for x in options if any(y in x for y in interested))):
|
|
return # check if any of interested is in any of options, some networks
|
|
chanlimit = None # call isupport() more than once, so discard swiftly anything
|
|
if not self.isconnected: # we don't care about
|
|
log("endpoint connected: %s - %i" % (self.net, self.num))
|
|
self.isconnected = True
|
|
for i in options:
|
|
if i.startswith("CHANLIMIT"):
|
|
if ":" in i:
|
|
split = i.split(":")
|
|
if len(split) >= 2:
|
|
chanlimit = split[1]
|
|
break
|
|
elif i.startswith("MAXCHANNELS"):
|
|
if "=" in i:
|
|
split = i.split("=")
|
|
if len(split) == 2:
|
|
chanlimit = split[1]
|
|
break
|
|
print("chanlimit", chanlimit)
|
|
try:
|
|
self.chanlimit = int(chanlimit)
|
|
except TypeError:
|
|
warn("Invalid chanlimit: %s" % i)
|
|
if self.chanlimit == 0:
|
|
self.chanlimit = 200 # don't take the piss if it's unlimited
|
|
allRelays = chankeep.allRelaysActive(self.net)
|
|
print(self.net, self.num, allRelays)
|
|
if allRelays:
|
|
for i in main.network.keys():
|
|
for x in main.network[i].relays.keys():
|
|
name = i+str(x)
|
|
if main.IRCPool[name].wantList == True:
|
|
main.IRCPool[name].list(nocheck=True)
|
|
debug("Asking for a list for %s after final relay %i connected" % (self.net, self.num))
|
|
if self.num == 1: # Only one instance should do a list
|
|
if self.chanlimit:
|
|
if allRelays:
|
|
self.list()
|
|
else:
|
|
self.wantList = True
|
|
else:
|
|
debug("Aborting LIST due to bad chanlimit")
|
|
self.checkChannels()
|
|
|
|
#twisted sucks so i have to do this to actually get the user info
|
|
def irc_JOIN(self, prefix, params):
|
|
"""
|
|
Called when a user joins a channel.
|
|
"""
|
|
nick = prefix.split('!')[0]
|
|
channel = params[-1]
|
|
if nick == self.nickname:
|
|
self.joined(channel)
|
|
else:
|
|
self.userJoined(prefix, channel)
|
|
|
|
def irc_PART(self, prefix, params):
|
|
"""
|
|
Called when a user leaves a channel.
|
|
"""
|
|
nick = prefix.split('!')[0]
|
|
channel = params[0]
|
|
if len(params) >= 2:
|
|
message = params[1]
|
|
else:
|
|
message = None
|
|
if nick == self.nickname:
|
|
self.left(prefix, channel, message)
|
|
else:
|
|
self.userLeft(prefix, channel, message)
|
|
|
|
def irc_QUIT(self, prefix, params):
|
|
"""
|
|
Called when a user has quit.
|
|
"""
|
|
nick = prefix.split('!')[0]
|
|
#if nick == self.nickname:
|
|
#self.botQuit(prefix, params[0])
|
|
#else:
|
|
self.userQuit(prefix, params[0])
|
|
|
|
def irc_NICK(self, prefix, params):
|
|
"""
|
|
Called when a user changes their nickname.
|
|
"""
|
|
nick = prefix.split('!', 1)[0]
|
|
if nick == self.nickname:
|
|
self.nickChanged(prefix, params[0])
|
|
else:
|
|
self.userRenamed(prefix, params[0])
|
|
|
|
def irc_KICK(self, prefix, params):
|
|
"""
|
|
Called when a user is kicked from a channel.
|
|
"""
|
|
#kicker = prefix.split('!')[0]
|
|
channel = params[0]
|
|
kicked = params[1]
|
|
message = params[-1]
|
|
# Checks on whether it was us that was kicked are done in userKicked
|
|
self.userKicked(kicked, channel, prefix, message)
|
|
|
|
def irc_TOPIC(self, prefix, params):
|
|
"""
|
|
Someone in the channel set the topic.
|
|
"""
|
|
#user = prefix.split('!')[0]
|
|
channel = params[0]
|
|
newtopic = params[1]
|
|
self.topicUpdated(prefix, channel, newtopic)
|
|
#END hacks
|
|
|
|
def signedOn(self):
|
|
log("signed on: %s - %i" % (self.net, self.num))
|
|
#self.event(type="conn", status="connected")
|
|
sendRelayNotification({"type": "conn", "net": self.net, "num": self.num, "status": "signedon"})
|
|
|
|
def joined(self, channel):
|
|
if not channel in self.channels:
|
|
self.channels.append(channel)
|
|
self.names(channel).addCallback(self.got_names)
|
|
if main.config["Toggles"]["Who"]:
|
|
#self.who(channel).addCallback(self.got_who)
|
|
#self.who(channel)
|
|
lc = LoopingCall(self.who, channel)
|
|
self._getWho[channel] = lc
|
|
intrange = main.config["Tweaks"]["Delays"]["WhoRange"]
|
|
minint = main.config["Tweaks"]["Delays"]["WhoLoop"]
|
|
interval = randint(minint, minint+intrange)
|
|
lc.start(interval)
|
|
|
|
def botLeft(self, channel):
|
|
if channel in self.channels:
|
|
self.channels.remove(channel)
|
|
if channel in self._getWho.keys():
|
|
lc = self._getWho[channel]
|
|
lc.stop()
|
|
del self._getWho[channel]
|
|
userinfo.delChannels(self.net, [channel]) # < we do not need to deduplicate this
|
|
#log("Can no longer cover %s, removing records" % channel)# as it will only be matched once --
|
|
# other bots have different nicknames so
|
|
def left(self, user, channel, message): # even if they saw it, they wouldn't react
|
|
self.event(type="part", muser=user, channel=channel, message=message)
|
|
self.botLeft(channel)
|
|
|
|
def userJoined(self, user, channel):
|
|
self.event(type="join", muser=user, channel=channel)
|
|
|
|
def userLeft(self, user, channel, message):
|
|
self.event(type="part", muser=user, channel=channel, message=message)
|
|
|
|
def userQuit(self, user, quitMessage):
|
|
self.chanlessEvent({"type": "quit", "muser": user, "message": quitMessage})
|
|
|
|
def userKicked(self, kickee, channel, kicker, message):
|
|
if kickee.lower() == self.nickname.lower():
|
|
self.botLeft(channel)
|
|
self.event(type="kick", muser=kicker, channel=channel, message=message, user=kickee)
|
|
|
|
def chanlessEvent(self, cast):
|
|
cast["nick"], cast["ident"], cast["host"] = parsen(cast["muser"])
|
|
if dedup(self.name, cast): # Needs to be kept self.name until the dedup
|
|
# function is converted to the new net, num
|
|
# format
|
|
return # stop right there sir!
|
|
chans = userinfo.getChanList(self.net, cast["nick"])
|
|
if chans == None:
|
|
error("No channels returned for chanless event: %s" % cast)
|
|
# self.event(**cast) -- no, should NEVER happen
|
|
return
|
|
# getChansSingle returns all channels of the user, we only want to use
|
|
# ones we have common with them
|
|
realChans = set(chans).intersection(set(self.channels))
|
|
for i in realChans:
|
|
cast["channel"] = i
|
|
self.event(**cast)
|
|
|
|
def userRenamed(self, oldname, newname):
|
|
self.chanlessEvent({"type": "nick", "muser": oldname, "user": newname})
|
|
|
|
def topicUpdated(self, user, channel, newTopic):
|
|
self.event(type="topic", muser=user, channel=channel, message= newTopic)
|
|
|
|
def modeChanged(self, user, channel, toset, modes, args):
|
|
argList = list(args)
|
|
modeList = [i for i in modes]
|
|
for a, m in zip(argList, modeList):
|
|
self.event(type="mode", muser=user, channel=channel, modes=m, status=toset, modeargs=a)
|
|
|
|
class IRCBotFactory(ReconnectingClientFactory):
|
|
def __init__(self, net, num=None, relayCommands=None, user=None, stage2=None):
|
|
if net == None:
|
|
self.num = num
|
|
self.net = None
|
|
self.name = "relay - %i" % num
|
|
self.relay = True
|
|
else:
|
|
self.name = net+str(num)
|
|
self.num = num
|
|
self.net = net
|
|
self.relay = False
|
|
self.client = None
|
|
self.maxDelay = main.config["Tweaks"]["Delays"]["MaxDelay"]
|
|
self.initialDelay = main.config["Tweaks"]["Delays"]["InitialDelay"]
|
|
self.factor = main.config["Tweaks"]["Delays"]["Factor"]
|
|
self.jitter = main.config["Tweaks"]["Delays"]["Jitter"]
|
|
|
|
self.relayCommands, self.user, self.stage2 = relayCommands, user, stage2
|
|
|
|
def buildProtocol(self, addr):
|
|
if self.relay == False:
|
|
entry = IRCBot(self.net, self.num)
|
|
main.IRCPool[self.name] = entry
|
|
else:
|
|
entry = IRCRelay(self.num, self.relayCommands, self.user, self.stage2)
|
|
|
|
self.client = entry
|
|
return entry
|
|
|
|
def clientConnectionLost(self, connector, reason):
|
|
if not self.relay:
|
|
userinfo.delChannels(self.net, self.client.channels)
|
|
if not self.client == None:
|
|
self.client.isconnected = False
|
|
self.client.channels = []
|
|
error = reason.getErrorMessage()
|
|
log("%s - %i: connection lost: %s" % (self.net, self.num, error))
|
|
if not self.relay:
|
|
sendAll("%s - %i: connection lost: %s" % (self.net, self.num, error))
|
|
sendRelayNotification({"type": "conn", "net": self.net, "num": self.num, "status": "lost", "message": error})
|
|
self.retry(connector)
|
|
#ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
|
|
|
|
def clientConnectionFailed(self, connector, reason):
|
|
if not self.client == None:
|
|
self.client.isconnected = False
|
|
self.client.channels = []
|
|
error = reason.getErrorMessage()
|
|
log("%s - %i: connection failed: %s" % (self.net, self.num, error))
|
|
if not self.relay:
|
|
sendAll("%s -%s: connection failed: %s" % (self.net, self.num, error))
|
|
sendRelayNotification({"type": "conn", "net": self.net, "num": self.num, "status": "failed", "message": error})
|
|
self.retry(connector)
|
|
#ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)
|
|
|