chronodose/irc.py

238 lines
8.6 KiB
Python
Raw Normal View History

import re
import socket
import ssl
import sys
import threading
from codes import Code
class IRCClient:
def __init__(self, server, nickname, port=None, tls=False, username=None, realname=None, encoding='utf-8', errors='ignore', capabilities=None):
self.server = server
self.nickname = nickname
if not self.nickname:
raise ValueError("Nick must not be empty")
if port is None:
if tls:
self.port = 6697
else:
self.port = 6667
else:
self.port = port
self.tls = tls
if not username:
self.username = self.nickname
else:
self.username = username
if not realname:
self.realname = self.username
else:
self.realname = realname
self.encoding = encoding
self.errors = errors
if capabilities is None:
capabilities = []
self.capabilities = capabilities
self.enabled_capabilities = []
self.socket_mutex = threading.Lock()
def start(self):
self.socket = socket.create_connection((self.server, self.port))
if self.tls:
self.raw_socket = self.socket
context = ssl.create_default_context()
self.socket = context.wrap_socket(self.raw_socket, server_hostname=self.server)
if self.capabilities:
self.cap_ls(True)
self.nick(self.nickname)
self.user(self.username, self.realname)
threads = []
while True:
data = b''
while not data or data[-1] != ord('\n'):
data += self.socket.recv(4096)
data = data.decode(self.encoding, self.errors).split('\r\n')
for command in data:
if command:
thread = threading.Thread(target=self.process_command, args=(command,))
thread.start()
threads.append(thread)
@staticmethod
def parse_command_params(params):
result = []
last_param = 0
for i, char in enumerate(params):
if char == ' ':
if params[i+1] == ':':
result.append(params[last_param:i])
result.append(params[i+2:])
last_param = len(params)
break
else:
result.append(params[last_param:i])
last_param = i+1
elif i == 0 and char == ':':
result.append(params[i+1:])
last_param = len(params)
break
if last_param != len(params):
result.append(params[last_param:])
return result
@staticmethod
def parse_tags(tags):
if tags[0] != '@':
raise ValueError("Invalid tags")
result = {}
tags = tags[1:].split(';')
for tag in tags:
if '=' in tag:
tag = tag.split('=', 1)
result[tag[0]] = tag[1]
else:
result[tag] = None
return result
def process_command(self, command):
match = re.match(r'^(?P<tags>@(?:(?:\+?(?:[0-9A-Za-z.-]+/)?[0-9A-Za-z-]+)(?:=[^\x00\r\n; ]+)?)?(?:;(?:\+?(?:[0-9A-Za-z.-]+/)?[0-9A-Za-z-]+)(?:=[^\x00\r\n; ]+)?)*)? *(?::(?P<target>[^ ]*))? *(?P<command>[a-zA-Z]+|[0-9]{3}) *(?:(?P<params>.*?))?$', command)
if match is None:
print('Unknown command:', command, file=sys.stderr)
return
tags = match.group('tags')
if tags is not None:
tags = self.parse_tags(tags)
else:
tags = {}
target = match.group('target')
command = match.group('command')
params = self.parse_command_params(match.group('params'))
print('<=', tags, target, command, params)
if command.isnumeric():
command = int(command)
try:
command = Code(command)
except ValueError:
self.on_command(command, *params, target=target, tags=tags)
if command == Code.CAP:
if params[1] == 'ACK':
self.on_cap_ack(params[2], target=target, tags=tags)
elif params[1] == 'LS':
self.on_cap_ls(params[2], target=target, tags=tags)
elif command == Code.INVITE:
self.on_invite(*params, target=target, tags=tags)
elif command == Code.JOIN:
self.on_join(*params, target=target, tags=tags)
elif command == Code.PING:
self.on_ping(*params, target=target, tags=tags)
elif command == Code.PRIVMSG:
self.on_privmsg(*params, target=target, tags=tags)
elif command == Code.RPL_ENDOFWHOIS:
self.on_endofwhois(*params, target=target, tags=tags)
elif command == Code.RPL_WELCOME:
self.on_welcome(*params, target=target, tags=tags)
elif command == Code.RPL_WHOISACCOUNT:
self.on_whoisaccount(*params, target=target, tags=tags)
elif command == Code.RPL_WHOISREGNICK:
self.on_whoisregnick(*params, target=target, tags=tags)
def cap_end(self):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.CAP.value} END\r\n'.encode(self.encoding))
self.socket_mutex.release()
def cap_ls(self, _302=False):
self.socket_mutex.acquire()
if self.capabilities:
if _302:
self.socket.sendall(f'{Code.CAP.value} LS 302\r\n'.encode(self.encoding))
else:
self.socket.sendall(f'{Code.CAP.value} LS\r\n'.encode(self.encoding))
self.socket_mutex.release()
def cap_req(self, capabilities=None):
self.socket_mutex.acquire()
if capabilities is None:
capabilities = self.capabilities
capabilities = ' '.join(capabilities)
self.socket.sendall(f'{Code.CAP.value} REQ :{capabilities}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def invite(self, nickname, channel):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.INVITE.value} {nickname} {channel}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def join(self, channel):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.JOIN.value} {channel}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def nick(self, nickname):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.NICK.value} {nickname}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def pong(self, data):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.PONG.value} :{data}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def privmsg(self, channel, message):
self.socket_mutex.acquire()
messages = message.split('\n')
for message in messages:
self.socket.sendall(f'{Code.PRIVMSG.value} {channel} :{message}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def user(self, username, realname, mode=0):
self.socket_mutex.acquire()
self.socket.sendall(f'{Code.USER.value} {username} {mode} * :{realname}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def whois(self, *masks, target=None):
self.socket_mutex.acquire()
masks = ' '.join(masks)
if target is None:
self.socket.sendall(f'{Code.WHOIS.value} {masks}\r\n'.encode(self.encoding))
else:
self.socket.sendall(f'{Code.WHOIS.value} {target} {masks}\r\n'.encode(self.encoding))
self.socket_mutex.release()
def on_cap_ack(self, capabilities, target, tags):
self.enabled_capabilities = capabilities.split()
self.cap_end()
def on_cap_ls(self, capabilities, target, tags):
capabilities = capabilities.split()
self.enabled_capabilities = [capability for capability in self.capabilities if capability in capabilities]
self.cap_req(self.enabled_capabilities)
def on_endofwhois(self, nickname, whoisnickname, info, target, tags):
pass
def on_invite(self, nickname, channel, target, tags):
pass
def on_join(self, channel, accountname='*', realname=None, target=None, tags=None):
pass
def on_ping(self, data, target, tags):
self.pong(data)
def on_privmsg(self, channel, message, target, tags):
pass
def on_welcome(self, nickname, reply, target, tags):
pass
def on_whoisaccount(self, nickname, whoisnickname, account, info, target, tags):
pass
def on_whoisregnick(self, nickname, whoisnickname, reply, target, tags):
pass
def on_command(code, *params, target=None, tags=None):
pass