pesterchum/irc.py

698 lines
27 KiB
Python
Raw Normal View History

import logging
import logging.config
2011-02-15 12:10:57 -05:00
import socket
import random
from time import time
from PyQt5 import QtCore, QtGui
import ostools
from mood import Mood
from dataobjs import PesterProfile
from generic import PesterList
2011-05-26 03:40:30 -04:00
from version import _pcVersion
from oyoyo.client import IRCClient
from oyoyo.cmdhandler import DefaultCommandHandler
from oyoyo import helpers, services
_datadir = ostools.getDataDir()
logging.config.fileConfig(_datadir + "logging.ini")
PchumLog = logging.getLogger('pchumLogger')
# Python 3
QString = str
2021-03-23 17:36:43 -04:00
2021-08-24 11:32:47 -04:00
#if ostools.isOSXBundle():
# logging.basicConfig(level=logging.WARNING)
#else:
# # karxi; We do NOT need this set to INFO; it's very, very spammy.
# logging.basicConfig(level=logging.WARNING)
2011-02-19 18:06:54 -05:00
class PesterIRC(QtCore.QThread):
def __init__(self, config, window):
2011-02-19 18:06:54 -05:00
QtCore.QThread.__init__(self)
self.mainwindow = window
2011-02-13 21:01:58 -05:00
self.config = config
2011-02-21 14:07:59 -05:00
self.registeredIRC = False
self.stopIRC = None
2011-09-28 19:16:01 -04:00
self.NickServ = services.NickServ()
self.ChanServ = services.ChanServ()
def IRCConnect(self):
server = self.config.server()
2011-02-15 12:10:57 -05:00
port = self.config.port()
self.cli = IRCClient(PesterHandler, host=server, port=int(port), nick=self.mainwindow.profile().handle, real_name='pcc31', blocking=True, timeout=120)
2011-02-15 12:10:57 -05:00
self.cli.command_handler.parent = self
self.cli.command_handler.mainwindow = self.mainwindow
2011-02-21 14:07:59 -05:00
self.cli.connect()
self.conn = self.cli.conn()
2011-02-19 18:06:54 -05:00
def run(self):
2011-02-21 14:07:59 -05:00
try:
self.IRCConnect()
2021-03-23 17:36:43 -04:00
except socket.error as se:
2011-02-21 14:07:59 -05:00
self.stopIRC = se
return
2011-02-19 18:06:54 -05:00
while 1:
2011-02-21 14:07:59 -05:00
res = True
2011-02-19 18:06:54 -05:00
try:
PchumLog.debug("updateIRC()")
2011-02-19 21:38:06 -05:00
res = self.updateIRC()
2021-03-23 17:36:43 -04:00
except socket.timeout as se:
PchumLog.debug("timeout in thread %s" % (self))
2011-02-19 21:38:06 -05:00
self.cli.close()
self.stopIRC = se
return
2021-03-23 17:36:43 -04:00
except socket.error as se:
2011-02-19 18:06:54 -05:00
if self.registeredIRC:
self.stopIRC = None
else:
self.stopIRC = se
PchumLog.debug("socket error, exiting thread")
2011-02-19 18:06:54 -05:00
return
2011-02-19 21:38:06 -05:00
else:
if not res:
PchumLog.debug("false Yield: %s, returning" % res)
2011-02-19 21:38:06 -05:00
return
2011-02-18 03:17:13 -05:00
def setConnected(self):
2011-02-18 21:02:54 -05:00
self.registeredIRC = True
2011-02-18 03:17:13 -05:00
self.connected.emit()
2011-02-19 18:06:54 -05:00
def setConnectionBroken(self):
2022-03-18 05:55:01 -04:00
PchumLog.critical("setconnection broken")
2011-02-19 18:06:54 -05:00
self.reconnectIRC()
#self.brokenConnection = True
@QtCore.pyqtSlot()
def updateIRC(self):
try:
2021-03-23 17:36:43 -04:00
res = next(self.conn)
except socket.timeout as se:
2011-02-19 18:06:54 -05:00
if self.registeredIRC:
2011-02-19 21:38:06 -05:00
return True
2011-02-19 18:06:54 -05:00
else:
raise se
2021-03-23 17:36:43 -04:00
except socket.error as se:
2011-02-19 18:06:54 -05:00
raise se
except StopIteration:
2011-02-21 14:07:59 -05:00
self.conn = self.cli.conn()
2011-02-19 21:38:06 -05:00
return True
else:
return res
2011-02-19 18:06:54 -05:00
@QtCore.pyqtSlot()
def reconnectIRC(self):
2022-03-18 05:55:01 -04:00
PchumLog.warning("reconnectIRC() from thread %s" % (self))
2011-02-19 18:06:54 -05:00
self.cli.close()
@QtCore.pyqtSlot(PesterProfile)
def getMood(self, *chums):
2011-02-15 12:10:57 -05:00
self.cli.command_handler.getMood(*chums)
@QtCore.pyqtSlot(PesterList)
def getMoods(self, chums):
self.cli.command_handler.getMood(*chums)
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString)
def sendNotice(self, text, handle):
2021-03-23 17:36:43 -04:00
h = str(handle)
t = str(text)
try:
helpers.notice(self.cli, h, t)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString)
def sendMessage(self, text, handle):
2021-03-23 17:36:43 -04:00
h = str(handle)
textl = [str(text)]
2011-02-13 20:32:02 -05:00
def splittext(l):
2011-04-14 03:07:05 -04:00
if len(l[0]) > 450:
space = l[0].rfind(" ", 0,430)
2011-02-13 20:32:02 -05:00
if space == -1:
2011-04-14 03:07:05 -04:00
space = 450
elif l[0][space+1:space+5] == "</c>":
space = space+4
2011-04-10 05:22:06 -04:00
a = l[0][0:space+1]
b = l[0][space+1:]
if a.count("<c") > a.count("</c>"):
# oh god ctags will break!! D=
hanging = []
usedends = []
c = a.rfind("<c")
while c != -1:
d = a.find("</c>", c)
while d in usedends:
d = a.find("</c>", d+1)
if d != -1: usedends.append(d)
else:
f = a.find(">", c)+1
hanging.append(a[c:f])
c = a.rfind("<c",0,c)
# end all ctags in first part
for i in range(a.count("<c")-a.count("</c>")):
a = a + "</c>"
#start them up again in the second part
for c in hanging:
b = c + b
2011-02-13 20:32:02 -05:00
if len(b) > 0:
return [a] + splittext([b])
else:
return [a]
else:
return l
textl = splittext(textl)
2011-02-15 12:10:57 -05:00
try:
for t in textl:
helpers.msg(self.cli, h, t)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, bool)
def startConvo(self, handle, initiated):
2021-03-23 17:36:43 -04:00
h = str(handle)
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, h, "COLOR >%s" % (self.mainwindow.profile().colorcmd()))
2011-02-15 12:10:57 -05:00
if initiated:
helpers.msg(self.cli, h, "PESTERCHUM:BEGIN")
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def endConvo(self, handle):
2021-03-23 17:36:43 -04:00
h = str(handle)
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, h, "PESTERCHUM:CEASE")
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
@QtCore.pyqtSlot()
def updateProfile(self):
me = self.mainwindow.profile()
handle = me.handle
2011-02-15 12:10:57 -05:00
try:
helpers.nick(self.cli, handle)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
self.mainwindow.closeConversations(True)
2014-01-12 03:14:16 -05:00
self.mainwindow.doAutoIdentify()
2014-01-12 20:50:01 -05:00
self.mainwindow.autoJoinDone = False
self.mainwindow.doAutoJoins()
self.updateMood()
@QtCore.pyqtSlot()
def updateMood(self):
me = self.mainwindow.profile()
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, "#pesterchum", "MOOD >%d" % (me.mood.value()))
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
@QtCore.pyqtSlot()
def updateColor(self):
#PchumLog.debug("irc updateColor (outgoing)")
me = self.mainwindow.profile()
2021-03-23 17:36:43 -04:00
for h in list(self.mainwindow.convos.keys()):
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, h, "COLOR >%s" % (self.mainwindow.profile().colorcmd()))
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def blockedChum(self, handle):
2021-03-23 17:36:43 -04:00
h = str(handle)
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, h, "PESTERCHUM:BLOCK")
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def unblockedChum(self, handle):
2021-03-23 17:36:43 -04:00
h = str(handle)
2011-02-15 12:10:57 -05:00
try:
helpers.msg(self.cli, h, "PESTERCHUM:UNBLOCK")
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def requestNames(self, channel):
2021-03-23 17:36:43 -04:00
c = str(channel)
2011-02-15 12:10:57 -05:00
try:
helpers.names(self.cli, c)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
@QtCore.pyqtSlot()
def requestChannelList(self):
2011-02-15 12:10:57 -05:00
try:
helpers.channel_list(self.cli)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def joinChannel(self, channel):
2021-03-23 17:36:43 -04:00
c = str(channel)
2011-02-15 12:10:57 -05:00
try:
helpers.join(self.cli, c)
2011-05-20 14:45:41 -04:00
helpers.mode(self.cli, c, "", None)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def leftChannel(self, channel):
2021-03-23 17:36:43 -04:00
c = str(channel)
2011-02-15 12:10:57 -05:00
try:
helpers.part(self.cli, c)
2011-09-13 00:03:05 -04:00
self.cli.command_handler.joined = False
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString)
2011-02-06 01:02:39 -05:00
def kickUser(self, handle, channel):
2011-06-13 16:37:07 -04:00
l = handle.split(":")
2021-03-23 17:36:43 -04:00
c = str(channel)
h = str(l[0])
2011-06-13 16:37:07 -04:00
if len(l) > 1:
2021-03-23 17:36:43 -04:00
reason = str(l[1])
2011-06-28 17:10:26 -04:00
if len(l) > 2:
for x in l[2:]:
2021-03-23 17:36:43 -04:00
reason += str(":") + str(x)
2011-06-13 16:37:07 -04:00
else:
reason = ""
2011-02-15 12:10:57 -05:00
try:
2011-06-13 16:37:07 -04:00
helpers.kick(self.cli, h, c, reason)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString, QString)
2011-02-06 19:50:21 -05:00
def setChannelMode(self, channel, mode, command):
2021-03-23 17:36:43 -04:00
c = str(channel)
m = str(mode)
cmd = str(command)
PchumLog.debug("c=%s\nm=%s\ncmd=%s" % (c,m,cmd))
2011-02-06 19:50:21 -05:00
if cmd == "":
cmd = None
2011-02-15 12:10:57 -05:00
try:
helpers.mode(self.cli, c, m, cmd)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString)
def channelNames(self, channel):
2021-03-23 17:36:43 -04:00
c = str(channel)
try:
helpers.names(self.cli, c)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString)
def inviteChum(self, handle, channel):
2021-03-23 17:36:43 -04:00
h = str(handle)
c = str(channel)
try:
helpers.invite(self.cli, h, c)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
self.setConnectionBroken()
@QtCore.pyqtSlot()
def pingServer(self):
try:
self.cli.send("PING %s" % int(time()))
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
self.setConnectionBroken()
2011-06-28 19:26:13 -04:00
@QtCore.pyqtSlot(bool)
def setAway(self, away=True):
try:
if away:
self.cli.send("AWAY Idle")
else:
self.cli.send("AWAY")
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-06-28 19:26:13 -04:00
self.setConnectionBroken()
2021-03-23 17:36:43 -04:00
@QtCore.pyqtSlot(QString, QString)
2011-06-29 13:19:22 -04:00
def killSomeQuirks(self, channel, handle):
2021-03-23 17:36:43 -04:00
c = str(channel)
h = str(handle)
2011-06-29 13:19:22 -04:00
try:
helpers.ctcp(self.cli, c, "NOQUIRKS", h)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-06-29 13:19:22 -04:00
self.setConnectionBroken()
2021-03-25 16:39:37 -04:00
def quit_dc(self):
helpers.quit(self.cli, _pcVersion + " <3")
2011-06-29 13:19:22 -04:00
#def getMask(self):
# This needs to be updated when our hostname is changed.
# Nevermind this entire thing, actually.
2021-03-23 17:36:43 -04:00
moodUpdated = QtCore.pyqtSignal('QString', Mood)
colorUpdated = QtCore.pyqtSignal('QString', QtGui.QColor)
messageReceived = QtCore.pyqtSignal('QString', 'QString')
memoReceived = QtCore.pyqtSignal('QString', 'QString', 'QString')
noticeReceived = QtCore.pyqtSignal('QString', 'QString')
inviteReceived = QtCore.pyqtSignal('QString', 'QString')
timeCommand = QtCore.pyqtSignal('QString', 'QString', 'QString')
namesReceived = QtCore.pyqtSignal('QString', PesterList)
channelListReceived = QtCore.pyqtSignal(PesterList)
2021-03-23 17:36:43 -04:00
nickCollision = QtCore.pyqtSignal('QString', 'QString')
myHandleChanged = QtCore.pyqtSignal('QString')
chanInviteOnly = QtCore.pyqtSignal('QString')
modesUpdated = QtCore.pyqtSignal('QString', 'QString')
connected = QtCore.pyqtSignal()
2021-03-23 17:36:43 -04:00
userPresentUpdate = QtCore.pyqtSignal('QString', 'QString',
'QString')
cannotSendToChan = QtCore.pyqtSignal('QString', 'QString')
2011-06-20 19:18:47 -04:00
tooManyPeeps = QtCore.pyqtSignal()
2021-03-23 17:36:43 -04:00
quirkDisable = QtCore.pyqtSignal('QString', 'QString', 'QString')
2011-02-15 12:10:57 -05:00
class PesterHandler(DefaultCommandHandler):
def notice(self, nick, chan, msg):
2021-03-23 17:40:47 -04:00
#try:
# msg = msg.decode('utf-8')
#except UnicodeDecodeError:
# msg = msg.decode('iso-8859-1', 'ignore')
#nick = nick.decode('utf-8')
#chan = chan.decode('utf-8')
handle = nick[0:nick.find("!")]
PchumLog.info("---> recv \"NOTICE %s :%s\"" % (handle, msg))
if handle == "ChanServ" and chan == self.parent.mainwindow.profile().handle and msg[0:2] == "[#":
self.parent.memoReceived.emit(msg[1:msg.index("]")], handle, msg)
else:
self.parent.noticeReceived.emit(handle, msg)
def privmsg(self, nick, chan, msg):
2021-03-23 17:40:47 -04:00
#try:
# msg = msg.decode('utf-8')
#except UnicodeDecodeError:
# msg = msg.decode('iso-8859-1', 'ignore')
# display msg, do other stuff
2011-02-07 13:40:05 -05:00
if len(msg) == 0:
return
# silently ignore CTCP
2021-02-21 10:40:03 -05:00
# Notice IRC /me (The CTCP kind)
if msg[0:8] == '\x01ACTION ':
msg = '/me' + msg[7:-1]
# silently ignore the rest of the CTCPs
if msg[0] == '\x01':
2011-05-26 03:40:30 -04:00
handle = nick[0:nick.find("!")]
PchumLog.warning("---> recv \"CTCP %s :%s\"" % (handle, msg[1:-1]))
2011-05-26 03:40:30 -04:00
if msg[1:-1] == "VERSION":
2011-07-12 03:15:47 -04:00
helpers.ctcp_reply(self.parent.cli, handle, "VERSION", "Pesterchum %s" % (_pcVersion))
2011-06-29 13:19:22 -04:00
elif msg[1:-1].startswith("NOQUIRKS") and chan[0] == "#":
op = nick[0:nick.find("!")]
self.parent.quirkDisable.emit(chan, msg[10:-1], op)
return
handle = nick[0:nick.find("!")]
2016-12-11 04:01:48 -05:00
2016-12-10 20:55:42 -05:00
if chan != "#pesterchum":
# We don't need anywhere near that much spam.
PchumLog.info("---> recv \"PRIVMSG %s :%s\"" % (handle, msg))
2016-12-11 04:01:48 -05:00
if chan == "#pesterchum":
# follow instructions
if msg[0:6] == "MOOD >":
try:
mood = Mood(int(msg[6:]))
except ValueError:
mood = Mood(0)
self.parent.moodUpdated.emit(handle, mood)
elif msg[0:7] == "GETMOOD":
mychumhandle = self.mainwindow.profile().handle
mymood = self.mainwindow.profile().mood.value()
if msg.find(mychumhandle, 8) != -1:
helpers.msg(self.client, "#pesterchum",
2011-02-15 12:10:57 -05:00
"MOOD >%d" % (mymood))
elif chan[0] == '#':
if msg[0:16] == "PESTERCHUM:TIME>":
self.parent.timeCommand.emit(chan, handle, msg[16:])
else:
self.parent.memoReceived.emit(chan, handle, msg)
else:
# private message
# silently ignore messages to yourself.
if handle == self.mainwindow.profile().handle:
return
if msg[0:7] == "COLOR >":
colors = msg[7:].split(",")
try:
colors = [int(d) for d in colors]
except ValueError as e:
PchumLog.warning(e)
colors = [0,0,0]
PchumLog.debug("colors: " + str(colors))
color = QtGui.QColor(*colors)
self.parent.colorUpdated.emit(handle, color)
else:
self.parent.messageReceived.emit(handle, msg)
2011-02-15 12:10:57 -05:00
def welcome(self, server, nick, msg):
2011-02-18 03:17:13 -05:00
self.parent.setConnected()
2011-02-15 12:10:57 -05:00
mychumhandle = self.mainwindow.profile().handle
mymood = self.mainwindow.profile().mood.value()
2011-09-13 00:03:05 -04:00
if not self.mainwindow.config.lowBandwidth():
from time import sleep
sleep(0.5) # To prevent TLS from dying </3
2011-09-13 00:03:05 -04:00
helpers.join(self.client, "#pesterchum")
helpers.msg(self.client, "#pesterchum", "MOOD >%d" % (mymood))
2011-02-15 12:10:57 -05:00
def nicknameinuse(self, server, cmd, nick, msg):
newnick = "pesterClient%d" % (random.randint(100,999))
2011-02-15 12:10:57 -05:00
helpers.nick(self.client, newnick)
self.parent.nickCollision.emit(nick, newnick)
2011-02-15 12:10:57 -05:00
def quit(self, nick, reason):
handle = nick[0:nick.find("!")]
PchumLog.info("---> recv \"QUIT %s: %s\"" % (handle, reason))
if handle == self.parent.mainwindow.randhandler.randNick:
self.parent.mainwindow.randhandler.setRunning(False)
2011-07-17 04:58:19 -04:00
server = self.parent.mainwindow.config.server()
baseserver = server[server.rfind(".", 0, server.rfind(".")):]
if reason.count(baseserver) == 2:
self.parent.userPresentUpdate.emit(handle, "", "netsplit")
else:
self.parent.userPresentUpdate.emit(handle, "", "quit")
2011-02-06 01:02:39 -05:00
self.parent.moodUpdated.emit(handle, Mood("offline"))
2011-06-13 16:37:07 -04:00
def kick(self, opnick, channel, handle, reason):
op = opnick[0:opnick.find("!")]
self.parent.userPresentUpdate.emit(handle, channel, "kick:%s:%s" % (op, reason))
2011-02-06 01:02:39 -05:00
# ok i shouldnt be overloading that but am lazy
2011-02-15 12:10:57 -05:00
def part(self, nick, channel, reason="nanchos"):
handle = nick[0:nick.find("!")]
PchumLog.info("---> recv \"PART %s: %s\"" % (handle, channel))
self.parent.userPresentUpdate.emit(handle, channel, "left")
if channel == "#pesterchum":
self.parent.moodUpdated.emit(handle, Mood("offline"))
2011-02-15 12:10:57 -05:00
def join(self, nick, channel):
handle = nick[0:nick.find("!")]
PchumLog.info("---> recv \"JOIN %s: %s\"" % (handle, channel))
self.parent.userPresentUpdate.emit(handle, channel, "join")
if channel == "#pesterchum":
if handle == self.parent.mainwindow.randhandler.randNick:
self.parent.mainwindow.randhandler.setRunning(True)
self.parent.moodUpdated.emit(handle, Mood("chummy"))
def mode(self, op, channel, mode, *handles):
PchumLog.debug("op=" + str(op))
PchumLog.debug("channel=" + str(channel))
PchumLog.debug("mode=" + str(mode))
PchumLog.debug("*handles=" + str(handles))
if len(handles) <= 0: handles = [""]
2021-03-23 17:40:47 -04:00
opnick = op[0:op.find("!")]
PchumLog.debug("opnick=" + opnick)
# Channel section
# Okay so, as I understand it channel modes will always be applied to a channel even if the commands also sets a mode to a user.
# So "MODE #channel +ro handleHandle" will set +r to channel #channel as well as set +o to handleHandle
# Therefore the bellow method causes a crash if both user and channel mode are being set in one command.
#if op == channel or channel == self.parent.mainwindow.profile().handle:
# modes = list(self.parent.mainwindow.modes)
# if modes and modes[0] == "+": modes = modes[1:]
# if mode[0] == "+":
# for m in mode[1:]:
# if m not in modes:
# modes.extend(m)
# elif mode[0] == "-":
# for i in mode[1:]:
# try:
# modes.remove(i)
# except ValueError:
# pass
# modes.sort()
# self.parent.mainwindow.modes = "+" + "".join(modes)
# EXPIRIMENTAL FIX
2021-08-24 11:32:47 -04:00
# No clue how stable this is but since it doesn't seem to cause a crash it's probably an improvement.
# This might be clunky with non-unrealircd IRC servers
channel_mode = ""
unrealircd_channel_modes = ['c', 'C', 'd', 'f', 'G', 'H', 'i', 'k', 'K', 'L', 'l', 'm', 'M', 'N', 'n', 'O', 'P', 'p', 'Q', 'R', 'r', 's', 'S', 'T', 't', 'V', 'z', 'Z']
if any(md in mode for md in unrealircd_channel_modes):
PchumLog.debug("Channel mode in string.")
modes = list(self.parent.mainwindow.modes)
for md in unrealircd_channel_modes:
if mode.find(md)!= -1: # -1 means not found
PchumLog.debug("md=" + md)
if mode[0] == "+":
modes.extend(md)
channel_mode = "+" + md
elif mode[0] == "-":
try:
modes.remove(md)
channel_mode = "-" + md
except ValueError:
PchumLog.warning("Can't remove channel mode that isn't set.")
pass
self.parent.userPresentUpdate.emit("", channel, channel_mode+":%s" % (op))
PchumLog.debug("pre-mode=" + str(mode))
mode = mode.replace(md, "")
PchumLog.debug("post-mode=" + str(mode))
modes.sort()
self.parent.mainwindow.modes = "+" + "".join(modes)
modes = []
cur = "+"
for l in mode:
if l in ["+","-"]: cur = l
else:
modes.append("%s%s" % (cur, l))
PchumLog.debug("handles=" + str(handles))
PchumLog.debug("enumerate(modes) = " + str(list(enumerate(modes))))
for (i,m) in enumerate(modes):
# Server-set usermodes don't need to be passed.
if (handles == ['']) & ( ('x' in m) | ('z' in m) | ('o' in m) | ('x' in m) )!=True:
2022-03-17 00:36:14 -04:00
try:
self.parent.userPresentUpdate.emit(handles[i], channel, m+":%s" % (op))
except IndexError as e:
PchumLog.exception("modeSetIndexError: %s" % e)
#print("i = " + i)
#print("m = " + m)
#self.parent.userPresentUpdate.emit(handles[i], channel, m+":%s" % (op))
#self.parent.userPresentUpdate.emit(handles[i], channel, m+":%s" % (op))
# Passing an empty handle here might cause a crash.
#except IndexError:
#self.parent.userPresentUpdate.emit("", channel, m+":%s" % (op))
2011-02-15 12:10:57 -05:00
def nick(self, oldnick, newnick):
oldhandle = oldnick[0:oldnick.find("!")]
2011-03-06 22:02:47 -05:00
if oldhandle == self.mainwindow.profile().handle:
self.parent.myHandleChanged.emit(newnick)
newchum = PesterProfile(newnick, chumdb=self.mainwindow.chumdb)
2011-02-15 12:10:57 -05:00
self.parent.moodUpdated.emit(oldhandle, Mood("offline"))
self.parent.userPresentUpdate.emit("%s:%s" % (oldhandle, newnick), "", "nick")
if newnick in self.mainwindow.chumList.chums:
self.getMood(newchum)
if oldhandle == self.parent.mainwindow.randhandler.randNick:
self.parent.mainwindow.randhandler.setRunning(False)
elif newnick == self.parent.mainwindow.randhandler.randNick:
self.parent.mainwindow.randhandler.setRunning(True)
2011-02-15 12:10:57 -05:00
def namreply(self, server, nick, op, channel, names):
namelist = names.split(" ")
PchumLog.info("---> recv \"NAMES %s: %d names\"" % (channel, len(namelist)))
2011-02-15 12:10:57 -05:00
if not hasattr(self, 'channelnames'):
self.channelnames = {}
if channel not in self.channelnames:
2011-02-15 12:10:57 -05:00
self.channelnames[channel] = []
self.channelnames[channel].extend(namelist)
#def ison(self, server, nick, nicks):
# nicklist = nicks.split(" ")
# getglub = "GETMOOD "
# PchumLog.info("---> recv \"ISON :%s\"" % nicks)
# for nick_it in nicklist:
# self.parent.moodUpdated.emit(nick_it, Mood(0))
# if nick_it in self.parent.mainwindow.namesdb["#pesterchum"]:
# getglub += nick_it
# if getglub != "GETMOOD ":
# helpers.msg(self.client, "#pesterchum", getglub)
2021-02-21 10:40:03 -05:00
2011-02-15 12:10:57 -05:00
def endofnames(self, server, nick, channel, msg):
namelist = self.channelnames[channel]
pl = PesterList(namelist)
del self.channelnames[channel]
self.parent.namesReceived.emit(channel, pl)
2011-09-13 00:03:05 -04:00
if channel == "#pesterchum" and (not hasattr(self, "joined") or not self.joined):
self.joined = True
self.parent.mainwindow.randhandler.setRunning(self.parent.mainwindow.randhandler.randNick in namelist)
chums = self.mainwindow.chumList.chums
#self.isOn(*chums)
lesschums = []
for c in chums:
chandle = c.handle
if chandle in namelist:
lesschums.append(c)
self.getMood(*lesschums)
2011-02-15 12:10:57 -05:00
def liststart(self, server, handle, *info):
self.channel_list = []
info = list(info)
2011-02-15 12:10:57 -05:00
self.channel_field = info.index("Channel") # dunno if this is protocol
PchumLog.info("---> recv \"CHANNELS: %s " % (self.channel_field))
2011-02-15 12:10:57 -05:00
def list(self, server, handle, *info):
channel = info[self.channel_field]
2011-03-31 17:57:30 -04:00
usercount = info[1]
2011-02-15 12:10:57 -05:00
if channel not in self.channel_list and channel != "#pesterchum":
2011-03-31 17:57:30 -04:00
self.channel_list.append((channel, usercount))
PchumLog.info("---> recv \"CHANNELS: %s " % (channel))
2011-02-15 12:10:57 -05:00
def listend(self, server, handle, msg):
pl = PesterList(self.channel_list)
PchumLog.info("---> recv \"CHANNELS END\"")
2011-02-15 12:10:57 -05:00
self.parent.channelListReceived.emit(pl)
self.channel_list = []
def umodeis(self, server, handle, modes):
self.parent.mainwindow.modes = modes
def invite(self, sender, you, channel):
handle = sender.split('!')[0]
self.parent.inviteReceived.emit(handle, channel)
def inviteonlychan(self, server, handle, channel, msg):
self.parent.chanInviteOnly.emit(channel)
2022-03-16 23:25:27 -04:00
# This can cause a crash without mode_params, channelmodeis can have six arguments.
2022-03-17 00:41:42 -04:00
def channelmodeis(self, server, handle, channel, modes, mode_params=""):
2011-05-20 14:45:41 -04:00
self.parent.modesUpdated.emit(channel, modes)
def cannotsendtochan(self, server, handle, channel, msg):
self.parent.cannotSendToChan.emit(channel, msg)
2011-06-20 19:18:47 -04:00
def toomanypeeps(self, *stuff):
self.parent.tooManyPeeps.emit()
def ping(self, prefix, server):
self.parent.mainwindow.lastping = int(time())
self.client.send('PONG', server)
2011-02-15 12:10:57 -05:00
def getMood(self, *chums):
chumglub = "GETMOOD "
for c in chums:
chandle = c.handle
if len(chumglub+chandle) >= 350:
try:
helpers.msg(self.client, "#pesterchum", chumglub)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.parent.setConnectionBroken()
chumglub = "GETMOOD "
chumglub += chandle
if chumglub != "GETMOOD ":
try:
helpers.msg(self.client, "#pesterchum", chumglub)
2022-03-18 05:55:01 -04:00
except socket.error as e:
PchumLog.warning(e)
2011-02-15 12:10:57 -05:00
self.parent.setConnectionBroken()
#def isOn(self, *chums):
# isonNicks = ""
# for c in chums:
# chandle = c.handle
# if len(chandle) >= 200:
# try:
# self.client.send("ISON", ":%s" % (isonNicks))
# except socket.error:
# self.parent.setConnectionBroken()
# isonNicks = ""
# isonNicks += " " + chandle
# if isonNicks != "":
# try:
# self.client.send("ISON", ":%s" % (isonNicks))
# except socket.error:
# self.parent.setConnectionBroken()