def read_messages(self, session_id, msgid=""):
state = self.session.get(session_id)
if not state.authenticated:
raise LtdErrorException(
"You must be registered to read any messages.")
with self.nickdb_connection.enter_scope() as scope:
if self.nickdb.count_messages(scope, state.nick) == 0:
raise LtdErrorException("No messages.")
for msg in self.nickdb.get_messages(scope, state.nick):
self.broker.deliver(
session_id,
ltd.encode_co_output(
"Message left at %s (UTC)." % msg.date, msgid))
e = ltd.Encoder("c")
e.add_field_str(msg.sender, append_null=False)
e.add_field_str(msg.text, append_null=True)
self.broker.deliver(session_id, e.encode())
self.nickdb.delete_message(scope, msg.uuid)
scope.complete()
self.__notification_table.remove_entry(session_id, "mbox_full")
def send(self, session_id, message, exclude=None):
state = self.session.get(session_id)
info = self.groups.get(state.group)
if info.volume == group.Volume.QUIET:
raise LtdErrorException(
"Open messages are not permitted in quiet groups.")
if info.control == group.Control.CONTROLLED and info.moderator != session_id:
if (not info.nick_can_talk(state.nick, state.authenticated)
and not info.address_can_talk(state.loginid, state.ip,
state.host,
state.authenticated)):
self.reputation.warning(session_id)
raise LtdErrorException(
"You do not have permission to talk in this group.")
if len(self.broker.get_subscribers(state.group)) == 1:
raise LtdErrorException("No one else in group.")
max_len = 254 - validate.NICK_MAX - 2
for part in wrap(message, max_len):
e = ltd.Encoder("b")
e.add_field_str(state.nick, append_null=False)
e.add_field_str(part, append_null=True)
if exclude:
excluded_sessions = set()
excluded_id = self.session.find_nick(exclude)
if not excluded_id:
raise LtdStatusException("Exclude", "Nick not found.")
subscribers = self.broker.get_subscribers(info.key)
if not excluded_id in subscribers:
raise LtdStatusException("Exclude", "Nick is not here.")
excluded_sessions.add(excluded_id)
if state.echo == session.EchoMode.OFF:
excluded_sessions.add(session_id)
msg = e.encode()
for sub_id in [
s for s in subscribers if not s in excluded_sessions
]:
self.broker.deliver(sub_id, msg)
else:
if state.echo == session.EchoMode.OFF:
self.broker.to_channel_from(session_id, state.group,
e.encode())
else:
self.broker.to_channel(state.group, e.encode())
def onMessage(self, payload, isBinary):
if not isBinary:
try:
msg = self.__read_message__(payload)
if msg["type"] == "a" and not self.__client:
loginid, nick, group = msg["fields"][:3]
password = msg["fields"][4] if len(
msg["fields"]) >= 5 else ""
asyncio.create_task(
self.__run_icb_client__(loginid, nick, group,
password))
else:
e = ltd.Encoder(msg["type"])
count = len(msg["fields"])
for i in range(count):
f = msg["fields"][i]
e.add_field_str(f,
append_null=(count == 0
or i == count - 1))
self.__client.send(e.encode())
except Exception as e:
self.__log.warning(e)
else:
self.__log.debug("Discarding binary message from %s.", self.__peer)
def command(self, command, arg=""):
e = ltd.Encoder("h")
e.add_field_str(command, append_null=False)
e.add_field_str(arg, append_null=True)
self.__write__(e.encode())
def __open_message__(self, message):
for part in wrap(message, 200):
e = ltd.Encoder("b")
e.add_field_str(part, append_null=True)
self.__client.send(e.encode())
def wall(self, session_id, message):
e = ltd.Encoder("f")
e.add_field_str("WALL", append_null=False)
e.add_field_str(message, append_null=True)
self.broker.broadcast(e.encode())
def __private_message__(self, receiver, message):
for part in wrap(message, 200):
e = ltd.Encoder("h")
e.add_field_str("m")
e.add_field_str("%s %s" % (receiver, part), append_null=True)
self.__client.send(e.encode())
def command(self, command, arg):
e = ltd.Encoder("h")
e.add_field_str(command, append_null=arg is None)
if arg:
e.add_field_str(arg if not arg is None else "", append_null=True)
self.__write__(e.encode())
def __broadcast__(self, receiver, message):
e = ltd.Encoder("m")
e.add_field_str(receiver, append_null=False)
e.add_field_str(message, append_null=True)
pkg = e.encode()
for c in self.__connections:
c.write(pkg)
def cancel_shutdown(self, session_id):
self.__test_admin__(session_id)
self.__shutdown.cancel()
e = ltd.Encoder("f")
e.add_field_str("WALL", append_null=False)
e.add_field_str("Server shutdown cancelled.", append_null=True)
self.broker.broadcast(e.encode())
def login(self, loginid, nick, group="", password="", address=""):
e = ltd.Encoder("a")
e.add_field_str(loginid)
e.add_field_str(nick)
e.add_field_str(group)
e.add_field_str("login")
e.add_field_str(password)
e.add_field_str("")
e.add_field_str(address)
self.__transport.write(e.encode())
self.__state.nick = nick
def shutdown(self, session_id, delay, restart):
self.__test_admin__(session_id)
msg = "Server %s in %s." % ("restarting" if restart else "shutting down", dateutils.elapsed_time(delay))
if restart:
self.__shutdown.restart(delay)
else:
self.__shutdown.halt(delay)
e = ltd.Encoder("f")
e.add_field_str("WALL", append_null=False)
e.add_field_str(msg, append_null=True)
self.broker.broadcast(e.encode())
def send(self, session_id, receiver, message):
loggedin_session = self.session.find_nick(receiver)
if loggedin_session:
state = self.session.get(session_id)
max_len = 254 - validate.NICK_MAX - 5
for part in wrap(message, max_len):
e = ltd.Encoder("c")
e.add_field_str(state.nick, append_null=False)
e.add_field_str(part, append_null=True)
self.broker.deliver(loggedin_session, e.encode())
if state.echo == session.EchoMode.VERBOSE:
self.broker.deliver(
session_id,
ltd.encode_co_output("<*to: %s*> %s" %
(receiver, part)))
loggedin_state = self.session.get(loggedin_session)
if loggedin_state.away:
if not self.__away_table.is_alive(session_id, receiver):
self.broker.deliver(
session_id,
ltd.encode_status_msg(
"Away", "%s (since %s)." %
(loggedin_state.away,
loggedin_state.t_away.elapsed_str())))
self.__away_table.set_alive(
session_id, receiver,
self.config.timeouts_away_message)
else:
raise LtdErrorException("%s is not signed on." % receiver)
def __show_group__(self, session_id, state, info, logins, is_admin,
ignore_visibility, msgid):
show_group = True
display_name = str(info)
if not ignore_visibility and info.visibility != group.Visibility.VISIBLE:
if is_admin or state.group == info.key:
display_name = "*%s*" % str(info)
else:
display_name = "-SECRET-"
show_group = info.visibility != group.Visibility.INVISIBLE
if show_group:
moderator = logins[
info.moderator].nick if info.moderator else "(None)"
flags = "%s%s%s" % (chr(
info.control.value), chr(
info.visibility.value), chr(info.volume.value))
topic = info.topic if info.topic else "(None)"
self.broker.deliver(
session_id,
ltd.encode_co_output(
"Group: %-8s (%s) Mod: %-13s Topic: %s" %
(display_name, flags, moderator, topic), msgid))
self.broker.deliver(
session_id,
ltd.encode_co_output(
" Nickname Idle Sign-On Account", msgid))
subscribers = sorted(
[[sub_id, logins[sub_id]]
for sub_id in self.broker.get_subscribers(info.key)],
key=lambda arg: arg[1].nick.lower())
status_util = UserStatus()
for sub_id, sub_state in subscribers:
admin_flag = core.MODERATOR_FLAG if info.moderator == sub_id else " "
status_flags = status_util.get_flags(sub_state)
status = "(%s)" % ", ".join(
status_flags) if status_flags else ""
idle = int(
sub_state.t_recv.elapsed()) if sub_state.t_recv else 0
signon = int(sub_state.signon.timestamp())
e = ltd.Encoder("i")
e.add_field_str("wl", append_null=False)
e.add_field_str(admin_flag, append_null=False)
e.add_field_str(sub_state.nick, append_null=False)
e.add_field_str(str(idle), append_null=False)
e.add_field_str("0", append_null=False)
e.add_field_str(str(signon), append_null=False)
e.add_field_str(sub_state.loginid, append_null=False)
e.add_field_str(sub_state.host, append_null=False)
e.add_field_str(status, append_null=True)
self.broker.deliver(session_id, e.encode())
return show_group
