python-talk/server.py

620 lines
26 KiB
Python
Raw Normal View History

#!/usr/bin/python3
2024-06-15 03:14:45 +00:00
import os, sys, asyncio, re, signal
from platform import uname
from traceback import format_exc
2024-06-15 03:14:45 +00:00
from logs import log
class LinksDownException(Exception): ...
2024-06-15 03:14:45 +00:00
class Globals: ...
2024-07-16 21:24:59 +00:00
# The two below lines are a hacky fix for python 3.10 asyncio
2024-07-16 21:22:35 +00:00
TimoutError = TimeoutError
2024-07-16 21:24:59 +00:00
TimeoutError = (TimoutError, asyncio.exceptions.TimeoutError)
2024-06-15 03:14:45 +00:00
G = Globals()
G.uniqueClients = 0
2024-07-05 05:31:47 +00:00
G.servers = {}
G.clientsConnected = {}
2024-06-15 03:14:45 +00:00
port = 65048
G.msgs = []
G.remoteID = uname().node
2024-06-15 03:14:45 +00:00
G.event = asyncio.Event()
G.loop = asyncio.get_event_loop()
G.interruptCount = 0
2024-07-13 10:16:30 +00:00
G.killList = {}
G.outboundLinks = []
G.S2SLogs = []
G.cwlgd = False
2024-07-13 08:28:37 +00:00
saveLogs = True
address = "0.0.0.0"
2024-06-15 03:14:45 +00:00
# Try to load a message log, if one exists
try:
G.msgs = __import__("cache").msgs
log(f"Got {len(G.msgs)} lines from message cache")
except ImportError:
log("No server message cache.", level="WARN")
except Exception:
log(
"Abnormal state! Failed to load cache even though the file exists!",
level="WARN",
)
try:
filename = sys.argv.pop(0) # Ignore the filename
2024-06-15 03:14:45 +00:00
for arg in sys.argv:
2024-07-13 10:16:30 +00:00
if arg.startswith("--port") or arg.startswith("-p"):
port = int(arg.lstrip("-port="))
elif arg in ["-c", "--no-cache"]:
2024-06-15 03:14:45 +00:00
log("Explicitly erasing cached messages")
G.msgs = []
elif arg in ["-?", "-h", "--help"]:
print(
f"""python3 {filename} <args>
All arguments are optional!
All areguments are *expected* to only be specified once, if it appears mutliple times, the last one takes priority.
The exception to the above rule is `--link`, since you could want to link to multiple other servers.
Accepted arguments:
-?, -h, --help - Triggers this help dialog
-l, --no-logs - Disables the saving of logs when the server shuts down
-c, --no-cache - Disables the loading of cached messages when the server boots
-p<number>, --port=<number> - Sets the port for the server to use, defaults to `65048`
--link=<host>:<port> - Establishes an S2S link with remote server <host> on port <port> when the server starts up
--hostname=<string> - Sets the hostname for this server to use when talking to other servers. Defaults to the current system's hostname (limit of 16 chars)
--address=<IP> - Sets the IP to listen on, defaults to all addresses (0.0.0.0)
--cwlgd - Crashes the server when outbound links go down
Examples:
python3 {filename} --hostname=Fun-chat --link=chat.example.com:65048 --port=92628
python3 {filename} --no-logs --no-cache
python3 {filename} --address=127.0.0.1 -l -p=7288"""
)
2024-06-15 03:14:45 +00:00
exit(0)
2024-07-13 08:28:37 +00:00
elif arg in ["-l", "--no-logs"]:
2024-07-13 10:16:30 +00:00
log("Explicitly disabling saving of logs!")
2024-07-13 08:28:37 +00:00
saveLogs = False
2024-07-13 10:16:30 +00:00
elif arg.startswith("--link"):
G.outboundLinks.append((arg[7:].split(":")[0], int(arg.split(":")[1])))
2024-07-14 05:17:40 +00:00
elif arg.startswith("--hostname"):
G.remoteID = arg[11:]
2024-07-16 21:45:26 +00:00
if not G.remoteID or len(G.remoteID) > 16:
raise ValueError
2024-07-14 05:17:40 +00:00
elif arg.startswith("--address"):
address = arg[9:]
elif arg.startswith("--cwlgd"):
G.cwlgd = True
log("Server will crasg when outbound links go down!", "WARN")
2024-07-13 10:16:30 +00:00
else:
log(f"Unrecognized argument {arg}!", "WARN")
2024-06-15 03:14:45 +00:00
except Exception:
sys.tracebacklimit = 0
raise ValueError("Invalid arguments. Please refer to --help for usage.") from None
if not saveLogs:
2024-07-15 18:38:36 +00:00
G.msgs.append(
b"[00-00-0000 00:00:00] Notice: Logging is disabled on this server instance!\n"
)
2024-07-16 21:45:26 +00:00
if len(G.remoteID) > 16:
G.remoteID = G.remoteID[:15]
2024-06-15 03:14:45 +00:00
2024-07-16 21:45:26 +00:00
2024-07-05 05:31:47 +00:00
def raw(string: str) -> str:
s = string.strip()
2024-07-13 08:28:37 +00:00
s = f"{s!r}"[1:-1].replace("\\\\", "\\")
if '"' in s:
return s.replace("\\'", "'")
else:
return s
2024-07-05 05:31:47 +00:00
def fmt(msg: str, name: str = "", action: bool = False) -> str:
if action:
return f"* {name}{' '*(20-len(name))} {msg}"
else:
return f" {name}{' '*(20-len(name))}: {msg}"
2024-07-13 08:28:37 +00:00
2024-07-13 11:28:41 +00:00
async def handleClient(reader, writer):
2024-06-15 03:14:45 +00:00
try:
global G
2024-07-05 05:31:47 +00:00
writer.write(b"Please identify yourself. Nick limit is 20 chars.\n")
2024-06-15 03:14:45 +00:00
await writer.drain()
2024-07-05 05:31:47 +00:00
name = raw((await reader.read(20)).decode("utf8"))
2024-06-15 03:14:45 +00:00
if len(name) > 20:
name = name[
:19
] # Really this is only possible if someone passes raw unicode as a nick, but let's clean it up anyways.
try:
await asyncio.wait_for(
reader.read(), 0.01
2024-07-13 08:28:37 +00:00
) # Silently consume the excess username data
2024-07-16 21:27:35 +00:00
except TimeoutError:
2024-06-15 03:14:45 +00:00
pass
if not name:
writer.write(b"Nice try. Actually set a nick.\n")
await writer.drain()
writer.close()
await writer.wait_closed()
return
2024-07-14 07:04:31 +00:00
if name.lower() in G.clientsConnected:
2024-06-15 03:14:45 +00:00
writer.write(f"Nick ({name}) in use\n".encode("utf8"))
await writer.drain()
writer.close()
await writer.wait_closed()
return
2024-07-05 05:31:47 +00:00
if not name.startswith("S2S-"):
G.clientsConnected[name.lower()] = G.remoteID
2024-07-05 05:31:47 +00:00
msgIndex = 0
G.uniqueClients += 1
G.msgs.extend([log(f"{name} has connected to the server.")])
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("+", name, G.remoteID))
2024-07-05 05:31:47 +00:00
while 1:
try:
buffer = await asyncio.wait_for(reader.read(967), 0.1)
request = raw(buffer.decode("utf8"))
response = None
if request.startswith("/mes "):
response = log(f"* {name}'s {request[5:]}")
G.S2SLogs.append(("A", (name + "'s", request[5:]), G.remoteID))
2024-07-05 05:31:47 +00:00
elif request.startswith("/me "):
response = log(f"* {name} {request[4:]}")
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("A", (name, request[4:]), G.remoteID))
2024-07-05 05:31:47 +00:00
elif request.startswith("/h"):
writer.write(
b"""Command List:
/me <action> - Sends a special message so it looks like you did <action>
/mes <action> - Same as /me, but adds a 's onto your nick
/afk [reason] - Optional reason, short hand for `/me is afk [to [reason]]`
/h, /help - Triggers this command listing
/back - Shorthand for `/me is back`
/stats - Sends you some server stats
/quit - Disconnects you from the server\n"""
)
2024-07-05 05:31:47 +00:00
await writer.drain()
elif request.startswith("/stats"):
writer.write(
f"""Server stats:
Linked servers: {len(G.servers)}
Connected clients: {G.uniqueClients}
2024-07-16 17:45:59 +00:00
Total Clients: {len(G.clientsConnected)}
2024-07-16 17:47:05 +00:00
Messages sent: {len(G.msgs)}
Please note that this is not network level statistics.\n""".encode(
"utf8"
)
)
2024-07-16 17:45:20 +00:00
await writer.drain()
2024-07-05 05:31:47 +00:00
elif request.startswith("/quit"):
break
2024-07-13 08:28:37 +00:00
elif request.startswith("/afk"):
if len(request) > 5:
2024-07-14 07:04:31 +00:00
response = log(f"* {name} is afk to {request[5:]}")
G.S2SLogs.append(
("A", (name, f"is afk to {request[5:]}"), G.remoteID)
)
2024-07-13 08:28:37 +00:00
else:
response = log(f"* {name} is afk")
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("A", (name, "is afk"), G.remoteID))
2024-07-13 08:28:37 +00:00
elif request.startswith("/back"):
response = log(f"* {name} is back")
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("A", (name, "is back"), G.remoteID))
2024-07-05 05:31:47 +00:00
elif request:
response = log(f" {name}: {request}")
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("M", (name, request), G.remoteID))
2024-07-05 05:31:47 +00:00
if response:
2024-07-14 07:04:31 +00:00
G.msgs.append(response)
2024-07-16 21:27:35 +00:00
except TimeoutError:
2024-07-05 05:31:47 +00:00
pass
if msgIndex < len(G.msgs):
writer.writelines(G.msgs[msgIndex:])
2024-07-13 08:28:37 +00:00
await writer.drain()
2024-07-05 05:31:47 +00:00
msgIndex = len(G.msgs)
2024-07-14 05:17:40 +00:00
if name.lower() in G.killList and G.killList[name.lower()]:
2024-07-13 08:28:37 +00:00
writer.write(b"Your client has been killed by the server\n")
2024-07-14 05:17:40 +00:00
G.killList[name.lower()] = False
2024-07-13 08:28:37 +00:00
break
2024-06-15 03:14:45 +00:00
await writer.drain()
2024-07-05 05:31:47 +00:00
writer.close()
await writer.wait_closed()
G.uniqueClients -= 1
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{name} has disconnected from the server."))
del G.clientsConnected[name.lower()]
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("-", name, G.remoteID))
2024-07-05 05:31:47 +00:00
else: # This is... probably a server?
sName = name[4:] # Trim off the S2S label
if (
2024-07-15 20:43:57 +00:00
G.servers.get(sName, False) != False
): # Have to explicitly check, empty list is False, but does not == False
writer.close()
await writer.wait_closed()
return # Server is already "linked", drop the connection
if G.remoteID == sName: # Hey! you can't *also* be ***me***!
writer.close()
await writer.wait_closed()
return # drop "us"
G.msgs.append(log(f"{sName} has linked to the network"))
2024-07-16 16:42:20 +00:00
G.servers[sName] = {}
2024-07-05 05:31:47 +00:00
msgIndex = 0
2024-07-14 07:04:31 +00:00
writer.write(b"I am awaiting your client listing.\n")
2024-07-05 05:31:47 +00:00
while 1:
2024-07-13 11:28:41 +00:00
client = raw((await reader.read(1024)).decode("utf8"))
2024-07-05 05:31:47 +00:00
if client == f"END OF CLIENT LISTING FROM {sName}":
break
if (
client.lower() in G.servers[sName]
or client.lower() in G.clientsConnected
):
2024-07-13 08:28:37 +00:00
writer.write(b"K Client rejected: Already exists\n")
await writer.drain()
2024-07-13 10:16:30 +00:00
continue
2024-07-13 11:28:41 +00:00
writer.write(b"I added that client.\n")
2024-07-13 08:28:37 +00:00
await writer.drain()
G.msgs.append(log(f"{client} has connected from {sName}"))
G.servers[sName][client.lower()] = False
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("+", client, sName))
2024-07-13 11:28:41 +00:00
writer.write(f"{G.remoteID}\n".encode("utf8"))
await writer.drain()
2024-07-14 07:04:31 +00:00
await reader.read(1024)
2024-07-13 11:28:41 +00:00
for client in G.clientsConnected:
writer.write(f"{client}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
await writer.drain()
2024-07-13 11:28:41 +00:00
resp = raw((await reader.read(1024)).decode("utf8"))
if resp.startswith("K"):
if G.clientsConnected[client] == G.remoteID:
G.killList[client] = True
else:
2024-07-16 19:24:17 +00:00
G.servers[G.clientsConnected[client]][client] = True
2024-07-13 11:28:41 +00:00
writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
await writer.drain()
2024-07-16 19:24:17 +00:00
for client in G.servers[sName]:
G.clientsConnected[client] = sName
2024-07-14 07:04:31 +00:00
msgInd = len(G.S2SLogs)
2024-07-05 05:31:47 +00:00
while 1:
2024-07-05 06:44:35 +00:00
try:
rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
buffer = raw(rawMsg.decode("utf8"))
match buffer[0]:
case "S": # Server notice
G.msgs.extend([log(buffer[2:])])
writer.write(b"I Mmm... Blueberries\n")
case "I":
pass
case "+":
cName = buffer[2:]
2024-07-14 05:17:40 +00:00
if cName.lower() not in G.clientsConnected:
2024-07-13 08:28:37 +00:00
G.msgs.append(
log(f"{cName} has connected from {sName}")
)
G.servers[sName][cName.lower()] = False
G.clientsConnected[cName.lower()] = sName
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("+", cName, sName))
2024-07-13 08:28:37 +00:00
writer.write(b"I Mmm... Pineapples\n")
else:
2024-07-14 05:17:40 +00:00
writer.write(f"K {cName}\n".encode("utf8"))
2024-07-05 06:44:35 +00:00
case "-":
cName = buffer[2:]
2024-07-16 19:24:17 +00:00
if G.clientsConnected.get(cName.lower(), None) == sName:
G.msgs.append(
log(f"{cName} has disconnected from {sName}")
)
del G.servers[sName][cName.lower()]
del G.clientsConnected[cName.lower()]
G.S2SLogs.append(("-", cName, sName))
writer.write(b"I Mmm... Bananas\n")
else:
writer.write(
2024-07-16 19:24:17 +00:00
f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
"utf8"
)
)
2024-07-05 06:44:35 +00:00
case "M":
cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split("|", 1)[1]
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f" {cName}: {message}"))
G.S2SLogs.append(("M", (cName, message), sName))
2024-07-13 08:28:37 +00:00
writer.write(
2024-07-14 07:04:31 +00:00
b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
2024-07-13 08:28:37 +00:00
)
2024-07-05 06:44:35 +00:00
case "A":
cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split("|", 1)[1]
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"* {cName} {message}"))
G.S2SLogs.append(("A", (cName, message), sName))
2024-07-13 08:28:37 +00:00
writer.write(b"I Mmm... Strawberries\n")
2024-07-05 06:44:35 +00:00
case "Q":
break
2024-07-13 08:28:37 +00:00
case "K":
cName = buffer[2:]
2024-07-16 19:07:02 +00:00
if G.clientsConnected[cName.lower()] == G.remoteID:
G.killList[cName.lower()] = True
else:
G.servers[G.clientsConnected[cName.lower()]][
cName.lower()
] = True
2024-07-13 08:28:37 +00:00
writer.write(b"I Mmm... Blood\n")
2024-07-05 06:44:35 +00:00
case _:
2024-07-13 08:28:37 +00:00
writer.write(
f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\n".encode(
"utf8"
)
2024-07-13 08:28:37 +00:00
)
2024-07-16 19:24:17 +00:00
log(
f"Recieved invalid message ({buffer}) from {sName}",
"WARN",
)
2024-07-13 10:16:30 +00:00
await writer.drain()
2024-07-05 06:44:35 +00:00
except TimeoutError:
pass
if any(G.servers[sName].values()):
for name in G.servers[sName]:
if G.servers[sName][name]:
writer.write(f"K {name}\n".encode("utf8"))
await writer.drain()
G.servers[sName][name] = False
2024-07-14 07:04:31 +00:00
while msgInd < len(G.S2SLogs):
type, data, server = G.S2SLogs[msgInd]
# match-case on type
if server != sName:
match type:
case "A":
nick, msg = data
writer.write(f"A {nick}|{msg}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
case "M":
nick, msg = data
writer.write(f"M {nick}|{msg}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
case "+":
writer.write(f"+ {data}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
case "-":
writer.write(f"- {data}\n".encode("utf8"))
2024-07-14 07:04:31 +00:00
case _:
pass
await writer.drain()
msgInd += 1
2024-07-13 10:16:30 +00:00
await writer.drain()
writer.close()
await writer.wait_closed()
for cName in G.servers[sName]:
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{cName}'s server is going down"))
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("-", cName, sName))
del G.clientsConnected[cName.lower()]
2024-07-14 07:04:31 +00:00
del G.servers[sName]
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{sName} has de-linked from the network"))
except (
ConnectionResetError,
BrokenPipeError,
IndexError,
): # Don't ask. IndexError needs to be caught here too.
2024-07-05 05:31:47 +00:00
if not name.startswith("S2S-"):
2024-07-05 06:44:35 +00:00
G.uniqueClients -= 1
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{name} has disconnected from the server."))
2024-07-14 07:04:31 +00:00
G.S2SLogs.append(("-", name, G.remoteID))
del G.clientsConnected[name.lower()]
2024-07-05 05:31:47 +00:00
else:
2024-07-13 10:16:30 +00:00
for cName in G.servers[name[4:]]:
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{cName}'s server is going down"))
try:
del G.clientsConnected[cName.lower()]
G.S2SLogs.append(("-", cName, name[4:]))
2024-07-13 08:28:37 +00:00
except Exception: # Crash during connection sequence?
pass
2024-07-14 07:04:31 +00:00
del G.servers[name[4:]]
2024-07-13 08:28:37 +00:00
G.msgs.append(log(f"{name[4:]} has de-linked from the network"))
2024-06-15 03:14:45 +00:00
2024-07-13 10:16:30 +00:00
async def connectServer(hostname: str, port: int):
global G
2024-07-13 10:16:30 +00:00
reader, writer = await asyncio.open_connection(hostname, port)
await reader.read(1024)
writer.write(f"S2S-{G.remoteID}\n".encode("utf8"))
await writer.drain()
await reader.read(1024)
for client in G.clientsConnected:
writer.write(f"{client}\n".encode("utf8"))
await writer.drain()
2024-07-13 11:28:41 +00:00
resp = raw((await reader.read(1024)).decode("utf8"))
if resp.startswith("K"):
if G.clientsConnected[client] == G.remoteID:
G.killList[client] = True
else:
2024-07-16 19:24:17 +00:00
G.servers[G.clientsConnected[client]][client] = True
2024-07-13 11:28:41 +00:00
writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
2024-07-13 10:16:30 +00:00
await writer.drain()
rID = raw((await reader.read(16)).decode("utf8"))
try:
await asyncio.wait_for(reader.read(1024), 0.1)
2024-07-15 20:46:47 +00:00
except TimeoutError:
pass
2024-07-15 20:43:57 +00:00
if G.servers.get(rID, False) != False:
writer.close()
await writer.wait_closed()
return
if G.remoteID == rID:
writer.close()
await writer.wait_closed()
return
G.msgs.append(log(f"{rID} has linked to the network"))
2024-07-16 16:42:20 +00:00
G.servers[rID] = {}
2024-07-13 11:28:41 +00:00
writer.write(b"I recieved your remote ID, now awaiting client listing\n")
2024-07-14 07:04:31 +00:00
await writer.drain()
2024-07-13 10:16:30 +00:00
# recieve client list from the other server
2024-07-13 11:28:41 +00:00
while 1:
client = raw((await reader.read(1024)).decode("utf8"))
if client == f"END OF CLIENT LISTING FROM {rID}":
break
2024-07-14 05:17:40 +00:00
if client.lower() in G.servers[rID] or client.lower() in G.clientsConnected:
2024-07-13 11:28:41 +00:00
writer.write(b"K Client rejected: Already exists\n")
await writer.drain()
continue
writer.write(b"I added that client.\n")
await writer.drain()
G.msgs.append(log(f"{client} has connected from {rID}"))
G.servers[rID][client.lower()] = False
for client in G.servers[rID]:
G.clientsConnected[client] = rID
msgInd = len(G.S2SLogs)
2024-07-14 04:12:40 +00:00
try:
while 1:
try:
rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
buffer = raw(rawMsg.decode("utf8"))
match buffer[0]:
case "S":
G.msgs.extend([log(buffer[2:])])
writer.write(b"I Mmm... Blueberries\n")
case "I":
pass
case "+":
cName = buffer[2:]
2024-07-14 05:17:40 +00:00
if cName.lower() not in G.clientsConnected:
2024-07-14 04:12:40 +00:00
G.msgs.append(log(f"{cName} has connected from {rID}"))
G.S2SLogs.append(("+", cName, rID))
G.servers[rID][cName.lower()] = False
G.clientsConnected[cName.lower()] = rID
2024-07-14 04:12:40 +00:00
writer.write(b"I Mmm... Pineapples\n")
else:
writer.write(f"K {cName}\n".encode("utf8"))
case "-":
cName = buffer[2:]
2024-07-16 19:24:17 +00:00
if G.clientsConnected.get(cName.lower(), None) == rID:
G.msgs.append(log(f"{cName} has disconnected from {rID}"))
del G.servers[rID][cName.lower()]
del G.clientsConnected[cName.lower()]
G.S2SLogs.append(("-", cName, rID))
else:
writer.write(
2024-07-16 19:24:17 +00:00
f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
"utf8"
)
)
2024-07-14 04:12:40 +00:00
case "M":
cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split("|", 1)[1]
G.msgs.append(log(f" {cName}: {message}"))
G.S2SLogs.append(("M", (cName, message), rID))
2024-07-14 04:12:40 +00:00
writer.write(
2024-07-14 07:04:31 +00:00
b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
2024-07-14 04:12:40 +00:00
)
case "A":
cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split("|", 1)[1]
G.S2SLogs.append(("A", (cName, message), rID))
2024-07-14 04:12:40 +00:00
G.msgs.append(log(f"* {cName} {message}"))
writer.write(b"I Mmm... Strawberries\n")
case "Q":
break
case "K":
cName = buffer[2:]
2024-07-16 19:07:02 +00:00
if G.clientsConnected[cName.lower()] == G.remoteID:
G.killList[cName.lower()] = True
else:
G.servers[G.clientsConnected[cName.lower()]][
cName.lower()
] = True
2024-07-14 04:12:40 +00:00
writer.write(b"I Mmm... Blood\n")
case _:
writer.write(
f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\n".encode(
"utf8"
)
)
2024-07-16 19:24:17 +00:00
log(f"Recieved invalid message ({buffer}) from {sName}", "WARN")
2024-07-14 04:12:40 +00:00
await writer.drain()
except TimeoutError:
pass
if any(G.servers[rID].values()):
for name in G.servers[rID]:
if G.servers[rID][name]:
writer.write(f"K {name}\n".encode("utf8"))
await writer.drain()
G.servers[rID][name] = False
while msgInd < len(G.S2SLogs):
type, data, server = G.S2SLogs[msgInd]
if server != rID:
match type:
case "A":
nick, msg = data
writer.write(f"A {nick}|{msg}\n".encode("utf8"))
case "M":
nick, msg = data
writer.write(f"M {nick}|{msg}\n".encode("utf8"))
case "+":
writer.write(f"+ {data}\n".encode("utf8"))
case "-":
writer.write(f"- {data}\n".encode("utf8"))
case _:
pass
await writer.drain()
msgInd += 1
if G.cwlgd:
raise LinksDownException
await writer.drain()
writer.close()
await writer.wait_closed()
for cName in G.servers[rID]:
G.msgs.append(log(f"{cName}'s server is going down"))
del G.clientsConnected[cName.lower()]
2024-07-15 23:37:15 +00:00
del G.servers[rID]
G.msgs.append(log(f"{rID} has de-linked from the network"))
except (ConnectionResetError, BrokenPipeError, IndexError):
if G.cwlgd:
raise LinksDownException
2024-07-14 04:12:40 +00:00
for cName in G.servers[rID]:
G.msgs.append(log(f"{cName}'s server is going down"))
try:
del G.clientsConnected[cName.lower()]
2024-07-14 04:12:40 +00:00
except Exception:
pass
2024-07-15 23:37:15 +00:00
del G.servers[rID]
2024-07-14 04:12:40 +00:00
G.msgs.append(log(f"{rID} has de-linked from the network"))
2024-07-13 10:16:30 +00:00
2024-07-14 05:17:40 +00:00
async def runServer(address: str, port: int):
2024-06-15 03:14:45 +00:00
global G
2024-07-14 05:17:40 +00:00
server = await asyncio.start_server(handleClient, address, port)
2024-06-15 03:14:45 +00:00
log(f"Listening on port {port}...")
2024-07-13 08:28:37 +00:00
G.msgs.append(log("Server startup"))
2024-07-13 10:16:30 +00:00
links = []
for hostname, portNum in G.outboundLinks:
links.append(connectServer(hostname, portNum))
2024-06-15 03:14:45 +00:00
crash = False
try:
2024-07-13 10:16:30 +00:00
links.append(G.event.wait())
await asyncio.gather(*links)
2024-06-15 03:14:45 +00:00
except Exception:
crash = True
G.msgs.append(log("Server crash", "FATAL")[1:])
log("Shutting down from Exception", "FATAL")
Err = format_exc()
for line in Err.split("\n"):
log(line, "ERROR")
2024-06-15 03:14:45 +00:00
finally:
if not crash:
2024-07-13 10:16:30 +00:00
G.msgs.append(log("Server shutdown"))
2024-06-15 03:14:45 +00:00
log("Kicking all clients as we go down")
server.close()
# server.abort_clients()
2024-07-13 08:28:37 +00:00
if saveLogs:
with open("cache.py", "w") as cache:
cache.write(f"msgs = {G.msgs}\n")
log("Saved logs, exiting now.")
else:
log("Not saving logs, exiting now.")
2024-06-15 03:14:45 +00:00
class ServerInterruptException(KeyboardInterrupt): ...
def interruptCatch(s, f):
global G
print()
G.loop.call_soon_threadsafe(G.event.set)
G.interruptCount += 1
sys.tracebacklimit = 0
raise ServerInterruptException from None
signal.signal(signal.SIGINT, interruptCatch)
2024-07-14 05:17:40 +00:00
asyncio.run(runServer(address, port))