Firepup650/python-talk
2
1
Fork 1
Code Issues Pull requests Activity Actions

Compare commits

base: Firepup650:master
Branches Tags
Firepup650:master
VenomousSteam81:master
..
compare: VenomousSteam81:master
Branches Tags
VenomousSteam81:master
Firepup650:master

1 commit
master ... master

Author SHA1 Message Date
VenomousSteam81
7bfe8dda2b make server.py executable. you can now run ./server.py instead of python3 server.py 2024-07-16 22:40:04 +00:00
7 changed files with 243 additions and 443 deletions
Show stats Expand all files Collapse all files

1
.gitignore vendored
View file

@ -2,4 +2,3 @@ __pycache__/**
.env .env
cache.py cache.py
*.swp *.swp
bugs.txt

35
IRC-spec.txt
View file

@ -1,35 +0,0 @@
# On-connect
:<servername> CAP * LS :
:<servername> 001 <client> :Welcome to the python-talk Network, <client>
:<servername> 002 <client> :Your host is <servername>, running version 0.1
:<servername> 003 <client> :This server was created 0
:<servername> 004 <client> python-talk 0.1 r t
:<servername> 005 <client> AWAYLEN=200,CASEMAPPING=ascii,CHANTYPES=#,ELIST=U,HOSTLEN=16 :are supported by this server
:<servername> 005 <client> CHANLIMIT=#:1,CHANMODES=b,k,l,t,CHANNELLEN=4,KICKLEN=1,MAXLIST=b:1 :are supported by this server
:<servername> 005 <client> MODES=4,NETWORK=talknet,NICKLEN=20,TOPICLEN=30,USERLEN=1 :are supported by this server
:<servername> 251 <client> :There are <u> users and 0 invisible on <s> servers
:<servername> 252 <client> 0 :operator(s) online
:<servername> 253 <client> 0 :unknown connection(s)
:<servername> 254 <client> 1 :channel formed
:<servername> 255 <client> :I have <c> clients and <s> servers
:<servername> 265 <client> [<u> <m>] :Current local users <u>, max <m>
:<servername> 266 <client> [<u> <m>] :Current global users <u>, max <m>
:<servername> 422 <client> :This server does not support MOTDs
:<client> JOIN #main
:<servername> 324 <client> #main t
:<servername> 332 <client> #main :Welcome to the main channel!
:<servername> 353 <client> = #main :<client>, ...other clients here...
:<servername> 366 <client> #main :End of /NAMES list
# On Attempting to join/part a channel, or anything else I don't want to deal with
:<servername> 421 <client> <command> :Unknown command
# I should probably return the "NOSUCHCHANNEL" thing for joins
#PING PONG
:<servername> PONG <servername> :<data>
# If the user tries to kill us or another server, respond with an easter egg
:<servername> 483 <client> :You can't kill me, I'm Skynet!
# Otherwise, if the user exists:
:<servername> 481 <client> :Permission Denied- There are no IRC operators here.
# Otherwise:
:<servername> 401 <client> <nickname> :No such nick/channel

13
init-scripts/freebsd-rc
View file

@ -1,13 +0,0 @@
#!/bin/sh
. /etc/rc.subr
name="python_talk"
start_cmd="${name}_start"
stop_cmd=":"
rcvar=python_talk_enable
load_rc_config $name
: ${python_talk_enable:=no}
python_talk_start() {
cd /usr/src/python-talk
(while true; do python3 server.py --link=37.27.51.34:65048 --no-log --no-cache --cwlgd 2>&1 >> /var/log/python-talk.log; done) &
}
run_rc_command "$1"

38
init-scripts/systemd-system.service
View file

@ -1,38 +0,0 @@
[Unit]
Description=firepup's python-talk
[Service]
DynamicUser=yes
WorkingDirectory=/opt/python-talk
ExecStart=/usr/bin/python3 server.py --link=37.27.51.34:65048 --no-logs --no-cache --cwlgd
Restart=always
RestartSec=5
NoNewPrivileges=true
RestrictSUIDSGID=true
ProtectSystem=strict
ProtectHome=true
ProtectProc=ptraceable
ProcSubset=pid
PrivateTmp=true
CapabilityBoundingSet=
PrivateDevices=true
ProtectClock=true
ProtectKernelLogs=true
ProtectControlGroups=true
ProtectKernelModules=true
SystemCallArchitectures=native
# python.
MemoryDenyWriteExecute=false
RestrictNamespaces=true
ProtectHostname=true
LockPersonality=true
ProtectKernelTunables=true
RestrictAddressFamilies=AF_INET
RestrictRealtime=true
PrivateUsers=true
SystemCallFilter=@system-service
SystemCallFilter=~@privileged @resources
UMask=0077
[Install]
WantedBy=multi-user.target

38
init-scripts/systemd-user.service
View file

@ -1,38 +0,0 @@
[Unit]
Description=firepup's python-talk
[Service]
WorkingDirectory=%h/python-talk
ExecStart=/usr/bin/python3 server.py --link=37.27.51.34:65048 --no-logs --no-cache --cwlgd
Restart=always
RestartSec=5
NoNewPrivileges=true
RestrictSUIDSGID=true
ProtectSystem=strict
ProtectHome=tmpfs
BindReadOnlyPaths=%h/python-talk
ProtectProc=ptraceable
ProcSubset=pid
PrivateTmp=true
CapabilityBoundingSet=
PrivateDevices=true
ProtectClock=true
ProtectKernelLogs=true
ProtectControlGroups=true
ProtectKernelModules=true
SystemCallArchitectures=native
# python.
MemoryDenyWriteExecute=false
RestrictNamespaces=true
ProtectHostname=true
LockPersonality=true
ProtectKernelTunables=true
RestrictAddressFamilies=AF_INET
RestrictRealtime=true
PrivateUsers=true
SystemCallFilter=@system-service
SystemCallFilter=~@privileged @resources
UMask=0077
[Install]
WantedBy=default.target

8
logs.py
View file

@ -30,16 +30,12 @@ def log(
print( print(
f"[{level}]{'['+origin+']' if origin else ''}[{time}] {message}", f"[{level}]{'['+origin+']' if origin else ''}[{time}] {message}",
file=stream, file=stream,
flush=True,
) )
else: else:
for line in message.split("\n"): for line in message.split("\n"):
log = ( log = log + f"\n[{level}]{'['+origin+']' if origin else ''}[{time}] {line}"
log + f"\r\n[{level}]{'['+origin+']' if origin else ''}[{time}] {line}"
)
print( print(
f"[{level}]{'['+origin+']' if origin else ''}[{time}] {line}", f"[{level}]{'['+origin+']' if origin else ''}[{time}] {line}",
file=stream, file=stream,
flush=True,
) )
return (log[5:] + "\r\n").encode("utf8") return (log[5:] + "\n").encode("utf8")

553
server.py
View file

@ -1,27 +1,20 @@
#!/usr/bin/python3 #!/usr/bin/python3
import os, sys, asyncio, re, signal, socket, random
import os, sys, asyncio, re, signal
from platform import uname from platform import uname
from traceback import format_exc from traceback import format_exc
from logs import log from logs import log
class LinkDownError(Exception): ... class LinksDownException(Exception): ...
class FailedLinkError(Exception): ...
class Globals: ... class Globals: ...
TimeoutErrors = (TimeoutError, asyncio.exceptions.TimeoutError) # The two below lines are a hacky fix for python 3.10 asyncio
DisconnectErrors = ( TimoutError = TimeoutError
ConnectionResetError, TimeoutError = (TimoutError, asyncio.exceptions.TimeoutError)
BrokenPipeError,
IndexError,
UnicodeDecodeError,
*TimeoutErrors,
)
G = Globals() G = Globals()
G.uniqueClients = 0 G.uniqueClients = 0
G.servers = {} G.servers = {}
@ -36,11 +29,8 @@ G.killList = {}
G.outboundLinks = [] G.outboundLinks = []
G.S2SLogs = [] G.S2SLogs = []
G.cwlgd = False G.cwlgd = False
G.NUL = "\x1e"
G.IRCStats = {"users": {"localMax": 0, "localCurrent": 0, "globalMax": 0, "globalCurrent": 0}, "servers": 0}
G.queue = []
saveLogs = True saveLogs = True
address = "::" address = "0.0.0.0"
# Try to load a message log, if one exists # Try to load a message log, if one exists
try: try:
G.msgs = __import__("cache").msgs G.msgs = __import__("cache").msgs
@ -61,9 +51,8 @@ try:
log("Explicitly erasing cached messages") log("Explicitly erasing cached messages")
G.msgs = [] G.msgs = []
elif arg in ["-?", "-h", "--help"]: elif arg in ["-?", "-h", "--help"]:
filename = filename if filename.startswith("./") else "python3 " + filename
print( print(
f"""{filename} <args> f"""python3 {filename} <args>
All arguments are optional! All arguments are optional!
All areguments are *expected* to only be specified once, if it appears mutliple times, the last one takes priority. 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. The exception to the above rule is `--link`, since you could want to link to multiple other servers.
@ -76,31 +65,27 @@ Accepted arguments:
--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) --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) --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 --cwlgd - Crashes the server when outbound links go down
-r, --random-port - Randomizes the port to listen on
Examples: Examples:
{filename} --hostname=Fun-chat --link=chat.example.com:65048 --port=92628 python3 {filename} --hostname=Fun-chat --link=chat.example.com:65048 --port=92628
{filename} --no-logs --no-cache python3 {filename} --no-logs --no-cache
{filename} --address=127.0.0.1 -l -p=7288""" python3 {filename} --address=127.0.0.1 -l -p=7288"""
) )
exit(0) exit(0)
elif arg in ["-l", "--no-logs"]: elif arg in ["-l", "--no-logs"]:
log("Explicitly disabling saving of logs!") log("Explicitly disabling saving of logs!")
saveLogs = False saveLogs = False
elif arg.startswith("--link="): elif arg.startswith("--link"):
G.outboundLinks.append((arg[7:].split(":")[0], int(arg.split(":")[1]))) G.outboundLinks.append((arg[7:].split(":")[0], int(arg.split(":")[1])))
elif arg.startswith("--hostname="): elif arg.startswith("--hostname"):
G.remoteID = arg[11:] G.remoteID = arg[11:]
if not G.remoteID or len(G.remoteID) > 16: if not G.remoteID or len(G.remoteID) > 16:
raise ValueError raise ValueError
elif arg.startswith("--address="): elif arg.startswith("--address"):
address = arg[10:] address = arg[9:]
elif arg in ["--cwlgd"]: elif arg.startswith("--cwlgd"):
G.cwlgd = True G.cwlgd = True
log("Server will crash when outbound links go down!", "WARN") log("Server will crasg when outbound links go down!", "WARN")
elif arg in ["-r", "--random-port"]:
random.seed()
port = random.randint(10000, 60000)
else: else:
log(f"Unrecognized argument {arg}!", "WARN") log(f"Unrecognized argument {arg}!", "WARN")
except Exception: except Exception:
@ -109,31 +94,12 @@ except Exception:
if not saveLogs: if not saveLogs:
G.msgs.append( G.msgs.append(
b"[00-00-0000 00:00:00] Notice: Logging is disabled on this server instance!\r\n" b"[00-00-0000 00:00:00] Notice: Logging is disabled on this server instance!\n"
) )
if len(G.remoteID) > 16: if len(G.remoteID) > 16:
G.remoteID = G.remoteID[:15] G.remoteID = G.remoteID[:15]
async def getMessage(reader, localQueue: list, size: int = 0, timeout: float = 0, sanitize: bool = False) -> str:
if not localQueue:
data = ""
if timeout and timeout > 0:
data = await asyncio.wait_for(reader.read(size), timeout)
else:
data = await reader.read(size)
localQueue = data.decode("utf8").strip().split("\r\n")
tmp = localQueue.pop(0)
if sanitize:
tmp = raw(tmp)
if size and size > 0:
other = tmp[size:]
tmp = tmp[:size]
if other:
localQueue.insert(0, other)
return tmp, localQueue
def raw(string: str) -> str: def raw(string: str) -> str:
s = string.strip() s = string.strip()
s = f"{s!r}"[1:-1].replace("\\\\", "\\") s = f"{s!r}"[1:-1].replace("\\\\", "\\")
@ -152,31 +118,33 @@ def fmt(msg: str, name: str = "", action: bool = False) -> str:
async def handleClient(reader, writer): async def handleClient(reader, writer):
try: try:
name = ""
global G global G
writer.write(b"Please identify yourself. Nick limit is 20 chars.\r\n") writer.write(b"Please identify yourself. Nick limit is 20 chars.\n")
await writer.drain() await writer.drain()
name, localQueue = await getMessage(reader, [], 20, 0, True) name = raw((await reader.read(20)).decode("utf8"))
localQueue = []
if len(name) > 20: if len(name) > 20:
name = name[ name = name[
:19 :19
] # Really this is only possible if someone passes raw unicode as a nick, but let's clean it up anyways. ] # 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
) # Silently consume the excess username data
except TimeoutError:
pass
if not name: if not name:
writer.write(b"Nice try. Actually set a nick.\r\n") writer.write(b"Nice try. Actually set a nick.\n")
await writer.drain() await writer.drain()
writer.close() writer.close()
await writer.wait_closed() await writer.wait_closed()
return return
if name.lower() in G.clientsConnected: if name.lower() in G.clientsConnected:
writer.write(f"Nick ({name}) in use\r\n".encode("utf8")) writer.write(f"Nick ({name}) in use\n".encode("utf8"))
await writer.drain() await writer.drain()
writer.close() writer.close()
await writer.wait_closed() await writer.wait_closed()
return return
if name == "CAP LS 302": if not name.startswith("S2S-"):
pass # TODO: IRC Logic
elif not name.startswith("S2S-"):
G.clientsConnected[name.lower()] = G.remoteID G.clientsConnected[name.lower()] = G.remoteID
msgIndex = 0 msgIndex = 0
G.uniqueClients += 1 G.uniqueClients += 1
@ -184,7 +152,8 @@ async def handleClient(reader, writer):
G.S2SLogs.append(("+", name, G.remoteID)) G.S2SLogs.append(("+", name, G.remoteID))
while 1: while 1:
try: try:
request, localQueue = await getMessage(reader, localQueue, 967, 0.1, True) buffer = await asyncio.wait_for(reader.read(967), 0.1)
request = raw(buffer.decode("utf8"))
response = None response = None
if request.startswith("/mes "): if request.startswith("/mes "):
response = log(f"* {name}'s {request[5:]}") response = log(f"* {name}'s {request[5:]}")
@ -194,25 +163,25 @@ async def handleClient(reader, writer):
G.S2SLogs.append(("A", (name, request[4:]), G.remoteID)) G.S2SLogs.append(("A", (name, request[4:]), G.remoteID))
elif request.startswith("/h"): elif request.startswith("/h"):
writer.write( writer.write(
b"""Command List:\r b"""Command List:
/me <action> - Sends a special message so it looks like you did <action>\r /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\r /mes <action> - Same as /me, but adds a 's onto your nick
/afk [reason] - Optional reason, short hand for `/me is afk [to [reason]]`\r /afk [reason] - Optional reason, short hand for `/me is afk [to [reason]]`
/h, /help - Triggers this command listing\r /h, /help - Triggers this command listing
/back - Shorthand for `/me is back`\r /back - Shorthand for `/me is back`
/stat - Sends you some server stats\r /stats - Sends you some server stats
/quit - Disconnects you from the server\r\n""" /quit - Disconnects you from the server\n"""
) )
await writer.drain() await writer.drain()
elif request.startswith("/stat"): elif request.startswith("/stats"):
writer.write( writer.write(
f"""Server stats:\r f"""Server stats:
Linked servers: {len(G.servers)}\r Linked servers: {len(G.servers)}
Connected clients: {G.uniqueClients}\r Connected clients: {G.uniqueClients}
Total Clients: {len(G.clientsConnected)}\r Total Clients: {len(G.clientsConnected)}
Messages sent: {len(G.msgs)}\r Messages sent: {len(G.msgs)}
\r
Please note that this is not network level statistics.\r\n""".encode( Please note that this is not network level statistics.\n""".encode(
"utf8" "utf8"
) )
) )
@ -236,14 +205,14 @@ Please note that this is not network level statistics.\r\n""".encode(
G.S2SLogs.append(("M", (name, request), G.remoteID)) G.S2SLogs.append(("M", (name, request), G.remoteID))
if response: if response:
G.msgs.append(response) G.msgs.append(response)
except TimeoutErrors: except TimeoutError:
pass pass
if msgIndex < len(G.msgs): if msgIndex < len(G.msgs):
writer.writelines(G.msgs[msgIndex:]) writer.writelines(G.msgs[msgIndex:])
await writer.drain() await writer.drain()
msgIndex = len(G.msgs) msgIndex = len(G.msgs)
if name.lower() in G.killList and G.killList[name.lower()]: if name.lower() in G.killList and G.killList[name.lower()]:
writer.write(b"Your client has been killed by the server\r\n") writer.write(b"Your client has been killed by the server\n")
G.killList[name.lower()] = False G.killList[name.lower()] = False
break break
await writer.drain() await writer.drain()
@ -261,54 +230,55 @@ Please note that this is not network level statistics.\r\n""".encode(
writer.close() writer.close()
await writer.wait_closed() await writer.wait_closed()
return # Server is already "linked", drop the connection return # Server is already "linked", drop the connection
if G.remoteID == sName or not sName: # Hey! you can't *also* be ***me***! if G.remoteID == sName: # Hey! you can't *also* be ***me***!
writer.close() writer.close()
await writer.wait_closed() await writer.wait_closed()
return # drop "us" return # drop "us"
G.msgs.append(log(f"{sName} has linked to the network")) G.msgs.append(log(f"{sName} has linked to the network"))
G.servers[sName] = {} G.servers[sName] = {}
msgIndex = 0 msgIndex = 0
writer.write(b"I am awaiting your client listing.\r\n") writer.write(b"I am awaiting your client listing.\n")
while 1: while 1:
client, localQueue = await getMessage(reader, localQueue, 1024, 0, True) client = raw((await reader.read(1024)).decode("utf8"))
if client == f"END OF CLIENT LISTING FROM {sName}": if client == f"END OF CLIENT LISTING FROM {sName}":
break break
if ( if (
client.lower() in G.servers[sName] client.lower() in G.servers[sName]
or client.lower() in G.clientsConnected or client.lower() in G.clientsConnected
): ):
writer.write(b"K Client rejected: Already exists\r\n") writer.write(b"K Client rejected: Already exists\n")
await writer.drain() await writer.drain()
continue continue
writer.write(b"I added that client.\r\n") writer.write(b"I added that client.\n")
await writer.drain() await writer.drain()
G.msgs.append(log(f"{client} has connected from {sName}")) G.msgs.append(log(f"{client} has connected from {sName}"))
G.servers[sName][client.lower()] = False G.servers[sName][client.lower()] = False
G.S2SLogs.append(("+", client, sName)) G.S2SLogs.append(("+", client, sName))
writer.write(f"{G.remoteID}\r\n".encode("utf8")) writer.write(f"{G.remoteID}\n".encode("utf8"))
await writer.drain() await writer.drain()
await reader.read(1024) await reader.read(1024)
for client in G.clientsConnected: for client in G.clientsConnected:
writer.write(f"{client}\r\n".encode("utf8")) writer.write(f"{client}\n".encode("utf8"))
await writer.drain() await writer.drain()
resp, localQueue = await getMessage(reader, localQueue, 1024, 0, True) resp = raw((await reader.read(1024)).decode("utf8"))
if resp.startswith("K"): if resp.startswith("K"):
if G.clientsConnected[client] == G.remoteID: if G.clientsConnected[client] == G.remoteID:
G.killList[client] = True G.killList[client] = True
else: else:
G.servers[G.clientsConnected[client]][client] = True G.servers[G.clientsConnected[client]][client] = True
writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\r\n".encode("utf8")) writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
await writer.drain() await writer.drain()
for client in G.servers[sName]: for client in G.servers[sName]:
G.clientsConnected[client] = sName G.clientsConnected[client] = sName
msgInd = len(G.S2SLogs) msgInd = len(G.S2SLogs)
while 1: while 1:
try: try:
buffer, localQueue = await getMessage(reader, localQueue, 1024, 0.1, False) rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
buffer = raw(rawMsg.decode("utf8"))
match buffer[0]: match buffer[0]:
case "S": # Server notice case "S": # Server notice
G.msgs.extend([log(buffer[2:])]) G.msgs.extend([log(buffer[2:])])
writer.write(b"I Mmm... Blueberries\r\n") writer.write(b"I Mmm... Blueberries\n")
case "I": case "I":
pass pass
case "+": case "+":
@ -320,9 +290,9 @@ Please note that this is not network level statistics.\r\n""".encode(
G.servers[sName][cName.lower()] = False G.servers[sName][cName.lower()] = False
G.clientsConnected[cName.lower()] = sName G.clientsConnected[cName.lower()] = sName
G.S2SLogs.append(("+", cName, sName)) G.S2SLogs.append(("+", cName, sName))
writer.write(b"I Mmm... Pineapples\r\n") writer.write(b"I Mmm... Pineapples\n")
else: else:
writer.write(f"K {cName}\r\n".encode("utf8")) writer.write(f"K {cName}\n".encode("utf8"))
case "-": case "-":
cName = buffer[2:] cName = buffer[2:]
if G.clientsConnected.get(cName.lower(), None) == sName: if G.clientsConnected.get(cName.lower(), None) == sName:
@ -332,43 +302,41 @@ Please note that this is not network level statistics.\r\n""".encode(
del G.servers[sName][cName.lower()] del G.servers[sName][cName.lower()]
del G.clientsConnected[cName.lower()] del G.clientsConnected[cName.lower()]
G.S2SLogs.append(("-", cName, sName)) G.S2SLogs.append(("-", cName, sName))
writer.write(b"I Mmm... Bananas\r\n") writer.write(b"I Mmm... Bananas\n")
else: else:
writer.write( writer.write(
f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\r\n".encode( f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
"utf8" "utf8"
) )
) )
case "M": case "M":
cName = buffer[2:].split(G.NUL, 1)[0] cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split(G.NUL, 1)[1] message = buffer[2:].split("|", 1)[1]
G.msgs.append(log(f" {cName}: {message}")) G.msgs.append(log(f" {cName}: {message}"))
G.S2SLogs.append(("M", (cName, message), sName)) G.S2SLogs.append(("M", (cName, message), sName))
writer.write( writer.write(
b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\r\n" b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
) )
case "A": case "A":
cName = buffer[2:].split(G.NUL, 1)[0] cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split(G.NUL, 1)[1] message = buffer[2:].split("|", 1)[1]
G.msgs.append(log(f"* {cName} {message}")) G.msgs.append(log(f"* {cName} {message}"))
G.S2SLogs.append(("A", (cName, message), sName)) G.S2SLogs.append(("A", (cName, message), sName))
writer.write(b"I Mmm... Strawberries\r\n") writer.write(b"I Mmm... Strawberries\n")
case "Q": case "Q":
break break
case "K": case "K":
cName = buffer[2:] cName = buffer[2:]
if not G.clientsConnected.get(cName.lower(), False): if G.clientsConnected[cName.lower()] == G.remoteID:
pass # They don't exist, safe to ignore
elif G.clientsConnected[cName.lower()] == G.remoteID:
G.killList[cName.lower()] = True G.killList[cName.lower()] = True
else: else:
G.servers[G.clientsConnected[cName.lower()]][ G.servers[G.clientsConnected[cName.lower()]][
cName.lower() cName.lower()
] = True ] = True
writer.write(b"I Mmm... Blood\r\n") writer.write(b"I Mmm... Blood\n")
case _: case _:
writer.write( writer.write(
f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\r\n".encode( f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\n".encode(
"utf8" "utf8"
) )
) )
@ -377,12 +345,12 @@ Please note that this is not network level statistics.\r\n""".encode(
"WARN", "WARN",
) )
await writer.drain() await writer.drain()
except TimeoutErrors: except TimeoutError:
pass pass
if any(G.servers[sName].values()): if any(G.servers[sName].values()):
for name in G.servers[sName]: for name in G.servers[sName]:
if G.servers[sName][name]: if G.servers[sName][name]:
writer.write(f"K {name}\r\n".encode("utf8")) writer.write(f"K {name}\n".encode("utf8"))
await writer.drain() await writer.drain()
G.servers[sName][name] = False G.servers[sName][name] = False
while msgInd < len(G.S2SLogs): while msgInd < len(G.S2SLogs):
@ -392,14 +360,14 @@ Please note that this is not network level statistics.\r\n""".encode(
match type: match type:
case "A": case "A":
nick, msg = data nick, msg = data
writer.write(f"A {nick}{G.NUL}{msg}\r\n".encode("utf8")) writer.write(f"A {nick}|{msg}\n".encode("utf8"))
case "M": case "M":
nick, msg = data nick, msg = data
writer.write(f"M {nick}{G.NUL}{msg}\r\n".encode("utf8")) writer.write(f"M {nick}|{msg}\n".encode("utf8"))
case "+": case "+":
writer.write(f"+ {data}\r\n".encode("utf8")) writer.write(f"+ {data}\n".encode("utf8"))
case "-": case "-":
writer.write(f"- {data}\r\n".encode("utf8")) writer.write(f"- {data}\n".encode("utf8"))
case _: case _:
pass pass
await writer.drain() await writer.drain()
@ -413,9 +381,11 @@ Please note that this is not network level statistics.\r\n""".encode(
del G.clientsConnected[cName.lower()] del G.clientsConnected[cName.lower()]
del G.servers[sName] del G.servers[sName]
G.msgs.append(log(f"{sName} has de-linked from the network")) G.msgs.append(log(f"{sName} has de-linked from the network"))
except DisconnectErrors: except (
if not name: ConnectionResetError,
return BrokenPipeError,
IndexError,
): # Don't ask. IndexError needs to be caught here too.
if not name.startswith("S2S-"): if not name.startswith("S2S-"):
G.uniqueClients -= 1 G.uniqueClients -= 1
G.msgs.append(log(f"{name} has disconnected from the server.")) G.msgs.append(log(f"{name} has disconnected from the server."))
@ -431,213 +401,178 @@ Please note that this is not network level statistics.\r\n""".encode(
pass pass
del G.servers[name[4:]] del G.servers[name[4:]]
G.msgs.append(log(f"{name[4:]} has de-linked from the network")) G.msgs.append(log(f"{name[4:]} has de-linked from the network"))
except Exception:
Err = format_exc()
for line in Err.split("\r\n"):
log(line, "ERROR")
async def connectServer(hostname: str, port: int): async def connectServer(hostname: str, port: int):
global G global G
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()
resp = raw((await reader.read(1024)).decode("utf8"))
if resp.startswith("K"):
if G.clientsConnected[client] == G.remoteID:
G.killList[client] = True
else:
G.servers[G.clientsConnected[client]][client] = True
writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
await writer.drain()
rID = raw((await reader.read(16)).decode("utf8"))
try: try:
reader, writer = await asyncio.open_connection(hostname, port) await asyncio.wait_for(reader.read(1024), 0.1)
ext, localQueue = await getMessage(reader, [], 1024) except TimeoutError:
writer.write(f"S2S-{G.remoteID}\r\n".encode("utf8")) pass
await writer.drain() if G.servers.get(rID, False) != False:
ext, localQueue = await getMessage(reader, [], 1024) writer.close()
for client in G.clientsConnected: await writer.wait_closed()
writer.write(f"{client}\r\n".encode("utf8")) return
if G.remoteID == rID:
writer.close()
await writer.wait_closed()
return
G.msgs.append(log(f"{rID} has linked to the network"))
G.servers[rID] = {}
writer.write(b"I recieved your remote ID, now awaiting client listing\n")
await writer.drain()
# recieve client list from the other server
while 1:
client = raw((await reader.read(1024)).decode("utf8"))
if client == f"END OF CLIENT LISTING FROM {rID}":
break
if client.lower() in G.servers[rID] or client.lower() in G.clientsConnected:
writer.write(b"K Client rejected: Already exists\n")
await writer.drain() await writer.drain()
resp, localQueue = await getMessage(reader, localQueue, 1024, 0, True) continue
if resp.startswith("K"): writer.write(b"I added that client.\n")
if G.clientsConnected[client] == G.remoteID:
G.killList[client] = True
else:
G.servers[G.clientsConnected[client]][client] = True
writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\r\n".encode("utf8"))
await writer.drain() await writer.drain()
rID = raw((await reader.read(16)).decode("utf8")) G.msgs.append(log(f"{client} has connected from {rID}"))
try: G.servers[rID][client.lower()] = False
await asyncio.wait_for(reader.read(1024), 0.1) for client in G.servers[rID]:
except TimeoutErrors: G.clientsConnected[client] = rID
pass msgInd = len(G.S2SLogs)
if G.servers.get(rID, False) != False: try:
writer.close()
await writer.wait_closed()
return
if G.remoteID == rID or not rID:
writer.close()
await writer.wait_closed()
return
G.msgs.append(log(f"{rID} has linked to the network"))
G.servers[rID] = {}
writer.write(b"I recieved your remote ID, now awaiting client listing\r\n")
await writer.drain()
# recieve client list from the other server
while 1: while 1:
client, localQueue = await getMessage(reader, localQueue, 1024, 0, True) try:
if client == f"END OF CLIENT LISTING FROM {rID}": rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
break buffer = raw(rawMsg.decode("utf8"))
if client.lower() in G.servers[rID] or client.lower() in G.clientsConnected: match buffer[0]:
writer.write(b"K Client rejected: Already exists\r\n") case "S":
await writer.drain() G.msgs.extend([log(buffer[2:])])
continue writer.write(b"I Mmm... Blueberries\n")
writer.write(b"I added that client.\r\n") case "I":
await writer.drain() pass
G.msgs.append(log(f"{client} has connected from {rID}")) case "+":
G.servers[rID][client.lower()] = False cName = buffer[2:]
for client in G.servers[rID]: if cName.lower() not in G.clientsConnected:
G.clientsConnected[client] = rID G.msgs.append(log(f"{cName} has connected from {rID}"))
msgInd = len(G.S2SLogs) G.S2SLogs.append(("+", cName, rID))
try: G.servers[rID][cName.lower()] = False
while 1: G.clientsConnected[cName.lower()] = rID
try: writer.write(b"I Mmm... Pineapples\n")
buffer, localQueue = await getMessage(reader, localQueue, 1024, 0.1, False) else:
match buffer[0]: writer.write(f"K {cName}\n".encode("utf8"))
case "S": case "-":
G.msgs.extend([log(buffer[2:])]) cName = buffer[2:]
writer.write(b"I Mmm... Blueberries\r\n") if G.clientsConnected.get(cName.lower(), None) == rID:
case "I": G.msgs.append(log(f"{cName} has disconnected from {rID}"))
pass del G.servers[rID][cName.lower()]
case "+": del G.clientsConnected[cName.lower()]
cName = buffer[2:] G.S2SLogs.append(("-", cName, rID))
if cName.lower() not in G.clientsConnected: else:
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
writer.write(b"I Mmm... Pineapples\r\n")
else:
writer.write(f"K {cName}\r\n".encode("utf8"))
case "-":
cName = buffer[2:]
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(
f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\r\n".encode(
"utf8"
)
)
case "M":
cName = buffer[2:].split(G.NUL, 1)[0]
message = buffer[2:].split(G.NUL, 1)[1]
G.msgs.append(log(f" {cName}: {message}"))
G.S2SLogs.append(("M", (cName, message), rID))
writer.write( writer.write(
b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\r\n" f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
)
case "A":
cName = buffer[2:].split(G.NUL, 1)[0]
message = buffer[2:].split(G.NUL, 1)[1]
G.S2SLogs.append(("A", (cName, message), rID))
G.msgs.append(log(f"* {cName} {message}"))
writer.write(b"I Mmm... Strawberries\r\n")
case "Q":
break
case "K":
cName = buffer[2:]
if not G.clientsConnected.get(cName.lower(), False):
pass # They don't exist, safe to ignore
elif G.clientsConnected[cName.lower()] == G.remoteID:
G.killList[cName.lower()] = True
else:
G.servers[G.clientsConnected[cName.lower()]][
cName.lower()
] = True
writer.write(b"I Mmm... Blood\r\n")
case _:
writer.write(
f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\r\n".encode(
"utf8" "utf8"
) )
) )
log( case "M":
f"Recieved invalid message ({buffer}) from {rID}", cName = buffer[2:].split("|", 1)[0]
"WARN", message = buffer[2:].split("|", 1)[1]
G.msgs.append(log(f" {cName}: {message}"))
G.S2SLogs.append(("M", (cName, message), rID))
writer.write(
b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
)
case "A":
cName = buffer[2:].split("|", 1)[0]
message = buffer[2:].split("|", 1)[1]
G.S2SLogs.append(("A", (cName, message), rID))
G.msgs.append(log(f"* {cName} {message}"))
writer.write(b"I Mmm... Strawberries\n")
case "Q":
break
case "K":
cName = buffer[2:]
if G.clientsConnected[cName.lower()] == G.remoteID:
G.killList[cName.lower()] = True
else:
G.servers[G.clientsConnected[cName.lower()]][
cName.lower()
] = True
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"
) )
await writer.drain() )
except TimeoutErrors: log(f"Recieved invalid message ({buffer}) from {sName}", "WARN")
pass await writer.drain()
if any(G.servers[rID].values()): except TimeoutError:
for name in G.servers[rID]: pass
if G.servers[rID][name]: if any(G.servers[rID].values()):
writer.write(f"K {name}\r\n".encode("utf8")) for name in G.servers[rID]:
await writer.drain() if G.servers[rID][name]:
G.servers[rID][name] = False writer.write(f"K {name}\n".encode("utf8"))
while msgInd < len(G.S2SLogs): await writer.drain()
type, data, server = G.S2SLogs[msgInd] G.servers[rID][name] = False
if server != rID: while msgInd < len(G.S2SLogs):
match type: type, data, server = G.S2SLogs[msgInd]
case "A": if server != rID:
nick, msg = data match type:
writer.write(f"A {nick}{G.NUL}{msg}\r\n".encode("utf8")) case "A":
case "M": nick, msg = data
nick, msg = data writer.write(f"A {nick}|{msg}\n".encode("utf8"))
writer.write(f"M {nick}{G.NUL}{msg}\r\n".encode("utf8")) case "M":
case "+": nick, msg = data
writer.write(f"+ {data}\r\n".encode("utf8")) writer.write(f"M {nick}|{msg}\n".encode("utf8"))
case "-": case "+":
writer.write(f"- {data}\r\n".encode("utf8")) writer.write(f"+ {data}\n".encode("utf8"))
case _: case "-":
pass writer.write(f"- {data}\n".encode("utf8"))
await writer.drain() case _:
msgInd += 1 pass
if G.cwlgd: await writer.drain()
raise LinkDownError msgInd += 1
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()]
del G.servers[rID]
G.msgs.append(log(f"{rID} has de-linked from the network"))
except DisconnectErrors:
if G.cwlgd:
raise LinkDownError
for cName in G.servers[rID]:
G.msgs.append(log(f"{cName}'s server is going down"))
try:
del G.clientsConnected[cName.lower()]
except Exception:
pass
del G.servers[rID]
G.msgs.append(log(f"{rID} has de-linked from the network"))
except OSError as E:
log("OSError: " + str(E), "ERROR")
if G.cwlgd: if G.cwlgd:
raise FailedLinkError raise LinksDownException
except Exception: await writer.drain()
Err = format_exc() writer.close()
for line in Err.split("\r\n"): await writer.wait_closed()
log(line, "ERROR") for cName in G.servers[rID]:
raise FailedLinkError G.msgs.append(log(f"{cName}'s server is going down"))
del G.clientsConnected[cName.lower()]
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
for cName in G.servers[rID]:
G.msgs.append(log(f"{cName}'s server is going down"))
try:
del G.clientsConnected[cName.lower()]
except Exception:
pass
del G.servers[rID]
G.msgs.append(log(f"{rID} has de-linked from the network"))
async def runServer(address: str, port: int): async def runServer(address: str, port: int):
global G global G
sock = None server = await asyncio.start_server(handleClient, address, port)
try:
if ":" in address:
INET = socket.AF_INET6
else:
INET = socket.AF_INET
sock = socket.socket(INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Reuse socket
sock.bind((address, port))
except OSError as E:
if E.errno != 97 or address != '::':
raise E
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Reuse socket
sock.bind(('0.0.0.0', port))
server = await asyncio.start_server(handleClient, sock=sock)
log(f"Listening on port {port}...") log(f"Listening on port {port}...")
G.msgs.append(log("Server startup")) G.msgs.append(log("Server startup"))
links = [] links = []
@ -647,17 +582,12 @@ async def runServer(address: str, port: int):
try: try:
links.append(G.event.wait()) links.append(G.event.wait())
await asyncio.gather(*links) await asyncio.gather(*links)
except LinkDownError:
G.msgs.append(log("Lost a server link, going down", "FATAL")[1:])
crash = True
except FailedLinkError:
G.msgs.append(log("Failed to establish a server link, going down", "FATAL")[1:])
except Exception: except Exception:
crash = True crash = True
G.msgs.append(log("Server crash", "FATAL")[1:]) G.msgs.append(log("Server crash", "FATAL")[1:])
log("Shutting down from Exception", "FATAL") log("Shutting down from Exception", "FATAL")
Err = format_exc() Err = format_exc()
for line in Err.split("\r\n"): for line in Err.split("\n"):
log(line, "ERROR") log(line, "ERROR")
finally: finally:
if not crash: if not crash:
@ -667,11 +597,10 @@ async def runServer(address: str, port: int):
# server.abort_clients() # server.abort_clients()
if saveLogs: if saveLogs:
with open("cache.py", "w") as cache: with open("cache.py", "w") as cache:
cache.write(f"msgs = {G.msgs}\r\n") cache.write(f"msgs = {G.msgs}\n")
log("Saved logs, exiting now.") log("Saved logs, exiting now.")
else: else:
log("Not saving logs, exiting now.") log("Not saving logs, exiting now.")
sock.close()
class ServerInterruptException(KeyboardInterrupt): ... class ServerInterruptException(KeyboardInterrupt): ...