bitbot-3.11-fork/IRCServer.py

380 lines
14 KiB
Python
Raw Normal View History

2016-03-29 11:56:58 +00:00
import collections, socket, ssl, sys, time
import IRCChannel, IRCUser
2016-03-29 11:56:58 +00:00
THROTTLE_LINES = 4
THROTTLE_SECONDS = 1
READ_TIMEOUT_SECONDS = 120
PING_INTERVAL_SECONDS = 30
OUR_TLS_PROTOCOL = ssl.PROTOCOL_SSLv23
if hasattr(ssl, "PROTOCOL_TLS"):
OUR_TLS_PROTOCOL = ssl.PROTOCOL_TLS
2016-03-29 11:56:58 +00:00
class Server(object):
def __init__(self, bot, events, id, hostname, port, password, ipv4,
tls, nickname, username, realname):
2016-03-29 11:56:58 +00:00
self.connected = False
self.bot = bot
self.events = events
2016-03-29 11:56:58 +00:00
self.id = id
self.target_hostname = hostname
self.port = port
self.tls = tls
self.password = password
self.ipv4 = ipv4
self.original_nickname = nickname
self.original_username = username or nickname
self.original_realname = realname or nickname
self.name = None
self._capability_queue = set([])
self._capabilities_waiting = set([])
2016-03-29 11:56:58 +00:00
self.write_buffer = b""
self.buffered_lines = []
2016-03-29 11:56:58 +00:00
self.read_buffer = b""
self.recent_sends = []
2016-03-29 11:56:58 +00:00
self.users = {}
self.new_users = set([])
self.channels = {}
self.own_modes = {}
self.mode_prefixes = collections.OrderedDict(
{"@": "o", "+": "v"})
2016-03-29 11:56:58 +00:00
self.channel_modes = []
self.channel_types = []
self.last_read = time.monotonic()
self.last_send = None
self.attempted_join = {}
self.ping_sent = False
2016-03-29 11:56:58 +00:00
if ipv4:
self.socket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
else:
self.socket = socket.socket(socket.AF_INET6,
socket.SOCK_STREAM)
2016-03-29 11:56:58 +00:00
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
self.socket.settimeout(5.0)
2016-03-29 11:56:58 +00:00
if self.tls:
context = ssl.SSLContext(OUR_TLS_PROTOCOL)
context.options |= ssl.OP_NO_SSLv2
context.options |= ssl.OP_NO_SSLv3
context.options |= ssl.OP_NO_TLSv1
2016-03-29 11:56:58 +00:00
self.socket = context.wrap_socket(self.socket)
self.cached_fileno = self.socket.fileno()
self.events.on("timer").on("rejoin").hook(self.try_rejoin)
2018-08-28 14:14:41 +00:00
2016-03-29 11:56:58 +00:00
def __repr__(self):
return "IRCServer.Server(%s)" % self.__str__()
2016-03-29 11:56:58 +00:00
def __str__(self):
return "%s:%s%s" % (self.target_hostname, "+" if self.tls else "",
self.port)
2016-03-29 11:56:58 +00:00
def fileno(self):
fileno = self.socket.fileno()
return self.cached_fileno if fileno == -1 else fileno
2016-03-29 11:56:58 +00:00
def connect(self):
self.socket.connect((self.target_hostname, self.port))
self.send_capibility_ls()
2016-03-29 11:56:58 +00:00
if self.password:
self.send_pass(self.password)
2018-07-15 22:56:06 +00:00
self.send_user(self.original_username, self.original_realname)
self.send_nick(self.original_nickname)
2016-03-29 11:56:58 +00:00
self.connected = True
def disconnect(self):
self.connected = False
try:
self.socket.shutdown(socket.SHUT_RDWR)
except:
pass
try:
self.socket.close()
except:
pass
2016-03-29 11:56:58 +00:00
def set_setting(self, setting, value):
self.bot.database.server_settings.set(self.id, setting,
2016-03-29 11:56:58 +00:00
value)
def get_setting(self, setting, default=None):
return self.bot.database.server_settings.get(self.id,
2016-03-29 11:56:58 +00:00
setting, default)
def find_settings(self, pattern, default=[]):
return self.bot.database.server_settings.find(self.id,
2016-03-29 11:56:58 +00:00
pattern, default)
def find_settings_prefix(self, prefix, default=[]):
return self.bot.database.server_settings.find_prefix(
self.id, prefix, default)
2016-03-29 11:56:58 +00:00
def del_setting(self, setting):
self.bot.database.server_settings.delete(self.id, setting)
def get_all_user_settings(self, setting, default=[]):
return self.bot.database.user_settings.find_all_by_setting(
self.id, setting, default)
def find_all_user_channel_settings(self, setting, default=[]):
return self.bot.database.user_channel_settings.find_all_by_setting(
self.id, setting, default)
2016-03-29 11:56:58 +00:00
def set_own_nickname(self, nickname):
self.nickname = nickname
self.nickname_lower = nickname.lower()
def is_own_nickname(self, nickname):
return nickname.lower() == self.nickname_lower
def add_own_mode(self, mode, arg=None):
self.own_modes[mode] = arg
2016-03-29 11:56:58 +00:00
def remove_own_mode(self, mode):
del self.own_modes[mode]
def change_own_mode(self, remove, mode, arg=None):
if remove:
self.remove_own_mode(mode)
else:
self.add_own_mode(mode, arg)
2016-03-29 11:56:58 +00:00
def has_user(self, nickname):
2018-08-04 11:10:10 +00:00
return nickname.lower() in self.users
2016-03-29 11:56:58 +00:00
def get_user(self, nickname):
if not self.has_user(nickname):
user_id = self.get_user_id(nickname)
new_user = IRCUser.User(nickname, user_id, self, self.bot)
self.events.on("new").on("user").call(
2016-03-29 11:56:58 +00:00
user=new_user, server=self)
2018-08-04 11:10:10 +00:00
self.users[new_user.nickname_lower] = new_user
2016-03-29 11:56:58 +00:00
self.new_users.add(new_user)
2018-08-04 11:10:10 +00:00
return self.users[nickname.lower()]
def get_user_id(self, nickname):
self.bot.database.users.add(self.id, nickname)
return self.bot.database.users.get_id(self.id, nickname)
2016-03-29 11:56:58 +00:00
def remove_user(self, user):
2018-08-04 11:10:10 +00:00
del self.users[user.nickname_lower]
2016-03-29 11:56:58 +00:00
for channel in user.channels:
channel.remove_user(user)
2016-03-29 11:56:58 +00:00
def change_user_nickname(self, old_nickname, new_nickname):
user = self.users.pop(old_nickname.lower())
user.id = self.get_user_id(new_nickname)
self.users[new_nickname.lower()] = user
2016-03-29 11:56:58 +00:00
def has_channel(self, channel_name):
return channel_name[0] in self.channel_types and channel_name.lower(
) in self.channels
def get_channel(self, channel_name):
if not self.has_channel(channel_name):
channel_id = self.get_channel_id(channel_name)
new_channel = IRCChannel.Channel(channel_name, channel_id,
self, self.bot)
self.events.on("new").on("channel").call(
2016-03-29 11:56:58 +00:00
channel=new_channel, server=self)
self.channels[new_channel.name] = new_channel
return self.channels[channel_name.lower()]
def get_channel_id(self, channel_name):
self.bot.database.channels.add(self.id, channel_name)
return self.bot.database.channels.get_id(self.id, channel_name)
2016-03-29 11:56:58 +00:00
def remove_channel(self, channel):
2018-07-02 10:08:39 +00:00
for user in channel.users:
2016-03-29 11:56:58 +00:00
user.part_channel(channel)
del self.channels[channel.name]
def parse_line(self, line):
if not line:
return
self.bot.line_handler.handle(self, line)
2017-07-16 20:18:58 +00:00
self.check_users()
2016-03-29 11:56:58 +00:00
def check_users(self):
for user in self.new_users:
if not len(user.channels):
self.remove_user(user)
self.new_users.clear()
def read(self):
data = b""
try:
data = self.read_buffer + self.socket.recv(4096)
except ConnectionResetError:
self.disconnect()
return []
2016-03-29 11:56:58 +00:00
self.read_buffer = b""
data_lines = [line.strip(b"\r") for line in data.split(b"\n")]
if data_lines[-1]:
self.read_buffer = data_lines[-1]
data_lines.pop(-1)
decoded_lines = []
for line in data_lines:
try:
line = line.decode(self.get_setting(
"encoding", "utf8"))
2016-03-29 11:56:58 +00:00
except:
try:
line = line.decode(self.get_setting(
"fallback-encoding", "latin-1"))
2016-03-29 11:56:58 +00:00
except:
continue
decoded_lines.append(line)
if not decoded_lines:
self.disconnect()
self.last_read = time.monotonic()
self.ping_sent = False
2016-03-29 11:56:58 +00:00
return decoded_lines
def until_next_ping(self):
return max(0, (self.last_read+PING_INTERVAL_SECONDS
)-time.monotonic())
def ping_due(self):
return self.until_next_ping() == 0
def until_read_timeout(self):
return max(0, (self.last_read+READ_TIMEOUT_SECONDS
)-time.monotonic())
def read_timed_out(self):
return self.until_read_timeout == 0
2016-03-29 11:56:58 +00:00
def send(self, data):
encoded = data.split("\n")[0].strip("\r").encode("utf8")
2016-03-29 11:56:58 +00:00
if len(encoded) > 450:
encoded = encoded[:450]
self.buffered_lines.append(encoded + b"\r\n")
if self.bot.args.verbose:
self.bot.log.info(">%s | %s", [str(self), encoded.decode("utf8")])
2016-03-29 11:56:58 +00:00
def _send(self):
if not len(self.write_buffer):
self.write_buffer = self.buffered_lines.pop(0)
2016-03-29 11:56:58 +00:00
self.write_buffer = self.write_buffer[self.socket.send(
self.write_buffer):]
now = time.monotonic()
self.recent_sends.append(now)
self.last_send = now
2016-03-29 11:56:58 +00:00
def waiting_send(self):
return bool(len(self.write_buffer)) or bool(len(self.buffered_lines))
def throttle_done(self):
return self.send_throttle_timeout() == 0
def send_throttle_timeout(self):
if len(self.write_buffer):
return 0
now = time.monotonic()
popped = 0
for i, recent_send in enumerate(self.recent_sends[:]):
time_since = now-recent_send
if time_since >= THROTTLE_SECONDS:
self.recent_sends.pop(i-popped)
popped += 1
if len(self.recent_sends) < THROTTLE_LINES:
return 0
time_left = self.recent_sends[0]+THROTTLE_SECONDS
time_left = time_left-now
return time_left
2016-03-29 11:56:58 +00:00
def send_user(self, username, realname):
self.send("USER %s - - :%s" % (username, realname))
def send_nick(self, nickname):
self.send("NICK %s" % nickname)
def send_capibility_ls(self):
self.send("CAP LS")
def queue_capability(self, capability):
self._capability_queue.add(capability)
def queue_capabilities(self, capabilities):
self._capability_queue.update(capabilities)
def send_capability_queue(self):
if self.has_capability_queue():
capabilities = " ".join(self._capability_queue)
self._capability_queue.clear()
self.send_capability_request(capabilities)
def has_capability_queue(self):
return bool(len(self._capability_queue))
def send_capability_request(self, capability):
self.send("CAP REQ :%s" % capability)
def send_capability_end(self):
self.send("CAP END")
def send_authenticate(self, text):
self.send("AUTHENTICATE %s" % text)
def waiting_for_capabilities(self):
return bool(len(self._capabilities_waiting))
def wait_for_capability(self, capability):
self._capabilities_waiting.add(capability)
def capability_done(self, capability):
self._capabilities_waiting.remove(capability)
if not self._capabilities_waiting:
self.send_capability_end()
2016-03-29 11:56:58 +00:00
def send_pass(self, password):
self.send("PASS %s" % password)
2016-03-29 11:56:58 +00:00
def send_ping(self, nonce="hello"):
self.send("PING :%s" % nonce)
def send_pong(self, nonce="hello"):
self.send("PONG :%s" % nonce)
def try_rejoin(self, event):
if event["server_id"] == self.id and event["channel_name"
] in self.attempted_join:
self.send_join(event["channel_name"], event["key"])
2016-03-29 11:56:58 +00:00
def send_join(self, channel_name, key=None):
self.send("JOIN %s%s" % (channel_name,
"" if key == None else " %s" % key))
def send_part(self, channel_name, reason=None):
self.send("PART %s%s" % (channel_name,
"" if reason == None else " %s" % reason))
2016-03-29 11:56:58 +00:00
def send_quit(self, reason="Leaving"):
self.send("QUIT :%s" % reason)
def send_message(self, target, message, prefix=None):
full_message = message if not prefix else prefix+message
self.send("PRIVMSG %s :%s" % (target, full_message))
action = full_message.startswith("\01ACTION "
) and full_message.endswith("\01")
if action:
message = full_message.split("\01ACTION ", 1)[1][:-1]
full_message_split = full_message.split()
2016-03-29 11:56:58 +00:00
if self.has_channel(target):
channel = self.get_channel(target)
channel.buffer.add_line(None, message, action, True)
self.events.on("self").on("message").on("channel").call(
message=full_message, message_split=full_message_split,
channel=channel, action=action, server=self)
else:
user = self.get_user(target)
user.buffer.add_line(None, message, action, True)
self.events.on("self").on("message").on("private").call(
message=full_message, message_split=full_message_split,
user=user, action=action, server=self)
2016-03-29 11:56:58 +00:00
def send_notice(self, target, message):
self.send("NOTICE %s :%s" % (target, message))
2016-03-29 11:56:58 +00:00
def send_mode(self, target, mode=None, args=None):
self.send("MODE %s%s%s" % (target, "" if mode == None else " %s" % mode,
"" if args == None else " %s" % args))
2016-03-29 11:56:58 +00:00
def send_topic(self, channel_name, topic):
self.send("TOPIC %s :%s" % (channel_name, topic))
def send_kick(self, channel_name, target, reason=None):
self.send("KICK %s %s%s" % (channel_name, target,
"" if reason == None else " :%s" % reason))
def send_names(self, channel_name):
self.send("NAMES %s" % channel_name)
def send_list(self, search_for=None):
self.send(
"LIST%s" % "" if search_for == None else " %s" % search_for)
def send_invite(self, target, channel_name):
self.send("INVITE %s %s" % (target, channel_name))
2016-03-29 11:56:58 +00:00
def send_whois(self, target):
self.send("WHOIS %s" % target)
def send_whowas(self, target, amount=None, server=None):
self.send("WHOWAS %s%s%s" % (target,
"" if amount == None else " %s" % amount,
"" if server == None else " :%s" % server))
def send_who(self, filter=None):
self.send("WHO%s" % ("" if filter == None else " %s" % filter))