def __init__(self, parent = None):
QTcpSocket.__init__(self, parent)
# The 'readyRead' signal is from QTcpSocket, call 'readyReadId'
# whenever is emitted.
self.readyRead.connect(self.onReadyRead)
self.disconnected.connect(self.onDisconnected)
def __init__(self, parent=None):
QTcpSocket.__init__(self, parent)
# The 'readyRead' signal is from QTcpSocket, call 'readyReadId'
# whenever is emitted.
self.readyRead.connect(self.onReadyRead)
self.disconnected.connect(self.onDisconnected)
def __init__(self, host, port=6667, ssl=False):
super(IRCServer, self).__init__()
if ssl:
self.socket = QSslSocket()
else:
self.socket = QTcpSocket()
self.__host = host
self.__port = port
self.__linebuf = ""
self.__channels = {}
self.socket.readyRead.connect(self.__handleRead)
self.receivedPing.connect(self.pong)
class clientTCP(clientAbstract.clientAbstract):
""" OSC-client running on GOD.
sends OSC-messages to SMi.
receives OSC-messages from SMi (and emits signals with the data)
"""
def __init__(self, host, port, oscprefix='', verbose=False):
super(clientTCP, self).__init__(oscprefix=oscprefix, verbose=verbose)
self.remote = (host, port) ## FIXXME: 'host' is not canonicalized
self.keepListening=True
self.slip = SLIP()
self.socket = QTcpSocket()
self.socket.readyRead.connect(self._callback)
self.socket.connectToHost(host, port);
self.sender=(host, port)
def __del__(self):
self.shutdown()
def shutdown(self):
self.keepListening=False
if self.socket is not None:
try:
self.socket.shutdown()
self.socket.close()
except:
pass
if self.addressManager is not None:
del self.addressManager
self.addressManager = None
self.remote = None
self.socket = None
def _callback(self):
'''Asynchronous connection listener. Starts a handler for each connection.'''
## while self.socket.hasPendingDatagrams():
## datagram, sender, senderPort = self.socket.readDatagram(self.socket.pendingDatagramSize())
## self.addressManager.handle(datagram.data(), (sender.toString(), senderPort))
data=str(self.socket.readAll())
self.slip.append(data)
for d in self.slip.get():
self.addressManager.handle(d, self.sender)
def _send(self, data):
if self.socket is not None and self.remote is not None:
logging.log(1, "sending '%s' to %s" % (str(data), str(self.remote)))
slip = SLIP();
slip+=data;
sdata=str(slip.getData())
self.socket.writeData(sdata, len(sdata))
def _createSocket(self):
from PySide.QtNetwork import QTcpSocket
q = self.q
ret = QTcpSocket(q)
socketio.initsocket(ret)
ret.error.connect(q.socketError)
ret.connected.connect(q.connected)
ret.disconnected.connect(q.disconnected)
ret.readyRead.connect(self.readSocket)
return ret
def __init__(self, host, port, oscprefix='', verbose=False):
super(clientTCP, self).__init__(oscprefix=oscprefix, verbose=verbose)
self.remote = (host, port) ## FIXXME: 'host' is not canonicalized
self.keepListening=True
self.slip = SLIP()
self.socket = QTcpSocket()
self.socket.readyRead.connect(self._callback)
self.socket.connectToHost(host, port);
self.sender=(host, port)
def _connect(self):
# connect to a server
if not self.chat_widget.connected:
self.chat_widget.connection = QTcpSocket()
# upon connection, disable the connect action, and enable the
# quit server action
self.chat_widget.connection.connected.connect(
partial(self.quit_server_action.setEnabled, True))
self.chat_widget.connection.connected.connect(
partial(self.connect_action.setDisabled, True))
# to the reverse thing upon disconnection
self.chat_widget.connection.disconnected.connect(
partial(self.connect_action.setEnabled, True))
self.chat_widget.connection.disconnected.connect(
partial(self.quit_server_action.setDisabled, True))
# connect to the chat server
self.chat_widget.connection.connectToHost(HOST_ADDRESS, PORT)
class IRCServer(QObject):
"""
A socket to an IRC server.
Initialize it with the host and port (default 6667)
Connect with server.connectAs(nick), and connect to the online() signal.
"""
joinedChannel = Signal(IRCChannel) # fired when the client joins a channel
kicked = Signal(str, IRCChannel, str) # fired when the client gets kicked from a channel
online = Signal() # fired when a connection to the IRC server has been successfully established.
packetRead = Signal(str) # fired when a full packet is read from the server
packetWritten = Signal(str) # fired when a full packet is written to the server
receivedPing = Signal(str) # fired when the client receives a Ping packet
receivedNotice = Signal(str, str) # fired when the client receives a Notice packet
receivedPrivateMessage = Signal(str, str) # fired when the client receives a personal privmsg packet
def __init__(self, host, port=6667, ssl=False):
super(IRCServer, self).__init__()
if ssl:
self.socket = QSslSocket()
else:
self.socket = QTcpSocket()
self.__host = host
self.__port = port
self.__linebuf = ""
self.__channels = {}
self.socket.readyRead.connect(self.__handleRead)
self.receivedPing.connect(self.pong)
def __handleRead(self):
while True:
line = str(self.socket.readLine())
if not line:
break
if self.__linebuf:
line = self.__linebuf + line
self.__linebuf = ""
if not line.endswith("\r\n"):
self.__linebuf = line
continue
sender, opcode, recipient, msg = self._parse(line.strip())
if opcode == opcodes.RPL_WELCOME:
self.online.emit()
elif opcode == opcodes.RPL_TOPIC:
channel, _, topic = msg.partition(" ")
topic = stripcolon(topic)
channel = self.channel(channel)
channel.topicUpdated.emit(None, topic)
channel.receivedReply.emit(opcode, stripcolon(topic))
elif opcode == opcodes.RPL_CREATIONTIME:
channel, timestamp = msg.split(" ")
self.channel(channel).receivedReply.emit(opcode, timestamp)
elif opcode == opcodes.RPL_CHANNELMODEIS:
channel, mode = msg.partition(" ")
self.channel(channel).receivedReply.emit(opcode, mode)
elif opcode == "JOIN":
user = IRCUser(sender, self)
channel = stripcolon(recipient)
if user.nick() == self.nick():
self.__channels[channel] = IRCChannel(channel, self)
self.joinedChannel.emit(self.__channels[channel])
else:
self.channel(channel).userJoined.emit(user)
elif opcode == "KICK":
channel = self.channel(recipient)
user, _, reason = msg.partition(" ")
reason = stripcolon(reason)
if user == self.nick():
# If we get kicked, emit IRCServer.kicked(sender, channel, reason)
# TODO also emit IRCChannel.kicked(sender, reason)
self.kicked.emit(sender, channel, reason)
del self.__channels[recipient] # remove from channel list
else:
# Otherwise, emit IRCChannel.userKicked(sender, user, reason)
self.channel(channel).userKicked.emit(sender, user, reason)
elif opcode == "NOTICE":
self.receivedNotice.emit(sender, msg)
elif opcode == "PING":
self.receivedPing.emit(msg)
elif opcode == "PRIVMSG":
sender = IRCUser(sender, self)
if recipient == self.nick():
self.receivedPrivateMessage.emit(sender, msg)
else:
self.channel(recipient).receivedMessage.emit(sender, msg)
elif opcode == "TOPIC":
sender = IRCUser(sender, self)
IRCChannel(recipient).topicUpdated.emit(sender, msg)
self.packetRead.emit(line)
def _parse(self, line):
if line.startswith(":"):
# XXX We need to use partition() and check arg numbers
line = line[1:] # strip the first colon already
sender, opcode, recipient = line.split(" ")[:3]
idx = len(" ".join((sender, opcode, recipient)))
msg = line[idx:]
if opcode.isdigit():
opcode = int(opcode)
return sender, opcode, recipient, stripcolon(msg.strip())
elif line.startswith("PING"):
server = ""
recipient = ""
opcode, msg = line.split()
return "", opcode, "", stripcolon(msg)
def channel(self, channel):
"""
Returns the channel \a channel.
"""
return self.__channels[channel]
def connectAs(self, nick, user="", host="", serverName="", realName=""):
"""
Opens a connection to the server and instantly returns.
If the connection is successful, the user's nickname will automatically be
set to \a nick. \a user, \a host, \a serverName and \a realName al default
to the user's nickname.
"""
if self.isSsl():
self.socket.connectToHostEncrypted(self.__host, self.__port)
else:
self.socket.connectToHost(self.__host, self.__port)
self.__nick = nick
def onConnect():
self.send("NICK %s" % (nick))
self.send("USER %s %s %s :%s" % (user or nick, host or nick, serverName or nick, realName or nick))
self.socket.connected.connect(onConnect)
def isSsl(self):
return isinstance(self.socket, QSslSocket)
def join(self, channel):
"""
Joins the channel \a channel.
"""
self.send("JOIN %s" % (channel))
def nick(self):
"""
Returns the user's nickname.
"""
return self.__nick
def pong(self, msg):
"""
Sends a PONG packet to the server with the message \a msg.
\sa receivedPing()
"""
self.send("PONG :%s" % (msg))
def quit(self, reason=""):
"""
Quits the server and closes the TCP socket.
"""
if reason:
self.send("QUIT :%s" % (reason))
else:
self.send("QUIT")
self.close()
def send(self, message):
"""
Sends \a message to the server, terminating it with CRLF if necessary.
\sa write()
"""
if not message.endswith("\r\n"):
message += "\r\n"
self.write(message)
def setAway(self, away, reason="Away"):
"""
Sets the user's away status to \a away, with reason \a reason.
\a reason is ignored if \a away is False. Default reason is "Away".
Note that you cannot set yourself away without a reason.
\sa away()
"""
if not away:
self.send("AWAY")
else:
self.send("AWAY :%s" % (reason))
def write(self, data):
"""
Writes \a data to the server. The data is not modified, and must be properly
terminated with CRLF.
\sa send() packetWritten()
"""
data = str(data)
self.socket.write(data)
self.socket.waitForBytesWritten()
self.packetWritten.emit(data)
